gnc-plugin-page.c

Go to the documentation of this file.

/*
 * gnc-plugin_page.c --
 *
 * Copyright (C) 2003 Jan Arne Petersen <jpetersen@uni-bonn.de>
 * Copyright (C) 2003,2005 David Hampton <hampton@employees.org>
 *
 * 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, contact:
 *
 * Free Software Foundation           Voice:  +1-617-542-5942
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652
 * Boston, MA  02110-1301,  USA       gnu@gnu.org
 */
 
#include <config.h>
 
#include <gtk/gtk.h>
#include "gnc-engine.h"
#include "gnc-plugin.h"
#include "gnc-plugin-page.h"
#include "gnc-gobject-utils.h"
#include "gnc-ui.h"
 
static QofLogModule log_module = GNC_MOD_GUI;
 
static void gnc_plugin_page_constructed (GObject *object);
static void gnc_plugin_page_finalize   (GObject *object);
static void gnc_plugin_page_set_property (GObject      *object,
                                          guint         prop_id,
                                          const GValue *value,
                                          GParamSpec   *pspec);
static void gnc_plugin_page_get_property (GObject      *object,
                                          guint         prop_id,
                                          GValue       *value,
                                          GParamSpec   *pspec);
 
static void gnc_plugin_page_default_focus (GncPluginPage *plugin_page,
                                           gboolean on_current_page);
 
enum
{
    INSERTED,
    REMOVED,
    SELECTED,
    UNSELECTED,
    LAST_SIGNAL
};
 
enum
{
    PROP_0,
    PROP_PAGE_NAME,
    PROP_PAGE_COLOR,
    PROP_BOOK,
    PROP_STATUSBAR_TEXT,
    PROP_USE_NEW_WINDOW,
    PROP_UI_DESCRIPTION,
};
 
static guint signals[LAST_SIGNAL] = { 0 };
 
 
typedef struct _GncPluginPagePrivate
{
    char *ui_description;
 
    GtkBuilder *builder;
    GSimpleActionGroup *simple_action_group;
    const gchar *simple_action_group_name;
    const gchar *menu_qualifier;
    const gchar *menu_popup_qualifier;
 
    GList *books;
 
    gboolean use_new_window;
 
    gchar *page_name;
    gchar *page_long_name;
    gchar *page_color;
    gchar *uri;
    gchar *statusbar_text;
 
    gulong page_changed_id;
    guint  focus_source_id;
 
} GncPluginPagePrivate;
 
G_DEFINE_TYPE_WITH_CODE(GncPluginPage, gnc_plugin_page, G_TYPE_OBJECT,
                G_ADD_PRIVATE(GncPluginPage))
 
#define GNC_PLUGIN_PAGE_GET_PRIVATE(o)  \
     ((GncPluginPagePrivate*)gnc_plugin_page_get_instance_private((GncPluginPage*)o))
 
/*  Create the display widget that corresponds to this plugin.  This
 *  function will be called by the main/embedded window manipulation
 *  code to create a widget that they can display.  The returned
 *  widget should encompass all information that goes with this page,
 *  including scroll bars, a summary bar, etc. */
GtkWidget *
gnc_plugin_page_create_widget (GncPluginPage *plugin_page)
{
    GncPluginPageClass *klass;
    GtkWidget *widget;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page), NULL);
 
    klass = GNC_PLUGIN_PAGE_GET_CLASS(plugin_page);
    g_return_val_if_fail (klass != NULL, NULL);
    g_return_val_if_fail (klass->create_widget != NULL, NULL);
 
    widget = klass->create_widget (plugin_page);
 
    /*
     * If there is a destroy function, add a ref so that the
     * widgets will exists when the destroy function is called.
     * Otherwise it will be destroyed when it is removed from the
     * main notebook for the window.
     */
    if (klass->destroy_widget)
        g_object_ref (widget);
 
    return widget;
}
 
 
/*  Destroy the display widget that corresponds to this plugin.  This
 *  function will be called by the main/embedded window manipulation
 *  code when a page is closed. */
void
gnc_plugin_page_destroy_widget (GncPluginPage *plugin_page)
{
    GncPluginPageClass *klass;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page));
 
    klass = GNC_PLUGIN_PAGE_GET_CLASS(plugin_page);
    g_return_if_fail (klass != NULL);
    g_return_if_fail (klass->destroy_widget != NULL);
 
    klass->destroy_widget (plugin_page);
}
 
 
/*  Show/hide the summarybar associated with this page. */
void
gnc_plugin_page_show_summarybar (GncPluginPage *page,
                                 gboolean visible)
{
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    if (!page->summarybar)
        return;
 
    if (visible)
        gtk_widget_show (page->summarybar);
    else
        gtk_widget_hide (page->summarybar);
}
 
 
/*  Call the plugin specific function that will save the state of a
 *  content page to a disk.  That function must save enough
 *  information about the page that it can be recreated next time the
 *  user starts gnucash. */
void
gnc_plugin_page_save_page (GncPluginPage *page,
                           GKeyFile *key_file,
                           const gchar *group_name)
{
    GncPluginPageClass *klass;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
    g_return_if_fail (key_file != NULL);
    g_return_if_fail (group_name != NULL);
 
    ENTER(" ");
    klass = GNC_PLUGIN_PAGE_GET_CLASS(page);
    g_return_if_fail (klass != NULL);
    g_return_if_fail (klass->save_page != NULL);
 
    klass->save_page (page, key_file, group_name);
    LEAVE(" ");
}
 
 
/*  This function looks up a specific plugin type by name, and then
 *  calls a plugin specific function to create a new page and restore
 *  its content to a previous state. */
GncPluginPage *
gnc_plugin_page_recreate_page(GtkWidget *window,
                              const gchar *page_type,
                              GKeyFile *key_file,
                              const gchar *page_group)
{
    GncPluginPageClass *klass;
    GncPluginPage *page = NULL;
    GType type;
 
    ENTER("type %s, keyfile %p, group %s", page_type, key_file, page_group);
    type = g_type_from_name (page_type);
    if (type == 0)
    {
        LEAVE("Cannot find type named %s", page_type);
        return NULL;
    }
 
    klass = g_type_class_ref (type);
    if (klass == NULL)
    {
        const gchar *type_name = g_type_name (type);
        LEAVE("Cannot create class %s(%s)", page_type, type_name ? type_name : "invalid type");
        return NULL;
    }
 
    if (!klass->recreate_page)
    {
        LEAVE("Class %shas no recreate function.", page_type);
        g_type_class_unref (klass);
        return NULL;
    }
 
    page = (klass->recreate_page)(window, key_file, page_group);
    g_type_class_unref (klass);
    LEAVE(" ");
    return page;
}
 
 
void
gnc_plugin_page_merge_actions (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
    GError *error = NULL;
    gchar *resource;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    if (!priv->builder)
        priv->builder = gtk_builder_new ();
 
    resource = g_strconcat (GNUCASH_RESOURCE_PREFIX "/", priv->ui_description, NULL);
 
    gtk_builder_set_translation_domain (priv->builder, PROJECT_NAME);
 
    gtk_builder_add_from_resource (priv->builder, resource, &error);
 
    if (error)
    {
        g_critical ("Failed to load ui resource %s, Error %s", resource, error->message);
        g_error_free (error);
    }
    g_free (resource);
}
 
 
GAction *
gnc_plugin_page_get_action (GncPluginPage *page, const gchar *name)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
    g_return_val_if_fail (name != NULL, NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    if (!priv->simple_action_group)
        return NULL;
    return g_action_map_lookup_action (G_ACTION_MAP(priv->simple_action_group), name);
}
 
 
/*  Retrieve the textual name of a plugin. */
const gchar *
gnc_plugin_page_get_plugin_name (GncPluginPage *plugin_page)
{
    GncPluginPageClass *klass;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page), NULL);
 
    klass = GNC_PLUGIN_PAGE_GET_CLASS(plugin_page);
    g_return_val_if_fail (klass != NULL, NULL);
 
    return (klass->plugin_name);
}
 
 
/* Signals */
void
gnc_plugin_page_inserted (GncPluginPage *plugin_page)
{
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page));
 
    g_signal_emit (G_OBJECT(plugin_page), signals[INSERTED], 0);
}
 
void
gnc_plugin_page_removed (GncPluginPage *plugin_page)
{
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page));
 
    g_signal_emit (G_OBJECT(plugin_page), signals[REMOVED], 0);
}
 
void
gnc_plugin_page_selected (GncPluginPage *plugin_page)
{
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page));
 
    g_signal_emit (G_OBJECT(plugin_page), signals[SELECTED], 0);
}
 
void
gnc_plugin_page_unselected (GncPluginPage *plugin_page)
{
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page));
 
    g_signal_emit (G_OBJECT(plugin_page), signals[UNSELECTED], 0);
}
 
static void
gnc_plugin_page_class_init (GncPluginPageClass *klass)
{
    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 
    gobject_class->constructed = gnc_plugin_page_constructed;
    gobject_class->finalize = gnc_plugin_page_finalize;
    gobject_class->set_property = gnc_plugin_page_set_property;
    gobject_class->get_property = gnc_plugin_page_get_property;
 
    klass->tab_icon    = NULL;
    klass->plugin_name = NULL;
    klass->focus_page = gnc_plugin_page_default_focus;
 
    g_object_class_install_property
    (gobject_class,
     PROP_PAGE_NAME,
     g_param_spec_string ("page-name",
                          "Page Name",
                          "The name of this page.  This value is "
                          "used to generate the notebook tab and "
                          "menu items, and also the window title "
                          "when this page is visible.",
                          NULL,
                          G_PARAM_READWRITE));
 
    g_object_class_install_property
    (gobject_class,
     PROP_PAGE_COLOR,
     g_param_spec_string ("page-color",
                          "Page Color",
                          "The color of this page.  This value is "
                          "used to generate the notebook tab color "
                          "when this page is visible.",
                          NULL,
                          G_PARAM_READWRITE));
 
    g_object_class_install_property
    (gobject_class,
     PROP_STATUSBAR_TEXT,
     g_param_spec_string ("statusbar-text",
                          "Statusbar Text",
                          "The text to be displayed in the statusbar "
                          "at the bottom of the window when this page "
                          "is visible.",
                          NULL,
                          G_PARAM_READWRITE));
 
    g_object_class_install_property
    (gobject_class,
     PROP_USE_NEW_WINDOW,
     g_param_spec_boolean ("use-new-window",
                           "Use New Window",
                           "When TRUE a new top level window will be "
                           "created to hold this page.",
                           FALSE,
                           G_PARAM_READWRITE));
 
    g_object_class_install_property
    (gobject_class,
     PROP_UI_DESCRIPTION,
     g_param_spec_string ("ui-description",
                          "UI Description File",
                          "The filename containing the XML data that "
                          "describes this pages menus and toolbars.",
                          NULL,
                          G_PARAM_READWRITE));
 
 
 
    signals[INSERTED] = g_signal_new ("inserted",
                                      G_OBJECT_CLASS_TYPE (klass),
                                      G_SIGNAL_RUN_FIRST,
                                      G_STRUCT_OFFSET (GncPluginPageClass, inserted),
                                      NULL, NULL,
                                      g_cclosure_marshal_VOID__VOID,
                                      G_TYPE_NONE,
                                      0);
    signals[REMOVED] = g_signal_new ("removed",
                                     G_OBJECT_CLASS_TYPE (klass),
                                     G_SIGNAL_RUN_FIRST,
                                     G_STRUCT_OFFSET (GncPluginPageClass, removed),
                                     NULL, NULL,
                                     g_cclosure_marshal_VOID__VOID,
                                     G_TYPE_NONE,
                                     0);
    signals[SELECTED] = g_signal_new ("selected",
                                      G_OBJECT_CLASS_TYPE (klass),
                                      G_SIGNAL_RUN_FIRST,
                                      G_STRUCT_OFFSET (GncPluginPageClass, selected),
                                      NULL, NULL,
                                      g_cclosure_marshal_VOID__VOID,
                                      G_TYPE_NONE,
                                      0);
    signals[UNSELECTED] = g_signal_new ("unselected",
                                        G_OBJECT_CLASS_TYPE (klass),
                                        G_SIGNAL_RUN_FIRST,
                                        G_STRUCT_OFFSET (GncPluginPageClass, unselected),
                                        NULL, NULL,
                                        g_cclosure_marshal_VOID__VOID,
                                        G_TYPE_NONE,
                                        0);
}
 
 
static void
gnc_plugin_page_init (GncPluginPage *page)
{
    GncPluginPagePrivate *priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    priv->page_name   = NULL;
    priv->page_color  = NULL;
    priv->page_changed_id = 0;
    priv->focus_source_id = 0;
    priv->menu_qualifier = NULL;
 
    page->window      = NULL;
    page->summarybar  = NULL;
}
 
 static void
gnc_plugin_page_constructed (GObject *obj)
{
    gnc_gobject_tracking_remember(obj);
 
    G_OBJECT_CLASS (gnc_plugin_page_parent_class)->constructed (obj);
}
 
static void
gnc_plugin_page_finalize (GObject *object)
{
    GncPluginPagePrivate *priv;
    GncPluginPage *page;
 
    page = GNC_PLUGIN_PAGE(object);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    if (priv->ui_description)
        g_free (priv->ui_description);
 
    if (priv->page_name)
        g_free (priv->page_name);
 
    if (priv->page_long_name)
        g_free (priv->page_long_name);
 
    if (priv->page_color)
        g_free (priv->page_color);
 
    if (priv->statusbar_text)
        g_free (priv->statusbar_text);
 
    if (priv->books)
    {
        g_list_free (priv->books);
        priv->books = NULL;
    }
 
    if (priv->builder)
        g_object_unref (priv->builder);
 
    page->window = NULL; // Don't need to free it.
 
    gnc_gobject_tracking_forget (object);
    G_OBJECT_CLASS(gnc_plugin_page_parent_class)->finalize (object);
}
 
/************************************************************/
/*                g_object other functions                  */
/************************************************************/
 
 
/* Note that g_value_set_object() refs the object, as does
 * g_object_get(). But g_object_get() only unrefs once when it disgorges
 * the object, leaving an unbalanced ref, which leaks. So instead of
 * using g_value_set_object(), use g_value_take_object() which doesn't
 * ref the object when used in get_property().
 */
static void
gnc_plugin_page_get_property (GObject     *object,
                              guint        prop_id,
                              GValue      *value,
                              GParamSpec  *pspec)
{
    GncPluginPage *page;
    GncPluginPagePrivate *priv;
 
    g_return_if_fail(GNC_IS_PLUGIN_PAGE(object));
 
    page = GNC_PLUGIN_PAGE(object);
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    switch (prop_id)
    {
    case PROP_PAGE_NAME:
        g_value_set_string (value, priv->page_name);
        break;
    case PROP_PAGE_COLOR:
        g_value_set_string (value, priv->page_color);
        break;
    case PROP_STATUSBAR_TEXT:
        g_value_set_string (value, priv->statusbar_text);
        break;
    case PROP_USE_NEW_WINDOW:
        g_value_set_boolean (value, priv->use_new_window);
        break;
    case PROP_UI_DESCRIPTION:
        g_value_set_string (value, priv->ui_description);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        break;
    }
}
 
 
static void
gnc_plugin_page_set_property (GObject      *object,
                              guint         prop_id,
                              const GValue *value,
                              GParamSpec   *pspec)
{
    GncPluginPage *page;
 
    g_return_if_fail(GNC_IS_PLUGIN_PAGE(object));
 
    page = GNC_PLUGIN_PAGE(object);
 
    switch (prop_id)
    {
    case PROP_PAGE_NAME:
        gnc_plugin_page_set_page_name (page, g_value_get_string (value));
        break;
    case PROP_PAGE_COLOR:
        gnc_plugin_page_set_page_color (page, g_value_get_string (value));
        break;
    case PROP_STATUSBAR_TEXT:
        gnc_plugin_page_set_statusbar_text (page, g_value_get_string (value));
        break;
    case PROP_USE_NEW_WINDOW:
        gnc_plugin_page_set_use_new_window (page, g_value_get_boolean (value));
        break;
    case PROP_UI_DESCRIPTION:
        gnc_plugin_page_set_ui_description (page, g_value_get_string (value));
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        break;
    }
}
 
/************************************************************/
/*                                                          */
/************************************************************/
 
/*  Add a book reference to the specified page. */
void
gnc_plugin_page_add_book (GncPluginPage *page, QofBook *book)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
    g_return_if_fail (book != NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    priv->books = g_list_append (priv->books, book);
}
 
 
/*  Query a page to see if it has a reference to a given book. */
gboolean
gnc_plugin_page_has_book (GncPluginPage *page, QofBook *book)
{
    GncPluginPagePrivate *priv;
    GList *item;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), FALSE);
    g_return_val_if_fail (book != NULL, FALSE);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    for (item = priv->books; item; item = g_list_next (item))
    {
        if (item->data == book)
        {
            return TRUE;
        }
    }
    return FALSE;
}
 
 
/*  Query a page to see if it has a reference to any book. */
gboolean
gnc_plugin_page_has_books (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), FALSE);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return (priv->books != NULL);
}
 
 
/*  Retrieve a pointer to the GncMainWindow (GtkWindow) containing
 *  this page. */
GtkWidget *
gnc_plugin_page_get_window (GncPluginPage *page)
{
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    return page->window;
}
 
 
/*  Retrieve the name of this page.  This is the string used in the
 *  window title, and in the notebook tab and page selection menus. */
const gchar *
gnc_plugin_page_get_page_name (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->page_name;
}
 
 
/*  Set the name of this page.  This is the string used in the window
 *  title, and in the notebook tab and page selection menus. */
void
gnc_plugin_page_set_page_name (GncPluginPage *page, const gchar *name)
{
    GncPluginPagePrivate *priv;
    GncPluginPageClass *klass;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    if (priv->page_name)
        g_free (priv->page_name);
 
    priv->page_name = g_strdup (name);
 
    /* Perform page specific actions */
    klass = GNC_PLUGIN_PAGE_GET_CLASS (page);
    if (klass->page_name_changed)
    {
        klass->page_name_changed(page, name);
    }
}
 
 
/*  Retrieve the long name of this page.  This is the string used in
 *  the tooltip that is attached to the page name in the notebook
 *  tab. */
const gchar *
gnc_plugin_page_get_page_long_name (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->page_long_name;
}
 
 
/*  Set the long name of this page.  This is the string used in the
 *  tooltip that is attached to the page name in the notebook tab. */
void
gnc_plugin_page_set_page_long_name (GncPluginPage *page, const gchar *name)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    if (priv->page_long_name)
        g_free (priv->page_long_name);
 
    priv->page_long_name = g_strdup (name);
}
 
 
/*  Get the color of this page.  This is the string used in the notebook tab. */
const gchar *
gnc_plugin_page_get_page_color (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->page_color;
}
 
 
/*  Set the color of this page.  This is the string used in the notebook tab. */
void
gnc_plugin_page_set_page_color (GncPluginPage *page, const gchar *color)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    if (priv->page_color)
        g_free (priv->page_color);
 
    if (color)
        priv->page_color = g_strdup (color);
}
 
 
static void
gnc_plugin_page_focus_idle_destroy (GncPluginPage *plugin_page)
{
    GncPluginPagePrivate *priv = GNC_PLUGIN_PAGE_GET_PRIVATE(plugin_page);
    priv->focus_source_id = 0;
}
 
 
static void
gnc_plugin_page_default_focus (GncPluginPage *plugin_page,
                               gboolean on_current_page)
{
    GncPluginPagePrivate *priv;
 
    if (!on_current_page)
        return;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(plugin_page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(plugin_page);
 
    if (G_LIKELY(GNC_PLUGIN_PAGE_GET_CLASS(plugin_page)->focus_page_function))
    {
        // The page changed signal is emitted multiple times so we need
        // to use an idle_add to change the focus
 
        if (priv->focus_source_id > 0)
            g_source_remove (priv->focus_source_id);
 
        priv->focus_source_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
                                    (GSourceFunc)(GNC_PLUGIN_PAGE_GET_CLASS(plugin_page)->focus_page_function),
                                    GNC_PLUGIN_PAGE(plugin_page),
                                    (GDestroyNotify)gnc_plugin_page_focus_idle_destroy);
    }
}
 
 
/* this is the callback for the plugin "page_changed" signal */
static void
gnc_plugin_page_main_window_changed (GtkWindow *window,
                                     GObject *object,
                                     gpointer user_data)
{
    GncPluginPage *current_plugin_page = GNC_PLUGIN_PAGE(object);
    GncPluginPage *plugin_page = GNC_PLUGIN_PAGE(user_data);
    gboolean on_current_page = FALSE;
 
    // Continue if current_plugin_page is valid
    if (!current_plugin_page || !GNC_IS_PLUGIN_PAGE(current_plugin_page))
        return;
 
    // Continue only if the plugin_page is valid
    if (!plugin_page || !GNC_IS_PLUGIN_PAGE(plugin_page))
        return;
 
    if (current_plugin_page == plugin_page)
        on_current_page = TRUE;
 
    (GNC_PLUGIN_PAGE_GET_CLASS(plugin_page)->focus_page)(plugin_page, on_current_page);
}
 
 
/* this is the callback for the plugin "inserted" signal which will setup
 * the callback for the "page_changed" signal and save a pointer to the
 * page focus function. */
void
gnc_plugin_page_inserted_cb (GncPluginPage *page, gpointer user_data)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    priv->page_changed_id = g_signal_connect (G_OBJECT(page->window), "page_changed",
                                              G_CALLBACK(gnc_plugin_page_main_window_changed),
                                              page);
 
    // on initial load try and set the page focus
    if (!gnc_main_window_is_restoring_pages (GNC_MAIN_WINDOW (gnc_ui_get_main_window (page->window))))
        (GNC_PLUGIN_PAGE_GET_CLASS(page)->focus_page)(page, TRUE);
}
 
 
/* disconnect the page_changed callback */
void
gnc_plugin_page_disconnect_page_changed (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    if (priv->page_changed_id > 0)
    {
        g_signal_handler_disconnect (G_OBJECT(page->window), priv->page_changed_id);
        priv->page_changed_id = 0;
    }
}
 
 
/*  Retrieve the statusbar text associated with this page. */
const gchar *
gnc_plugin_page_get_statusbar_text (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->statusbar_text;
}
 
 
/*  Set the statusbar text associated with this page. */
void
gnc_plugin_page_set_statusbar_text (GncPluginPage *page, const gchar *message)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    if (priv->statusbar_text)
        g_free (priv->statusbar_text);
 
    priv->statusbar_text = g_strdup (message);
}
 
 
/*  Retrieve the "use new window" setting associated with this page. */
gboolean
gnc_plugin_page_get_use_new_window (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), FALSE);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->use_new_window;
}
 
 
/*  Set the "use new window" setting associated with this page.  If
 *  this setting is TRUE, the page will be installed into a new
 *  window.  Otherwise the page will be installed into an existing
 *  window. */
void
gnc_plugin_page_set_use_new_window (GncPluginPage *page, gboolean use_new)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    priv->use_new_window = use_new;
}
 
 
/*  Retrieve the name of the XML UI file associated with this page. */
const gchar *
gnc_plugin_page_get_ui_description (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), FALSE);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->ui_description;
}
 
 
/*  Set an alternate UI for the specified page.  This alternate ui
 *  may only use actions specified in the source for the page. */
void
gnc_plugin_page_set_ui_description (GncPluginPage *page,
                                    const char *ui_filename)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    if (priv->ui_description)
        g_free (priv->ui_description);
 
    priv->ui_description = g_strdup (ui_filename);
}
 
 
/*  Retrieve the GtkBuilder object associated with this page. */
GtkBuilder *
gnc_plugin_page_get_builder (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->builder;
}
 
 
/*  Retrieve the menu qualifier associated with this page. */
const gchar *
gnc_plugin_page_get_menu_qualifier (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->menu_qualifier;
}
 
void
gnc_plugin_page_set_menu_qualifier (GncPluginPage *page,
                                    const char *menu_qualifier)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    priv->menu_qualifier = menu_qualifier;
}
 
const gchar *
gnc_plugin_page_get_menu_popup_qualifier (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->menu_popup_qualifier;
}
 
void
gnc_plugin_page_set_menu_popup_qualifier (GncPluginPage *page,
                                    const char *menu_qualifier)
{
    GncPluginPagePrivate *priv;
 
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    priv->menu_popup_qualifier = menu_qualifier;
}
 
 
GSimpleActionGroup *
gnc_plugin_page_get_action_group (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
    return priv->simple_action_group;
}
 
GSimpleActionGroup *
gnc_plugin_page_create_action_group (GncPluginPage *page, const gchar *group_name)
{
    GncPluginPagePrivate *priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    priv->simple_action_group = g_simple_action_group_new ();
    priv->simple_action_group_name = group_name;
 
    return priv->simple_action_group;
}
 
const gchar *
gnc_plugin_page_get_simple_action_group_name (GncPluginPage *page)
{
    GncPluginPagePrivate *priv;
 
    g_return_val_if_fail (GNC_IS_PLUGIN_PAGE(page), NULL);
 
    priv = GNC_PLUGIN_PAGE_GET_PRIVATE(page);
 
    return priv->simple_action_group_name;
}
 
gboolean
gnc_plugin_page_finish_pending (GncPluginPage *page)
{
    if (!page)
        return TRUE;
 
    if (!GNC_IS_PLUGIN_PAGE(page))
        return TRUE;
 
    if (!GNC_PLUGIN_PAGE_GET_CLASS(page)->finish_pending)
        return TRUE;
 
    return (GNC_PLUGIN_PAGE_GET_CLASS(page)->finish_pending)(page);
}