gnc-embedded-window.c

/*
 * gnc-main-window.c -- GtkWindow which represents the
 *  GnuCash main window.
 *
 * Copyright (C) 2003 Jan Arne Petersen <jpetersen@uni-bonn.de>
 * Copyright (C) 2003 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-embedded-window.h"
 
#include "gnc-engine.h"
#include "gnc-filepath-utils.h"
#include "gnc-gnome-utils.h"
#include "gnc-gobject-utils.h"
#include "gnc-gui-query.h"
#include "gnc-plugin.h"
#include "gnc-plugin-manager.h"
#include "gnc-ui.h"
#include "gnc-window.h"
#include "dialog-utils.h"
#include "gnc-gtk-utils.h"
 
enum
{
    PAGE_CHANGED,
    LAST_SIGNAL
};
 
/* Static Globals *******************************************************/
 
static QofLogModule log_module = GNC_MOD_GUI;
 
 
/* Declarations *********************************************************/
static void gnc_embedded_window_constructed (GObject *object);
static void gnc_embedded_window_finalize (GObject *object);
static void gnc_embedded_window_dispose (GObject *object);
 
static void gnc_window_embedded_window_init (GncWindowInterface *iface);
 
static void gnc_embedded_window_setup_window (GncEmbeddedWindow *window);
 
struct _GncEmbeddedWindow
{
    GtkBox vbox;
 
    GtkWidget *menu_dock;
    GtkWidget *menubar;
    GMenuModel *menubar_model;
    GtkWidget *toolbar;
    GtkWidget *statusbar;
 
    GSimpleActionGroup *simple_action_group;
 
    GtkAccelGroup *accel_group;
 
    GncPluginPage *page;
    GtkWidget *parent_window;
};
 
G_DEFINE_TYPE_WITH_CODE(GncEmbeddedWindow, gnc_embedded_window, GTK_TYPE_BOX,
                        G_IMPLEMENT_INTERFACE(GNC_TYPE_WINDOW,
                                              gnc_window_embedded_window_init))
 
 
static guint embedded_window_signals[LAST_SIGNAL] = { 0 };
 
/*  Display a data plugin page in a window. */
void
gnc_embedded_window_open_page (GncEmbeddedWindow *window,
                               GncPluginPage *page)
{
    g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (window));
    g_return_if_fail (GNC_IS_PLUGIN_PAGE (page));
    g_return_if_fail (window->page == NULL);
 
    ENTER("window %p, page %p", window, page);
    window->page = page;
    page->window = GTK_WIDGET(window);
    page->notebook_page = gnc_plugin_page_create_widget (page);
 
    gtk_box_pack_end(GTK_BOX(window), page->notebook_page, TRUE, TRUE, 2);
    gnc_plugin_page_inserted (page);
    LEAVE(" ");
}
 
 
/*  Remove a data plugin page from a window. */
void
gnc_embedded_window_close_page (GncEmbeddedWindow *window,
                                GncPluginPage *page)
{
    g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (window));
    g_return_if_fail (GNC_IS_PLUGIN_PAGE (page));
    g_return_if_fail (window->page == page);
 
    ENTER("window %p, page %p", window, page);
 
    if (!page->notebook_page)
    {
        LEAVE("no displayed widget");
        return;
    }
 
    gtk_container_remove (GTK_CONTAINER(window), GTK_WIDGET(page->notebook_page));
    window->page = NULL;
    gnc_plugin_page_removed (page);
 
    gnc_plugin_page_destroy_widget (page);
    g_object_unref(page);
    LEAVE(" ");
}
 
 
/*  Retrieve the plugin that is embedded in the specified window. */
GncPluginPage *
gnc_embedded_window_get_page (GncEmbeddedWindow *window)
{
    return window->page;
}
 
 
static void
gnc_embedded_window_class_init (GncEmbeddedWindowClass *klass)
{
    GObjectClass *object_class;
    ENTER("klass %p", klass);
    object_class = G_OBJECT_CLASS (klass);
 
    object_class->constructed = gnc_embedded_window_constructed;
    object_class->finalize = gnc_embedded_window_finalize;
    object_class->dispose = gnc_embedded_window_dispose;
 
     embedded_window_signals[PAGE_CHANGED] =
        g_signal_new ("page_changed",
                      G_OBJECT_CLASS_TYPE (object_class),
                      G_SIGNAL_RUN_FIRST,
                      0,
                      NULL, NULL,
                      g_cclosure_marshal_VOID__OBJECT,
                      G_TYPE_NONE, 1,
                      G_TYPE_OBJECT);
 
    LEAVE(" ");
}
 
 
static void
gnc_embedded_window_init (GncEmbeddedWindow *window)
{
    ENTER("window %p", window);
 
    gtk_orientable_set_orientation (GTK_ORIENTABLE(window), GTK_ORIENTATION_VERTICAL);
 
    // Set the name for this dialog so it can be easily manipulated with css
    gtk_widget_set_name (GTK_WIDGET(window), "gnc-id-embedded-window");
 
    gnc_embedded_window_setup_window (window);
 
    LEAVE(" ");
}
 
 static void
gnc_embedded_window_constructed (GObject *obj)
{
    gnc_gobject_tracking_remember(obj);
 
    G_OBJECT_CLASS (gnc_embedded_window_parent_class)->constructed (obj);
}
 
static void
gnc_embedded_window_finalize (GObject *object)
{
    g_return_if_fail (object != NULL);
    g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (object));
 
    ENTER("object %p", object);
    gnc_gobject_tracking_forget(object);
    G_OBJECT_CLASS (gnc_embedded_window_parent_class)->finalize (object);
    LEAVE(" ");
}
 
 
static void
gnc_embedded_window_dispose (GObject *object)
{
    GncEmbeddedWindow *window;
 
    g_return_if_fail (object != NULL);
    g_return_if_fail (GNC_IS_EMBEDDED_WINDOW (object));
 
    ENTER("object %p", object);
    window = GNC_EMBEDDED_WINDOW (object);
 
    if (window->page)
    {
        DEBUG("unreffing page %p (count currently %d)", window->page,
              G_OBJECT(window->page)->ref_count);
        g_object_unref(window->page);
        window->page = NULL;
    }
 
    G_OBJECT_CLASS (gnc_embedded_window_parent_class)->dispose (object);
    LEAVE(" ");
}
 
 
static void
gnc_embedded_window_setup_window (GncEmbeddedWindow *window)
{
    ENTER("window %p", window);
 
    /* Create widgets and add them to the window */
    gtk_widget_show (GTK_WIDGET(window));
 
    window->menu_dock = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_set_homogeneous (GTK_BOX (window->menu_dock), FALSE);
    gtk_widget_show (window->menu_dock);
    gtk_box_pack_start (GTK_BOX (window), window->menu_dock, FALSE, TRUE, 0);
 
    window->statusbar = gtk_statusbar_new ();
    gtk_widget_show (window->statusbar);
    gtk_box_pack_end (GTK_BOX (window), window->statusbar, FALSE, TRUE, 0);
 
    window->simple_action_group = NULL;
    LEAVE(" ");
}
 
 
GncEmbeddedWindow *
gnc_embedded_window_new (const gchar *action_group_name,
                         GActionEntry *action_entries,
                         gint n_action_entries,
                         const gchar *ui_filename,
                         GtkWidget *enclosing_win,
                         gboolean add_accelerators,
                         gpointer user_data)
{
    GncEmbeddedWindow *window;
    gchar *ui_fullname;
    GError *error = NULL;
    GtkBuilder *builder;
 
    ENTER("group %s, first %p, num %d, ui file %s, parent %p, add accelerators %d, user data %p",
          action_group_name, action_entries, n_action_entries, ui_filename,
          enclosing_win, add_accelerators, user_data);
 
    window = g_object_new (GNC_TYPE_EMBEDDED_WINDOW, NULL);
 
    builder = gtk_builder_new ();
    gtk_builder_set_translation_domain (builder, PROJECT_NAME);
 
    ui_fullname = g_strconcat (GNUCASH_RESOURCE_PREFIX "/", ui_filename, NULL);
 
    gtk_builder_add_from_resource (builder, ui_fullname, &error);
 
    if (error)
    {
        g_critical ("Failed to load, Error %s", error->message);
        g_error_free (error);
        return NULL;
    }
 
    window->menubar_model = (GMenuModel *)gtk_builder_get_object (builder, "embeddedwin-menu");
 
    window->menubar = gtk_menu_bar_new_from_model (window->menubar_model);
    gtk_container_add (GTK_CONTAINER(window->menu_dock), window->menubar);
    gtk_widget_show (GTK_WIDGET(window->menubar));
 
    window->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "embeddedwin-toolbar");
    g_object_set (window->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
    gtk_container_add (GTK_CONTAINER(window->menu_dock), GTK_WIDGET(window->toolbar));
    gtk_widget_show (GTK_WIDGET(window->toolbar));
 
    g_object_unref (builder);
 
    window->simple_action_group = g_simple_action_group_new ();
 
    g_action_map_add_action_entries (G_ACTION_MAP(window->simple_action_group),
                                     action_entries,
                                     n_action_entries,
                                     user_data);
 
    gtk_widget_insert_action_group (GTK_WIDGET(window), "embeddedwin",
                                    G_ACTION_GROUP(window->simple_action_group));
 
    window->parent_window = enclosing_win;
 
    // need to add the accelerator keys
    window->accel_group = gtk_accel_group_new ();
    gtk_window_add_accel_group (GTK_WINDOW(enclosing_win), window->accel_group);
    gnc_add_accelerator_keys_for_menu (GTK_WIDGET(window->menubar), window->menubar_model, window->accel_group);
 
    g_free (ui_fullname);
    LEAVE("window %p", window);
    return window;
}
 
 
static GtkWindow *
gnc_embedded_window_get_gtk_window (GncWindow *window_in)
{
    GncEmbeddedWindow *window;
 
    g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW (window_in), NULL);
 
    window = GNC_EMBEDDED_WINDOW(window_in);
    return GTK_WINDOW(window->parent_window);
}
 
 
static GtkWidget *
gnc_embedded_window_get_statusbar (GncWindow *window_in)
{
    GncEmbeddedWindow *window;
 
    g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW (window_in), NULL);
 
    window = GNC_EMBEDDED_WINDOW(window_in);
    return window->statusbar;
}
 
 
static GtkWidget *
gnc_embedded_window_get_menubar (GncWindow *window)
{
    g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
 
    return GNC_EMBEDDED_WINDOW (window)->menubar;
}
 
static GtkWidget *
gnc_embedded_window_get_toolbar (GncWindow *window)
{
    g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
 
    return GNC_EMBEDDED_WINDOW (window)->toolbar;
}
 
static GMenuModel *
gnc_embedded_window_get_menubar_model (GncWindow *window)
{
    g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
 
    return GNC_EMBEDDED_WINDOW (window)->menubar_model;
}
 
static GtkAccelGroup *
gnc_embedded_window_get_accel_group (GncWindow *window)
{
    g_return_val_if_fail (GNC_IS_EMBEDDED_WINDOW(window), NULL);
 
    return GNC_EMBEDDED_WINDOW (window)->accel_group;
}
 
static void
gnc_window_embedded_window_init (GncWindowInterface *iface)
{
    iface->get_gtk_window      = gnc_embedded_window_get_gtk_window;
    iface->get_statusbar       = gnc_embedded_window_get_statusbar;
    iface->get_menubar         = gnc_embedded_window_get_menubar;
    iface->get_toolbar         = gnc_embedded_window_get_toolbar;
    iface->get_menubar_model   = gnc_embedded_window_get_menubar_model;
    iface->get_accel_group     = gnc_embedded_window_get_accel_group;
}