gnc-main-window.c

Go to the documentation of this file.

/* 
 * gnc-main-window.c -- GtkWindow which represents the
 *      GnuCash main window.
 *
 * Copyright (C) 2003 Jan Arne Petersen <jpetersen@uni-bonn.de>
 * Copyright (C) 2003,2005,2006 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 <gnome.h>
#include <glib/gi18n.h>
#include <libguile.h>
#include "guile-mappings.h"

#include "gnc-plugin.h"
#include "gnc-plugin-manager.h"
#include "gnc-main-window.h"

#include "dialog-preferences.h"
#include "dialog-reset-warnings.h"
#include "dialog-transfer.h"
#include "dialog-utils.h"
#include "file-utils.h"
#include "gnc-component-manager.h"
#include "gnc-engine.h"
#include "gnc-file.h"
#include "gnc-gkeyfile-utils.h"
#include "gnc-gnome-utils.h"
#include "gnc-gobject-utils.h"
#include "gnc-gui-query.h"
#include "gnc-hooks.h"
#include "gnc-session.h"
#include "gnc-ui.h"
#include "gnc-ui-util.h"
#include "gnc-version.h"
#include "gnc-window.h"
#include "gnc-main.h"
#include "gnc-gconf-utils.h"
// +JSLED
#include "gnc-html.h"
#include "gnc-autosave.h"

enum {
  PAGE_ADDED,
  PAGE_CHANGED,
  LAST_SIGNAL
};

#define PLUGIN_PAGE_LABEL "plugin-page"

#define PLUGIN_PAGE_CLOSE_BUTTON "close-button"
#define PLUGIN_PAGE_TAB_LABEL    "label"

#define KEY_SHOW_CLOSE_BUTTON   "tab_close_buttons"
#define KEY_TAB_NEXT_RECENT     "tab_next_recent"
#define KEY_TAB_POSITION        "tab_position"
#define KEY_TAB_WIDTH           "tab_width"

#define GNC_MAIN_WINDOW_NAME "GncMainWindow"

/* Static Globals *******************************************************/

static QofLogModule log_module = GNC_MOD_GUI;
static GObjectClass *parent_class = NULL;
static GQuark window_type = 0;
static GList *active_windows = NULL;

/* Declarations *********************************************************/
static void gnc_main_window_class_init (GncMainWindowClass *klass);
static void gnc_main_window_init (GncMainWindow *window, GncMainWindowClass *klass);
static void gnc_main_window_finalize (GObject *object);
static void gnc_main_window_destroy (GtkObject *object);

static void gnc_main_window_setup_window (GncMainWindow *window);
static void gnc_window_main_window_init (GncWindowIface *iface);
static void gnc_main_window_update_all_menu_items (void);

/* Callbacks */
static void gnc_main_window_add_widget (GtkUIManager *merge, GtkWidget *widget, GncMainWindow *window);
static void gnc_main_window_switch_page (GtkNotebook *notebook, GtkNotebookPage *notebook_page, gint pos, GncMainWindow *window);
#ifdef HAVE_GTK_2_10
static void gnc_main_window_page_reordered (GtkNotebook *notebook, GtkWidget *child, guint pos, GncMainWindow *window);
#endif
static void gnc_main_window_plugin_added (GncPlugin *manager, GncPlugin *plugin, GncMainWindow *window);
static void gnc_main_window_plugin_removed (GncPlugin *manager, GncPlugin *plugin, GncMainWindow *window);

/* Command callbacks */
static void gnc_main_window_cmd_file_properties (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_file_close (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_file_quit (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_edit_cut (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_edit_copy (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_edit_paste (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_edit_preferences (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_view_refresh (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_view_toolbar (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_view_summary (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_view_statusbar (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_actions_reset_warnings (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_actions_rename_page (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_window_new (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_window_move_page (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_window_raise (GtkAction *action, GtkRadioAction *current, GncMainWindow *window);
static void gnc_main_window_cmd_help_tutorial (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_help_contents (GtkAction *action, GncMainWindow *window);
static void gnc_main_window_cmd_help_about (GtkAction *action, GncMainWindow *window);

static void do_popup_menu(GncPluginPage *page, GdkEventButton *event);
static gboolean gnc_main_window_popup_menu_cb (GtkWidget *widget, GncPluginPage *page);

static GtkAction *gnc_main_window_find_action (GncMainWindow *window, const gchar *name);

typedef struct GncMainWindowPrivate
{
        GtkWidget *menu_dock;
        /* The toolbar created by the UI manager.  This pointer
         * provides easy access for showing/hiding the toolbar. */
        GtkWidget *toolbar;
        GtkWidget *notebook;
        GtkWidget *statusbar;
        GtkWidget *progressbar;

        GtkActionGroup *action_group;

        GList *installed_pages;
        GList *usage_order;
        GncPluginPage *current_page;
        gint event_handler_id;

        GHashTable *merged_actions_table;
} GncMainWindowPrivate;

#define GNC_MAIN_WINDOW_GET_PRIVATE(o)  \
   (G_TYPE_INSTANCE_GET_PRIVATE ((o), GNC_TYPE_MAIN_WINDOW, GncMainWindowPrivate))

typedef struct {
        guint merge_id;
        GtkActionGroup *action_group;
} MergedActionEntry;

static guint main_window_signals[LAST_SIGNAL] = { 0 };


static GtkActionEntry gnc_menu_actions [] =
{
        /* Toplevel */

        { "FileAction", NULL, N_("_File"), NULL, NULL, NULL, },
        { "EditAction", NULL, N_("_Edit"), NULL, NULL, NULL },
        { "ViewAction", NULL, N_("_View"), NULL, NULL, NULL },
        { "ActionsAction", NULL, N_("_Actions"), NULL, NULL, NULL },
        { "TransactionAction", NULL, N_("Tra_nsaction"), NULL, NULL, NULL },
        { "ReportsAction", NULL, N_("_Reports"), NULL, NULL, NULL },
        { "ToolsAction", NULL, N_("_Tools"), NULL, NULL, NULL },
        { "ExtensionsAction", NULL, N_("E_xtensions"), NULL, NULL, NULL },
        { "WindowsAction", NULL, N_("_Windows"), NULL, NULL, NULL },
        { "HelpAction", NULL, N_("_Help"), NULL, NULL, NULL },

        /* File menu */

        { "FileNewMenuAction", GTK_STOCK_NEW, N_("_New"), "", NULL, NULL },
        { "FileOpenMenuAction", GTK_STOCK_OPEN, N_("_Open"), "", NULL, NULL },
        { "FileImportAction", NULL, N_("_Import"), NULL, NULL, NULL },
        { "FileExportAction", NULL, N_("_Export"), NULL, NULL, NULL },
        { "FilePrintAction", GTK_STOCK_PRINT, N_("_Print..."), "<control>p", 
          N_("Print the currently active page"), NULL },
        { "FilePropertiesAction", GTK_STOCK_PROPERTIES, N_("Proper_ties"), "<Alt>Return",
          N_("Edit the properties of the current file"),
          G_CALLBACK (gnc_main_window_cmd_file_properties) },
        { "FileCloseAction", GTK_STOCK_CLOSE, N_("_Close"), NULL,
          N_("Close the currently active page"),
          G_CALLBACK (gnc_main_window_cmd_file_close) },
        { "FileQuitAction", GTK_STOCK_QUIT, N_("_Quit"), NULL,
          N_("Quit this application"),
          G_CALLBACK (gnc_main_window_cmd_file_quit) },

        /* Edit menu */

        { "EditCutAction", GTK_STOCK_CUT, N_("Cu_t"), NULL, 
          N_("Cut the current selection and copy it to clipboard"),
          G_CALLBACK (gnc_main_window_cmd_edit_cut) },
        { "EditCopyAction", GTK_STOCK_COPY, N_("_Copy"), NULL, 
          N_("Copy the current selection to clipboard"),
          G_CALLBACK (gnc_main_window_cmd_edit_copy) },
        { "EditPasteAction", GTK_STOCK_PASTE, N_("_Paste"), NULL,
          N_("Paste the clipboard content at the cursor position"),
          G_CALLBACK (gnc_main_window_cmd_edit_paste) },
        { "EditPreferencesAction", GTK_STOCK_PREFERENCES, N_("Pr_eferences"), NULL,
          N_("Edit the global preferences of GnuCash"),
          G_CALLBACK (gnc_main_window_cmd_edit_preferences) },

        /* View menu */

        { "ViewSortByAction", NULL, N_("_Sort By..."), NULL, 
          N_("Select sorting criteria for this page view"), NULL },
        { "ViewFilterByAction", NULL, N_("_Filter By..."), NULL, 
          N_("Select the account types that should be displayed."), NULL },
        { "ViewRefreshAction", GTK_STOCK_REFRESH, N_("_Refresh"), "<control>r",
          N_("Refresh this window"),
          G_CALLBACK (gnc_main_window_cmd_view_refresh) },

        /* Actions menu */

        { "ScrubMenuAction", NULL, N_("_Check & Repair"), NULL, NULL, NULL },
        { "ActionsForgetWarningsAction", NULL, N_("Reset _Warnings..."), NULL,
          N_("Reset the state of all warning messages so they will be shown again."),
          G_CALLBACK (gnc_main_window_cmd_actions_reset_warnings) },
        { "ActionsRenamePageAction", NULL, N_("Re_name Page"), NULL,
          N_("Rename this page."),
          G_CALLBACK (gnc_main_window_cmd_actions_rename_page) },

        /* Windows menu */

        { "WindowNewAction", NULL, N_("_New Window"), NULL,
          N_("Open a new top-level GnuCash window."),
          G_CALLBACK (gnc_main_window_cmd_window_new) },
        { "WindowMovePageAction", NULL, N_("New Window with _Page"), NULL,
          N_("Move the current page to a new top-level GnuCash window."),
          G_CALLBACK (gnc_main_window_cmd_window_move_page) },

        /* Help menu */

        { "HelpTutorialAction", GNOME_STOCK_BOOK_BLUE, N_("Tutorial and Concepts _Guide"), NULL,
          N_("Open the GnuCash Tutorial"),
          G_CALLBACK (gnc_main_window_cmd_help_tutorial) },
        { "HelpContentsAction", GTK_STOCK_HELP, N_("_Contents"), "F1",
          N_("Open the GnuCash Help"),
          G_CALLBACK (gnc_main_window_cmd_help_contents) },
        { "HelpAboutAction", GNOME_STOCK_ABOUT, N_("_About"), NULL,
          N_("About GnuCash"),
          G_CALLBACK (gnc_main_window_cmd_help_about) },
};
static guint gnc_menu_n_actions = G_N_ELEMENTS (gnc_menu_actions);

static GtkToggleActionEntry toggle_actions [] =
{
        { "ViewToolbarAction", NULL, N_("_Toolbar"), NULL,
          N_("Show/hide the toolbar on this window"),
          G_CALLBACK (gnc_main_window_cmd_view_toolbar), TRUE },
        { "ViewSummaryAction", NULL, N_("Su_mmary Bar"), NULL,
          N_("Show/hide the summary bar on this window"),
          G_CALLBACK (gnc_main_window_cmd_view_summary), TRUE },
        { "ViewStatusbarAction", NULL, N_("Stat_us Bar"), NULL,
          N_("Show/hide the status bar on this window"),
          G_CALLBACK (gnc_main_window_cmd_view_statusbar), TRUE },
};
static guint n_toggle_actions = G_N_ELEMENTS (toggle_actions);

static GtkRadioActionEntry radio_entries [] =
{
        { "Window0Action", NULL, N_("Window _1"), NULL, NULL, 0 },
        { "Window1Action", NULL, N_("Window _2"), NULL, NULL, 1 },
        { "Window2Action", NULL, N_("Window _3"), NULL, NULL, 2 },
        { "Window3Action", NULL, N_("Window _4"), NULL, NULL, 3 },
        { "Window4Action", NULL, N_("Window _5"), NULL, NULL, 4 },
        { "Window5Action", NULL, N_("Window _6"), NULL, NULL, 5 },
        { "Window6Action", NULL, N_("Window _7"), NULL, NULL, 6 },
        { "Window7Action", NULL, N_("Window _8"), NULL, NULL, 7 },
        { "Window8Action", NULL, N_("Window _9"), NULL, NULL, 8 },
        { "Window9Action", NULL, N_("Window _0"), NULL, NULL, 9 },
};
static guint n_radio_entries = G_N_ELEMENTS (radio_entries);


static const gchar *gnc_menu_important_actions[] = {
  "FileCloseAction",
  NULL,
};


static const gchar *always_insensitive_actions[] = {
        "FilePrintAction",
        NULL
};


static const gchar *initially_insensitive_actions[] = {
        "FileCloseAction",
        NULL
};


static const gchar *always_hidden_actions[] = {
        "ViewSortByAction",
        "ViewFilterByAction",
        NULL
};


static const gchar *immutable_page_actions[] = {
        "FileCloseAction",
        NULL
};


static const gchar *multiple_page_actions[] = {
        "WindowMovePageAction",
        NULL
};


/* This data structure holds the tooltops for all notebook tabs.
 * Typically these are used to provide the full path of a register
 * page. */
static GtkTooltips *tips = NULL;

/************************************************************
 *                                                          *
 ************************************************************/
#define WINDOW_COUNT            "WindowCount"
#define WINDOW_STRING           "Window %d"
#define WINDOW_GEOMETRY         "WindowGeometry"
#define WINDOW_POSITION         "WindowPosition"
#define WINDOW_MAXIMIZED        "WindowMaximized"
#define TOOLBAR_VISIBLE         "ToolbarVisible"
#define STATUSBAR_VISIBLE       "StatusbarVisible"
#define SUMMARYBAR_VISIBLE      "SummarybarVisible"
#define WINDOW_FIRSTPAGE        "FirstPage"
#define WINDOW_PAGECOUNT        "PageCount"
#define WINDOW_PAGEORDER        "PageOrder"
#define PAGE_TYPE               "PageType"
#define PAGE_NAME               "PageName"
#define PAGE_STRING             "Page %d"

typedef struct {
  GKeyFile *key_file;
  const gchar *group_name;
  gint window_num;
  gint page_num;
  gint page_offset;
} GncMainWindowSaveData;


/*  Iterator function to walk all pages in all windows, calling the
 *  specified function for each page. */
void
gnc_main_window_foreach_page (GncMainWindowPageFunc fn, gpointer user_data)
{
  GncMainWindowPrivate *priv;
  GncMainWindow *window;
  GncPluginPage *page;
  GList *w, *p;

  ENTER(" ");
  for (w = active_windows; w; w = g_list_next(w)) {
    window = w->data;
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    for (p = priv->installed_pages; p; p = g_list_next(p)) {
      page = p->data;
      fn(page, user_data);
    }
  }
  LEAVE(" ");
}


static void
gnc_main_window_restore_page (GncMainWindow *window, 
                              GncMainWindowSaveData *data)
{
  GncMainWindowPrivate *priv;
  GncPluginPage *page;
  gchar *page_group, *page_type = NULL, *name = NULL;
  const gchar *class_type;
  GError *error = NULL;

  ENTER("window %p, data %p (key file %p, window %d, page start %d, page num %d)",
        window, data, data->key_file, data->window_num, data->page_offset, 
        data->page_num);

  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
  page_group = g_strdup_printf(PAGE_STRING, 
                               data->page_offset + data->page_num);
  page_type = g_key_file_get_string(data->key_file, page_group,
                                    PAGE_TYPE, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              page_group, PAGE_TYPE, error->message);
    goto cleanup;
  }

  /* See if the page already exists. */
  page = g_list_nth_data(priv->installed_pages, data->page_num);
  if (page) {
    class_type = GNC_PLUGIN_PAGE_GET_CLASS(page)->plugin_name;
    if (strcmp(page_type, class_type) != 0) {
      g_warning("error: page types don't match: state %s, existing page %s",
                page_type, class_type);
      goto cleanup;
    }
  } else {
    /* create and install the page */
    page = gnc_plugin_page_recreate_page(GTK_WIDGET(window), page_type,
                                         data->key_file, page_group);
    if (page) {
      /* Does the page still need to be installed into the window? */
      if (page->window == NULL) {
        gnc_plugin_page_set_use_new_window(page, FALSE);
        gnc_main_window_open_page(window, page);
      }

      /* Restore the page name */
      name = g_key_file_get_string(data->key_file, page_group,
                                       PAGE_NAME, &error);
      if (error) {
        g_warning("error reading group %s key %s: %s",
                  page_group, PAGE_NAME, error->message);
        /* Fall through and still show the page. */
      } else {
        DEBUG("updating page name for %p to %s.", page, name);
        main_window_update_page_name(page, name);
        g_free(name);
      }
    }
  }

  LEAVE("ok");
 cleanup:
  if (error)
    g_error_free(error);
  if (page_type)
    g_free(page_type);
  g_free(page_group);
}


static void
gnc_main_window_restore_window (GncMainWindow *window, GncMainWindowSaveData *data)
{
  GncMainWindowPrivate *priv;
  GtkAction *action;
  gint *pos, *geom, *order;
  gsize length;
  gboolean max, visible, desired_visibility;
  gchar *window_group;
  gint page_start, page_count, i;
  GError *error = NULL;

  /* Setup */
  ENTER("window %p, data %p (key file %p, window %d)",
        window, data, data->key_file, data->window_num);
  window_group = g_strdup_printf(WINDOW_STRING, data->window_num + 1);

  /* Get this window's notebook info */
  page_count = g_key_file_get_integer(data->key_file,
                                      window_group, WINDOW_PAGECOUNT, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, WINDOW_PAGECOUNT, error->message);
    goto cleanup;
  }
  if (page_count == 0) {
    /* Shound never happen, but has during alpha testing. Having this
     * check doesn't hurt anything. */
    goto cleanup;
  }
  page_start = g_key_file_get_integer(data->key_file,
                                      window_group, WINDOW_FIRSTPAGE, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, WINDOW_FIRSTPAGE, error->message);
    goto cleanup;
  }

  /* Build a window if we don't already have one */
  if (window == NULL) {
    DEBUG("Window %d doesn't exist. Creating new window.", data->window_num);
    DEBUG("active_windows %p.", active_windows);
    if (active_windows)
      DEBUG("first window %p.", active_windows->data);
    window = gnc_main_window_new();
    gtk_widget_show(GTK_WIDGET(window));
  }

  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

  /* Get the window coordinates, etc. */
  geom = g_key_file_get_integer_list(data->key_file, window_group,
                                     WINDOW_GEOMETRY, &length, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, WINDOW_GEOMETRY, error->message);
    g_error_free(error);
    error = NULL;
  } else if (length != 2) {
    g_warning("invalid number of values for group %s key %s",
              window_group, WINDOW_GEOMETRY);
  } else {
    gtk_window_resize(GTK_WINDOW(window), geom[0], geom[1]);
    DEBUG("window (%p) size %dx%d", window, geom[0], geom[1]);
  }
  /* keep the geometry for a test whether the windows position
     is offscreen */

  pos = g_key_file_get_integer_list(data->key_file, window_group,
                                    WINDOW_POSITION, &length, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, WINDOW_POSITION, error->message);
    g_error_free(error);
    error = NULL;
  } else if (length != 2) {
    g_warning("invalid number of values for group %s key %s",
              window_group, WINDOW_POSITION);
  } else if ((pos[0] + (geom ? geom[0] : 0) < 0) ||
             (pos[0] > gdk_screen_width()) ||
             (pos[1] + (geom ? geom[1] : 0) < 0) ||
             (pos[1] > gdk_screen_height())) {
//    g_debug("position %dx%d, size%dx%d is offscreen; will not move",
//          pos[0], pos[1], geom[0], geom[1]);
  } else {
    gtk_window_move(GTK_WINDOW(window), pos[0], pos[1]);
    DEBUG("window (%p) position %dx%d", window, pos[0], pos[1]);
  }
  if (geom) {
    g_free(geom);
  }
  if (pos) {
    g_free(pos);
  }

  max = g_key_file_get_boolean(data->key_file, window_group,
                               WINDOW_MAXIMIZED, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, WINDOW_MAXIMIZED, error->message);
    g_error_free(error);
    error = NULL;
  } else if (max) {
    gtk_window_maximize(GTK_WINDOW(window));
  }

  /* Common view menu items */
  action = gnc_main_window_find_action(window, "ViewToolbarAction");
  visible = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
  desired_visibility = g_key_file_get_boolean(data->key_file, window_group,
                                              TOOLBAR_VISIBLE, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, TOOLBAR_VISIBLE, error->message);
    g_error_free(error);
    error = NULL;
  } else if (visible != desired_visibility) {
    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action),desired_visibility);
  }

  action = gnc_main_window_find_action(window, "ViewSummaryAction");
  visible = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
  desired_visibility = g_key_file_get_boolean(data->key_file, window_group,
                                              SUMMARYBAR_VISIBLE, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, TOOLBAR_VISIBLE, error->message);
    g_error_free(error);
    error = NULL;
  } else if (visible != desired_visibility) {
    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action),desired_visibility);
  }

  action = gnc_main_window_find_action(window, "ViewStatusbarAction");
  visible = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
  desired_visibility = g_key_file_get_boolean(data->key_file, window_group,
                                              STATUSBAR_VISIBLE, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, TOOLBAR_VISIBLE, error->message);
    g_error_free(error);
    error = NULL;
  } else if (visible != desired_visibility) {
    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action),desired_visibility);
  }

  /* Now populate the window with pages. */
  for (i = 0; i < page_count; i++) {
    data->page_offset = page_start;
    data->page_num = i;
    gnc_main_window_restore_page(window, data);

    /* give the page a chance to display */
    while (gtk_events_pending ())
      gtk_main_iteration ();
  }

  /* Restore page ordering within the notebook. Use +1 notation so the
   * numbers in the page order match the page sections, at least for
   * the one window case. */
  order = g_key_file_get_integer_list(data->key_file, window_group,
                                      WINDOW_PAGEORDER, &length, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              window_group, WINDOW_PAGEORDER, error->message);
    g_error_free(error);
    error = NULL;
  } else if (length != page_count) {
    g_warning("%s key %s length %" G_GSIZE_FORMAT " differs from window page count %d",
              window_group, WINDOW_PAGEORDER, length, page_count);
  } else {
    /* Dump any list that might exist */
    g_list_free(priv->usage_order);
    priv->usage_order = NULL;
    /* Now rebuild the list from the key file. */
    for (i = 0; i < length; i++) {
      gpointer page = g_list_nth_data(priv->installed_pages, order[i] - 1);
      if (page) {
        priv->usage_order = g_list_append(priv->usage_order, page);
      }
    }
    gtk_notebook_set_current_page (GTK_NOTEBOOK(priv->notebook),
                                   order[0] - 1);
  }
  if (order) {
    g_free(order);
  }

  LEAVE("window %p", window);
 cleanup:
  if (error)
    g_error_free(error);
  g_free(window_group);
}

void
gnc_main_window_restore_all_windows(const GKeyFile *keyfile)
{
  gint i, window_count;
  GError *error = NULL;
  GncMainWindowSaveData data;
  GncMainWindow *window;

  /* We use the same struct for reading and for writing, so we cast
     away the const. */
  data.key_file = (GKeyFile *) keyfile;
  window_count = g_key_file_get_integer(data.key_file, STATE_FILE_TOP, 
                                        WINDOW_COUNT, &error);
  if (error) {
    g_warning("error reading group %s key %s: %s",
              STATE_FILE_TOP, WINDOW_COUNT, error->message);
    g_error_free(error);
    LEAVE("can't read count");
    return;
  }

  /* Restore all state information on the open windows.  Window
     numbers in state file are 1-based. GList indices are 0-based. */
  gnc_set_busy_cursor (NULL, TRUE);
  for (i = 0; i < window_count; i++) {
    data.window_num = i;
    window = g_list_nth_data(active_windows, i);
    gnc_main_window_restore_window(window, &data);
  }
  gnc_unset_busy_cursor (NULL);
}

void
gnc_main_window_restore_default_state(void)
{
    GtkAction *action;
    GncMainWindow *window;
    
    /* The default state should be to have an Account Tree page open
     * in the window. */
    DEBUG("no saved state file");
    window = g_list_nth_data(active_windows, 0);
    action = gnc_main_window_find_action(window, "FileNewAccountTreeAction");
    gtk_action_activate(action);
}

static void
gnc_main_window_save_page (GncPluginPage *page, GncMainWindowSaveData *data)
{
  gchar *page_group;
  const gchar *plugin_name, *page_name;

  ENTER("page %p, data %p (key file %p, window %d, page %d)",
        page, data, data->key_file, data->window_num, data->page_num);
  plugin_name = gnc_plugin_page_get_plugin_name(page);
  page_name = gnc_plugin_page_get_page_name(page);
  if (!plugin_name || !page_name) {
      LEAVE("not saving invalid page");
      return;
  }
  page_group = g_strdup_printf(PAGE_STRING, data->page_num++);
  g_key_file_set_string(data->key_file, page_group, PAGE_TYPE, plugin_name);
  g_key_file_set_string(data->key_file, page_group, PAGE_NAME, page_name);

  gnc_plugin_page_save_page(page, data->key_file, page_group);
  g_free(page_group);
  LEAVE(" ");
}


static void
gnc_main_window_save_window (GncMainWindow *window, GncMainWindowSaveData *data)
{
  GncMainWindowPrivate *priv;
  GtkAction *action;
  gint i, num_pages, coords[4], *order;
  gboolean maximized, visible;
  gchar *window_group;

  /* Setup */
  ENTER("window %p, data %p (key file %p, window %d)",
        window, data, data->key_file, data->window_num);
  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

  /* Check for bogus window structures. */
  num_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook));
  if (0 == num_pages) {
    LEAVE("empty window %p", window);
    return;
  }

  /* Save this window's notebook info */
  window_group = g_strdup_printf(WINDOW_STRING, data->window_num++);
  g_key_file_set_integer(data->key_file, window_group,
                         WINDOW_PAGECOUNT, num_pages);
  g_key_file_set_integer(data->key_file, window_group,
                         WINDOW_FIRSTPAGE, data->page_num);

  /* Save page ordering within the notebook. Use +1 notation so the
   * numbers in the page order match the page sections, at least for
   * the one window case. */
  order = g_malloc(sizeof(gint) * num_pages);
  for (i = 0; i < num_pages; i++) {
    gpointer page = g_list_nth_data(priv->usage_order, i);
    order[i] = g_list_index(priv->installed_pages, page) + 1;
  }
  g_key_file_set_integer_list(data->key_file, window_group,
                              WINDOW_PAGEORDER, order, num_pages);
  g_free(order);

  /* Save the window coordinates, etc. */
  gtk_window_get_position(GTK_WINDOW(window), &coords[0], &coords[1]);
  gtk_window_get_size(GTK_WINDOW(window), &coords[2], &coords[3]);
  maximized = (gdk_window_get_state((GTK_WIDGET(window))->window)
               & GDK_WINDOW_STATE_MAXIMIZED) != 0;
  g_key_file_set_integer_list(data->key_file, window_group,
                              WINDOW_POSITION, &coords[0], 2);
  g_key_file_set_integer_list(data->key_file, window_group,
                              WINDOW_GEOMETRY, &coords[2], 2);
  g_key_file_set_boolean(data->key_file, window_group,
                         WINDOW_MAXIMIZED, maximized);
  DEBUG("window (%p) position %dx%d, size %dx%d, %s", window,  coords[0], coords[1],
        coords[2], coords[3],
        maximized ? "maximized" : "not maximized");

  /* Common view menu items */
  action = gnc_main_window_find_action(window, "ViewToolbarAction");
  visible = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
  g_key_file_set_boolean(data->key_file, window_group,
                         TOOLBAR_VISIBLE, visible);
  action = gnc_main_window_find_action(window, "ViewSummaryAction");
  visible = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
  g_key_file_set_boolean(data->key_file, window_group,
                         SUMMARYBAR_VISIBLE, visible);
  action = gnc_main_window_find_action(window, "ViewStatusbarAction");
  visible = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
  g_key_file_set_boolean(data->key_file, window_group,
                         STATUSBAR_VISIBLE, visible);

  /* Save individual pages in this window */
  g_list_foreach(priv->installed_pages, (GFunc)gnc_main_window_save_page, data);

  g_free(window_group);
  LEAVE("window %p", window);
}

void
gnc_main_window_save_all_windows(GKeyFile *keyfile)
{
    GncMainWindowSaveData data;

    /* Set up the iterator data structures */
    data.key_file = keyfile;
    data.window_num = 1;
    data.page_num = 1;

    g_key_file_set_integer(data.key_file,
                           STATE_FILE_TOP, WINDOW_COUNT,
                           g_list_length(active_windows));
    /* Dump all state information on the open windows */
    g_list_foreach(active_windows, (GFunc)gnc_main_window_save_window, &data);
}


gboolean
gnc_main_window_finish_pending (GncMainWindow *window)
{
        GncMainWindowPrivate *priv;
        GList *item;

        g_return_val_if_fail(GNC_IS_MAIN_WINDOW(window), TRUE);

        priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
        for (item = priv->installed_pages; item; item = g_list_next(item)) {
          if (!gnc_plugin_page_finish_pending(item->data)) {
            return FALSE;
          }
        }
        return TRUE;
}


gboolean
gnc_main_window_all_finish_pending (void)
{
        const GList *windows, *item;

        windows = gnc_gobject_tracking_get_list(GNC_MAIN_WINDOW_NAME);
        for (item = windows; item; item = g_list_next(item)) {
          if (!gnc_main_window_finish_pending(item->data)) {
            return FALSE;
          }
        }
        return TRUE;
}


static gboolean
gnc_main_window_page_exists (GncPluginPage *page)
{
        GncMainWindow *window;
        GncMainWindowPrivate *priv;
        GList *walker;

        for (walker = active_windows; walker; walker = g_list_next(walker)) {
          window = walker->data;
          priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
          if (g_list_find(priv->installed_pages, page)) {
            return TRUE;
          }
        }
        return FALSE;
}


static gboolean
gnc_main_window_prompt_for_save (GtkWidget *window)
{
  QofSession *session;
  QofBook *book;
  GtkWidget *dialog;
  gint response;
  const gchar *filename, *tmp;
  const gchar *title = _("Save changes to file %s before closing?");
  /* This should be the same message as in gnc-file.c */
  const gchar *message_mins =
    _("If you don't save, changes from the past %d minutes will be discarded.");
  const gchar *message_hours =
    _("If you don't save, changes from the past %d hours and %d minutes will be discarded.");
  const gchar *message_days =
    _("If you don't save, changes from the past %d days and %d hours will be discarded.");
  time_t oldest_change;
  gint minutes, hours, days;

  session = gnc_get_current_session();
  book = qof_session_get_book(session);
  filename = qof_session_get_url(session);
  if (filename == NULL)
    filename = _("<unknown>");
  if ((tmp = strrchr(filename, '/')) != NULL)
    filename = tmp + 1;

  /* Remove any pending auto-save timeouts */
  gnc_autosave_remove_timer(book);

  dialog = gtk_message_dialog_new(GTK_WINDOW(window),
                                  GTK_DIALOG_MODAL,
                                  GTK_MESSAGE_WARNING,
                                  GTK_BUTTONS_NONE,
                                  title,
                                  filename);
  oldest_change = qof_book_get_dirty_time(book);
  minutes = (time(NULL) - oldest_change) / 60 + 1;
  hours = minutes / 60;
  minutes = minutes % 60;
  days = hours / 24;
  hours = hours % 24;
  if (days > 0) {
      gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
                                               message_days, days, hours);
  } else if (hours > 0) {
      gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
                                               message_hours, hours, minutes);
  } else {
      gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
                                               message_mins, minutes);
  }
  gtk_dialog_add_buttons(GTK_DIALOG(dialog),
                         _("Close _Without Saving"), GTK_RESPONSE_CLOSE,
                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                         GTK_STOCK_SAVE, GTK_RESPONSE_APPLY,
                         NULL);
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_APPLY);
  response = gtk_dialog_run (GTK_DIALOG (dialog));
  gtk_widget_destroy(dialog);

  switch (response) {
    case GTK_RESPONSE_APPLY:
      gnc_file_save();
      return FALSE;

    case GTK_RESPONSE_CLOSE:
      qof_book_mark_saved(book);
      return FALSE;

    default:
      return TRUE;
  }
}


static void
gnc_main_window_add_plugin (gpointer plugin,
                            gpointer window)
{
        g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
        g_return_if_fail (GNC_IS_PLUGIN (plugin));

        ENTER(" ");
        gnc_plugin_add_to_window (GNC_PLUGIN (plugin),
                                  GNC_MAIN_WINDOW (window),
                                  window_type);
        LEAVE(" ");
}

static void
gnc_main_window_remove_plugin (gpointer plugin,
                               gpointer window)
{
        g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
        g_return_if_fail (GNC_IS_PLUGIN (plugin));

        ENTER(" ");
        gnc_plugin_remove_from_window (GNC_PLUGIN (plugin),
                                       GNC_MAIN_WINDOW (window),
                                       window_type);
        LEAVE(" ");
}


static gboolean
gnc_main_window_timed_quit (gpointer dummy)
{
  if (gnc_file_save_in_progress())
    return TRUE;

  gnc_shutdown (0);
  return FALSE;
}

static gboolean
gnc_main_window_quit(GncMainWindow *window)
{
    QofSession *session;
    gboolean needs_save, do_shutdown;

    session = gnc_get_current_session();
    needs_save = qof_book_not_saved(qof_session_get_book(session)) && 
        !gnc_file_save_in_progress();
    do_shutdown = !needs_save || 
        (needs_save && !gnc_main_window_prompt_for_save(GTK_WIDGET(window)));

    if (do_shutdown) {
        g_timeout_add(250, gnc_main_window_timed_quit, NULL);
        return TRUE;
    }
    return FALSE;
}

static gboolean
gnc_main_window_delete_event (GtkWidget *window,
                              GdkEvent *event,
                              gpointer user_data)
{
  static gboolean already_dead = FALSE;

  if (already_dead)
    return TRUE;

  if (!gnc_main_window_finish_pending(GNC_MAIN_WINDOW(window))) {
    /* Don't close the window. */
    return TRUE;
  }

  if (g_list_length(active_windows) > 1)
    return FALSE;

  already_dead = gnc_main_window_quit(GNC_MAIN_WINDOW(window));
  return TRUE;
}


static void
gnc_main_window_event_handler (QofInstance *entity,  QofEventId event_type,
                               gpointer user_data, gpointer event_data)
{
        GncMainWindow *window;
        GncMainWindowPrivate *priv;
        GncPluginPage *page;
        GList *item, *next;

        /* hard failures */
        g_return_if_fail(GNC_IS_MAIN_WINDOW(user_data));

        /* soft failures */
        if (!QOF_CHECK_TYPE(entity, QOF_ID_BOOK))
          return;
        if (event_type !=  QOF_EVENT_DESTROY)
          return;

        ENTER("entity %p, event %d, window %p, event data %p",
              entity, event_type, user_data, event_data);
        window = GNC_MAIN_WINDOW(user_data);
        priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

        /* This is not a typical list iteration.  We're removing while
         * we iterate, so we have to cache the 'next' pointer before
         * executing any code in the loop. */
        for (item = priv->installed_pages; item; item = next) {
          next = g_list_next(item);
          page = GNC_PLUGIN_PAGE(item->data);
          if (gnc_plugin_page_has_book (page, (QofBook *)entity))
              gnc_main_window_close_page (page);
        }
        LEAVE(" ");
}


static gchar *
gnc_main_window_generate_title (GncMainWindow *window)
{
  GncMainWindowPrivate *priv;
  GncPluginPage *page;
  QofBook *book;
  const gchar *filename = NULL, *dirty = "";
  gchar *title, *ptr;
  GtkAction* action;

  /* The save action is sensitive iff the book is dirty */
  action = gnc_main_window_find_action (window, "FileSaveAction");
  if (action != NULL) {
        gtk_action_set_sensitive(action, FALSE);
  }
  if (gnc_current_session_exist()) {
      filename = gnc_session_get_url (gnc_get_current_session ());
      book = gnc_get_current_book();
      if (qof_instance_is_dirty(QOF_INSTANCE(book))) {
                dirty = "*";
                if (action != NULL) {
                  gtk_action_set_sensitive(action, TRUE);
                }
          }
  }

  if (!filename)
    filename = _("<no file>");
  else {
    /* The Gnome HIG 2.0 recommends only the file name (no path) be used. (p15) */
    ptr = g_utf8_strrchr(filename, -1, G_DIR_SEPARATOR);
    if (ptr != NULL)
      filename = g_utf8_next_char(ptr);
  }

  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
  page = priv->current_page;
  if (page) {
    /* The Gnome HIG 2.0 recommends the application name not be used. (p16) */
    title = g_strdup_printf("%s%s - %s", dirty, filename,
                            gnc_plugin_page_get_page_name(page));
  } else {
    title = g_strdup_printf("%s%s", dirty, filename);
  }
  
  return title;
}


static void
gnc_main_window_update_title (GncMainWindow *window)
{
  gchar *title;

  title = gnc_main_window_generate_title(window);
  gtk_window_set_title(GTK_WINDOW(window), title);
  g_free(title);
}

static void
gnc_main_window_update_all_titles (void)
{
  g_list_foreach(active_windows,
                 (GFunc)gnc_main_window_update_title,
                 NULL);
}

static void
gnc_main_window_book_dirty_cb (QofBook *book,
                               gboolean dirty,
                               gpointer user_data)
{
  gnc_main_window_update_all_titles();

  /* Auto-save feature */
  gnc_autosave_dirty_handler(book, dirty);
}

static void
gnc_main_window_attach_to_book (QofSession *session)
{
  QofBook *book;

  g_return_if_fail(session);

  book = qof_session_get_book(session);
  qof_book_set_dirty_cb(book, gnc_main_window_book_dirty_cb, NULL);
  gnc_main_window_update_all_titles();
  gnc_main_window_update_all_menu_items();
}


struct menu_update {
  gchar    *action_name;

  gchar    *label;

  gboolean  visible;
};


static void
gnc_main_window_update_one_menu_action (GncMainWindow *window,
                                        struct menu_update *data)
{
  GncMainWindowPrivate *priv;
  GtkAction* action;

  ENTER("window %p, action %s, label %s, visible %d", window,
        data->action_name, data->label, data->visible);
  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
  action = gtk_action_group_get_action(priv->action_group, data->action_name);
  if (action)
    g_object_set(G_OBJECT(action),
                 "label", data->label,
                 "visible", data->visible,
                 (char *)NULL);
  LEAVE(" ");
}


static void
gnc_main_window_update_radio_button (GncMainWindow *window)
{
  GncMainWindowPrivate *priv;
  GtkAction *action, *first_action;
  GSList *action_list;
  gchar *action_name;
  gint index;

  ENTER("window %p", window);

  /* Show the new entry in all windows. */
  index = g_list_index(active_windows, window);
  if (index >= n_radio_entries) {
    LEAVE("window %d, only %d actions", index, n_radio_entries);
    return;
  }

  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
  action_name = g_strdup_printf("Window%dAction", index);
  action = gtk_action_group_get_action(priv->action_group, action_name);

  /* Block the signal so as not to affect window ordering (top to
   * bottom) on the screen */
  action_list = gtk_radio_action_get_group(GTK_RADIO_ACTION(action));
  first_action = g_slist_last(action_list)->data;
  g_signal_handlers_block_by_func(G_OBJECT(first_action),
                                  G_CALLBACK(gnc_main_window_cmd_window_raise), window);
  DEBUG("blocked signal on %p, set %p active, window %p", first_action, action, window);
  gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), TRUE);
  g_signal_handlers_unblock_by_func(G_OBJECT(first_action),
                                    G_CALLBACK(gnc_main_window_cmd_window_raise), window);
  g_free(action_name);
  LEAVE(" ");
}


static void
gnc_main_window_update_menu_item (GncMainWindow *window)
{
  struct menu_update data;
  gchar **strings, *title, *expanded;
  gint index;