gnc-main-window.cpp

/*
 * 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 <glib/gi18n.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>
#include "dialog-options.hpp"
#include <libguile.h>

#include <config.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 "engine-helpers.h"
#include "file-utils.h"
#include "gnc-component-manager.h"
#include "dialog-doclink-utils.h"
#include "gnc-engine.h"
#include "gnc-features.h"
#include "gnc-file.h"
#include "gnc-filepath-utils.h"
#include "gnc-gkeyfile-utils.h"
#include "gnc-gnome-utils.h"
#include "gnc-gobject-utils.h"
#include "gnc-gui-query.h"
#include "gnc-gtk-utils.h"
#include "gnc-hooks.h"
#include "gnc-icons.h"
#include "gnc-session.h"
#include "gnc-state.h"
#include "gnc-ui.h"
#include "gnc-ui-util.h"
#include <gnc-glib-utils.h>
#include "gnc-uri-utils.h"
#include "gnc-version.h"
#include "gnc-warnings.h"
#include "gnc-window.h"
#include "gnc-prefs.h"
#include "gnc-optiondb.h"
#include "gnc-autosave.h"
#include "print-session.h"
#ifdef MAC_INTEGRATION
#include <gtkmacintegration/gtkosxapplication.h>
#endif
#ifdef HAVE_SYS_STAT_H
# define __need_system_sys_stat_h //To block Guile-2.0's evil substitute
# include <sys/types.h>
# include <sys/stat.h> // for stat(2)
#endif

enum
{
    PAGE_ADDED,
    PAGE_CHANGED,
    MENU_CHANGED,
    LAST_SIGNAL
};

#define PLUGIN_PAGE_LABEL "plugin-page"

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

#define GNC_PREF_SHOW_CLOSE_BUTTON    "tab-close-buttons"
#define GNC_PREF_TAB_NEXT_RECENT      "tab-next-recent"
#define GNC_PREF_TAB_POSITION_TOP     "tab-position-top"
#define GNC_PREF_TAB_POSITION_BOTTOM  "tab-position-bottom"
#define GNC_PREF_TAB_POSITION_LEFT    "tab-position-left"
#define GNC_PREF_TAB_POSITION_RIGHT   "tab-position-right"
#define GNC_PREF_TAB_WIDTH            "tab-width"
#define GNC_PREF_TAB_COLOR            "show-account-color-tabs"
#define GNC_PREF_SAVE_CLOSE_EXPIRES   "save-on-close-expires"
#define GNC_PREF_SAVE_CLOSE_WAIT_TIME "save-on-close-wait-time"
#define GNC_PREF_TAB_OPEN_ADJACENT    "tab-open-adjacent"

#define GNC_MAIN_WINDOW_NAME "GncMainWindow"

#define DIALOG_BOOK_OPTIONS_CM_CLASS "dialog-book-options"

extern gboolean gnc_book_options_dialog_apply_helper(GncOptionDB * options);

[[maybe_unused]] constexpr auto gnc_main_window_max_number {10};

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

static QofLogModule log_module = GNC_MOD_GUI;
static GQuark window_type = 0;
static GList *active_windows = nullptr;
static guint secs_to_save = 0;
#define MSG_AUTO_SAVE _("Changes will be saved automatically in %u seconds")

/* Declarations *********************************************************/
static void gnc_main_window_constructed (GObject *object);
static void gnc_main_window_finalize (GObject *object);
static void gnc_main_window_destroy (GtkWidget *widget);

static void gnc_main_window_setup_window (GncMainWindow *window);
static void gnc_window_main_window_init (GncWindowInterface *iface);
#ifndef MAC_INTEGRATION
static void gnc_main_window_update_all_menu_items (void);
#endif

/* Callbacks */
static void gnc_main_window_switch_page (GtkNotebook *notebook, gpointer *notebook_page, gint pos, GncMainWindow *window);
static void gnc_main_window_page_reordered (GtkNotebook *notebook, GtkWidget *child, guint pos, GncMainWindow *window);
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);
static void gnc_main_window_engine_commit_error_callback( gpointer data, QofBackendError errcode );

/* Command callbacks */
static void gnc_main_window_cmd_redirect (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_page_setup (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_file_properties (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_file_close (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_file_quit (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_edit_cut (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_edit_copy (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_edit_paste (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_edit_preferences (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_view_refresh (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_view_toolbar (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_view_summary (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_view_statusbar (GSimpleAction *simple, GVariant *paramter, gpointer user_data);

static void gnc_main_window_cmd_view_tab_position (GSimpleAction *simple, GVariant *parameter, gpointer user_data);

static void gnc_main_window_cmd_actions_reset_warnings (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_actions_rename_page (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_window_new (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_window_move_page (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
#ifndef MAC_INTEGRATION
static void gnc_main_window_cmd_window_raise (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
#endif
static void gnc_main_window_cmd_help_tutorial (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_help_contents (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
static void gnc_main_window_cmd_help_about (GSimpleAction *simple, GVariant *paramter, gpointer user_data);

static void do_popup_menu(GncPluginPage *page, GdkEventButton *event);
static GtkWidget *gnc_main_window_get_statusbar (GncWindow *window_in);
static void statusbar_notification_lastmodified (void);
static void gnc_main_window_update_tab_position (gpointer prefs, gchar *pref, gpointer user_data);
static void gnc_main_window_remove_prefs (GncMainWindow *window);

#ifdef MAC_INTEGRATION
static void gnc_quartz_shutdown (GtkosxApplication *theApp, gpointer data);
static gboolean gnc_quartz_should_quit (GtkosxApplication *theApp, GncMainWindow *window);
static void gnc_quartz_set_menu (GncMainWindow* window);
#endif
static void gnc_main_window_init_menu_updaters (GncMainWindow *window);

struct _GncMainWindow
{
    GtkApplicationWindow gtk_application_window;  
    gboolean window_quitting;                     
    gboolean just_plugin_prefs;                   
};

typedef struct
{
    GtkWidget *menu_dock;
    GtkWidget *menubar;
    GMenuModel *menubar_model;
    GtkWidget *toolbar;
    GtkWidget *notebook;
    gboolean show_color_tabs;
    GtkWidget *statusbar;
    GtkWidget *progressbar;
    GList *installed_pages;
    GList *usage_order;
    GncPluginPage *current_page;
    gint event_handler_id;
    gint pos[2];
    gboolean restoring_pages;

    const gchar   *previous_plugin_page_name;
    const gchar   *previous_menu_qualifier;

    GtkAccelGroup *accel_group;

    GHashTable    *display_item_hash;

} GncMainWindowPrivate;

G_DEFINE_TYPE_WITH_CODE(GncMainWindow, gnc_main_window, GTK_TYPE_APPLICATION_WINDOW,
                        G_ADD_PRIVATE (GncMainWindow)
                        G_IMPLEMENT_INTERFACE (GNC_TYPE_WINDOW,
                                       gnc_window_main_window_init))

#define GNC_MAIN_WINDOW_GET_PRIVATE(o)  \
   ((GncMainWindowPrivate*)gnc_main_window_get_instance_private((GncMainWindow*)o))

static guint main_window_signals[LAST_SIGNAL] = { 0 };

static GActionEntry gnc_menu_actions [] =
{
    { "FilePageSetupAction", gnc_main_window_cmd_page_setup, nullptr, nullptr, nullptr },
    { "FilePropertiesAction", gnc_main_window_cmd_file_properties, nullptr, nullptr, nullptr },
    { "FileCloseAction", gnc_main_window_cmd_file_close, nullptr, nullptr, nullptr },
    { "FilePrintAction", gnc_main_window_cmd_redirect, nullptr, nullptr, nullptr },
    { "FileQuitAction", gnc_main_window_cmd_file_quit, nullptr, nullptr, nullptr },

    { "EditCutAction", gnc_main_window_cmd_edit_cut, nullptr, nullptr, nullptr },
    { "EditCopyAction", gnc_main_window_cmd_edit_copy, nullptr, nullptr, nullptr },
    { "EditPasteAction", gnc_main_window_cmd_edit_paste, nullptr, nullptr, nullptr },
    { "EditPreferencesAction", gnc_main_window_cmd_edit_preferences, nullptr, nullptr, nullptr },

    { "ActionsForgetWarningsAction", gnc_main_window_cmd_actions_reset_warnings, nullptr, nullptr, nullptr },
    { "ActionsRenamePageAction", gnc_main_window_cmd_actions_rename_page, nullptr, nullptr, nullptr },

    { "TransactionAction", nullptr, nullptr, nullptr, nullptr },

    { "ViewSortByAction", nullptr, nullptr, nullptr, nullptr },
    { "ViewFilterByAction", nullptr, nullptr, nullptr, nullptr },
    { "ViewRefreshAction", gnc_main_window_cmd_view_refresh, nullptr, nullptr, nullptr },
    { "ViewToolbarAction", gnc_main_window_cmd_view_toolbar, nullptr, "true", nullptr },
    { "ViewSummaryAction", gnc_main_window_cmd_view_summary, nullptr, "true", nullptr },
    { "ViewStatusbarAction", gnc_main_window_cmd_view_statusbar, nullptr, "true", nullptr },
    { "ViewTabPositionAction",  gnc_main_window_cmd_view_tab_position, "i", "@i 0", nullptr },

    { "ScheduledAction", nullptr, nullptr, nullptr, nullptr },

    { "ExtensionsAction", nullptr, nullptr, nullptr, nullptr },

    { "WindowNewAction", gnc_main_window_cmd_window_new, nullptr, nullptr, nullptr },
    { "WindowMovePageAction", gnc_main_window_cmd_window_move_page, nullptr, nullptr, nullptr },
#ifndef MAC_INTEGRATION
    { "WindowAction",  gnc_main_window_cmd_window_raise, "i", "@i 0", nullptr },
#endif
    { "HelpTutorialAction", gnc_main_window_cmd_help_tutorial, nullptr, nullptr, nullptr },
    { "HelpContentsAction", gnc_main_window_cmd_help_contents, nullptr, nullptr, nullptr },
    { "HelpAboutAction", gnc_main_window_cmd_help_about, nullptr, nullptr, nullptr },
};
static guint gnc_menu_n_actions = G_N_ELEMENTS(gnc_menu_actions);

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


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


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


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


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


/************************************************************
 *                                                          *
 ************************************************************/
#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;


gboolean
gnc_main_window_is_restoring_pages (GncMainWindow *window)
{
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    return priv->restoring_pages;
}


/*  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)
{
    ENTER(" ");
    for (auto w = active_windows; w; w = g_list_next(w))
    {
        auto window{static_cast<GncMainWindow*>(w->data)};
        auto priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
        for (auto p = priv->installed_pages; p; p = g_list_next(p))
        {
            auto page{static_cast<GncPluginPage*>(p->data)};
            fn(page, user_data);
        }
    }
    LEAVE(" ");
}


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

    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 = static_cast<GncPluginPage*>(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 == nullptr)
            {
                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);

    return (page ? true : false);
}

static bool
intersects_some_monitor(const GdkRectangle& rect)
{
    auto display = gdk_display_get_default();
    if (!display)
        return false;

    int n = gdk_display_get_n_monitors(display);
    for (int i = 0; i < n; ++i)
    {
        auto monitor = gdk_display_get_monitor(display, i);
        GdkRectangle monitor_geometry;
        gdk_monitor_get_geometry(monitor, &monitor_geometry);
        DEBUG("Monitor %d: position (%d,%d), size %dx%d\n", i,
                        monitor_geometry.x, monitor_geometry.y,
                        monitor_geometry.width, monitor_geometry.height);
        if (gdk_rectangle_intersect(&rect, &monitor_geometry, nullptr))
            return true;
    }

    return false;
}

static void
set_window_geometry(GncMainWindow *window, GncMainWindowSaveData *data, gchar *window_group)
{
    gsize length;
    GError *error = nullptr;
    gint *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 = nullptr;
    }
    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 */
    gint *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 = nullptr;
    }
    else if (length != 2)
    {
        g_warning("invalid number of values for group %s key %s",
                  window_group, WINDOW_POSITION);
    }
    else if (pos)
    {
        // Prevent restoring coordinates if this would move the window off-screen
        // If missing geom, use height=width=1 to make the intersection check work
        GdkRectangle geometry{pos[0], pos[1], geom ? geom[0] : 1, geom ? geom[1] : 1};
        if (intersects_some_monitor(geometry))
        {
            gtk_window_move(GTK_WINDOW(window), geometry.x, geometry.y);
            auto priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
            priv->pos[0] = geometry.x;
            priv->pos[1] = geometry.y;
            DEBUG("window (%p) position (%d,%d)", window, geometry.x, geometry.y);
        }
        else
        {
            DEBUG("position (%d,%d), size %dx%d is offscreen; will not move",
                  geometry.x, geometry.y, geometry.width, geometry.height);
        }
    }
    g_free(geom);
    g_free(pos);

    gboolean 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 = nullptr;
    }
    else if (max)
    {
        gtk_window_maximize(GTK_WINDOW(window));
    }
}

static void
gnc_main_window_restore_window (GncMainWindow *window, GncMainWindowSaveData *data)
{
    GncMainWindowPrivate *priv;
    GAction *action;
    gint *order;
    gsize length;
    gsize page_start, page_count, i;
    GError *error = nullptr;
    GSList *added_page_offsets = nullptr;
    gint offset = 0;

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

    /* Deal with the uncommon case that the state file defines a window
     * but no pages. An example to get in such a situation can be found
     * here: https://bugs.gnucash.org/show_bug.cgi?id=436479#c3
     * If this happens on the first window, we will open an account hierarchy
     * to avoid confusing the user by presenting a completely empty window.
     * If it happens on a later window, we'll just skip restoring that window.
     */
    if (!g_key_file_has_group (data->key_file, window_group) ||
        !g_key_file_has_key (data->key_file, window_group, WINDOW_PAGECOUNT, &error))
    {
        if (window)
        {
            gnc_main_window_restore_default_state (window);
            PINFO ("saved state had an empty first main window\n"
                   "an account hierarchy page was added automatically to avoid confusion");
        }
        else
            PINFO ("saved state had an empty main window, skipping restore");

        goto cleanup;
    }


    /* 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)
    {
        /* Should 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 == nullptr)
    {
        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();
    }

    /* Get the window coordinates, etc. */
    set_window_geometry(window, data, window_group);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    // need to add the accelerator keys
    gnc_add_accelerator_keys_for_menu (GTK_WIDGET(priv->menubar), priv->menubar_model, priv->accel_group);

    /* Common view menu items */
    action = gnc_main_window_find_action (window, "ViewToolbarAction");
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        gboolean visible = g_variant_get_boolean (state);
        gboolean 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 = nullptr;
        }
        else if (visible != desired_visibility)
        {
            g_action_activate (action, nullptr);
        }
        g_variant_unref (state);
    }

    action = gnc_main_window_find_action (window, "ViewSummaryAction");
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        gboolean visible = g_variant_get_boolean (state);
        gboolean 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, SUMMARYBAR_VISIBLE, error->message);
            g_error_free (error);
            error = nullptr;
        }
        else if (visible != desired_visibility)
        {
            g_action_activate (action, nullptr);
        }
        g_variant_unref (state);
    }

    action = gnc_main_window_find_action (window, "ViewStatusbarAction");
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        gboolean visible = g_variant_get_boolean (state);
        gboolean 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, STATUSBAR_VISIBLE, error->message);
            g_error_free (error);
            error = nullptr;
        }
        else if (visible != desired_visibility)
        {
            g_action_activate (action, nullptr);
        }
        g_variant_unref (state);
    }
    priv->restoring_pages = TRUE;
    /* Now populate the window with pages. */
    for (i = 0; i < page_count; i++)
    {
        data->page_offset = page_start;
        data->page_num = i;
        gboolean page_added = gnc_main_window_restore_page (window, data);

        if (!page_added) // if page not added, increase offset to compensate
        {
            offset ++;
            added_page_offsets = g_slist_append (added_page_offsets, 
                                                 GINT_TO_POINTER(-1));
        }
        else
            added_page_offsets = g_slist_append (added_page_offsets,
                                                 GINT_TO_POINTER(offset));

        /* give the page a chance to display */
        while (gtk_events_pending ())
            gtk_main_iteration ();
    }
    priv->restoring_pages = FALSE;
    /* 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 = nullptr;
    }
    else if (length != page_count)
    {
        g_warning("%s key %s length %" G_GSIZE_FORMAT " differs from window page count %" G_GSIZE_FORMAT,
                  window_group, WINDOW_PAGEORDER, length, page_count);
    }
    else
    {
        /* Dump any list that might exist */
        g_list_free(priv->usage_order);
        priv->usage_order = nullptr;

        gint default_page_position = -1;

        /* Now rebuild the list from the key file, skipping pages not added */
        for (i = 0; i < length; i++)
        {
            gint zero_based_page_number = order[i] - 1;

            gint offset = GPOINTER_TO_INT(g_slist_nth_data (added_page_offsets, 
                                                            zero_based_page_number));

            if (offset == -1)
                continue;

            gpointer page = g_list_nth_data (priv->installed_pages,
                                             zero_based_page_number - offset);

            if (default_page_position == -1)
                default_page_position = zero_based_page_number - offset;

            if (page)
                priv->usage_order = g_list_append (priv->usage_order, page);
        }
        gtk_notebook_set_current_page (GTK_NOTEBOOK(priv->notebook),
                                       default_page_position);

        g_signal_emit_by_name (window, "page_changed",
                               g_list_nth_data (priv->usage_order, 0));
    }
    if (order)
    {
        g_free(order);
    }

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

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

    /* 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 (nullptr, TRUE);
    for (i = 0; i < window_count; i++)
    {
        data.window_num = i;
        auto window{static_cast<GncMainWindow*>(g_list_nth_data(active_windows,
                                                                i))};
        gnc_main_window_restore_window(window, &data);
    }
    gnc_unset_busy_cursor (nullptr);

    statusbar_notification_lastmodified();
}

void
gnc_main_window_restore_default_state (GncMainWindow *window)
{
    GAction *action;

    /* The default state should be to have an Account Tree page open
     * in the window. */
    DEBUG("no saved state file");
    if (!window)
        window = static_cast<GncMainWindow*>(g_list_nth_data(active_windows, 0));
    gtk_widget_show (GTK_WIDGET(window));
    action = gnc_main_window_find_action_in_group (window,
                                                   "gnc-plugin-account-tree-actions",
                                                   "ViewAccountTreeAction");
    g_action_activate (action, nullptr);
}

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;
    GAction *action;
    gint i, num_pages, coords[4], *order;
    gboolean maximized, minimized, visible = true;
    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 = static_cast<int*>(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_get_window ((GTK_WIDGET(window))))
                 & GDK_WINDOW_STATE_MAXIMIZED) != 0;
    minimized = (gdk_window_get_state(gtk_widget_get_window ((GTK_WIDGET(window))))
                 & GDK_WINDOW_STATE_ICONIFIED) != 0;

    if (minimized)
    {
        gint *pos = priv->pos;
        g_key_file_set_integer_list(data->key_file, window_group,
                                    WINDOW_POSITION, &pos[0], 2);
        DEBUG("window minimized (%p) position (%d,%d)", window, pos[0], pos[1]);
    }
    else
        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 (%d,%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");
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        visible = g_variant_get_boolean (state);
        g_variant_unref (state);
    }
    g_key_file_set_boolean (data->key_file, window_group,
                            TOOLBAR_VISIBLE, visible);
    action = gnc_main_window_find_action (window, "ViewSummaryAction");
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        visible = g_variant_get_boolean (state);
        g_variant_unref (state);
    }
    g_key_file_set_boolean (data->key_file, window_group,
                            SUMMARYBAR_VISIBLE, visible);
    action = gnc_main_window_find_action (window, "ViewStatusbarAction");
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        visible = g_variant_get_boolean (state);
        g_variant_unref (state);
    }
    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(static_cast<GncPluginPage*>(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(static_cast<GncMainWindow*>(item->data)))
        {
            return FALSE;
        }
    }
    if (gnc_gui_refresh_suspended ())
    {
        gnc_warning_dialog (nullptr, "%s", "An operation is still running, wait for it to complete before quitting.");
        return FALSE;
    }
    return TRUE;
}


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

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

static gboolean auto_save_countdown (GtkWidget *dialog)
{
    GtkWidget *label;
    gchar *timeoutstr = nullptr;

    /* Stop count down if user closed the dialog since the last time we were called */
    if (!GTK_IS_DIALOG (dialog))
        return FALSE; /* remove timer */

    /* Stop count down if count down text can't be updated */
    label = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), "count-down-label"));
    if (!GTK_IS_LABEL (label))
        return FALSE; /* remove timer */

    /* Protect against rolling over to MAXUINT */
    if (secs_to_save)
        --secs_to_save;
    DEBUG ("Counting down: %d seconds", secs_to_save);

    timeoutstr = g_strdup_printf (MSG_AUTO_SAVE, secs_to_save);
    gtk_label_set_text (GTK_LABEL (label), timeoutstr);
    g_free (timeoutstr);

    /* Count down reached 0. Save and close dialog */
    if (!secs_to_save)
    {
        gtk_dialog_response (GTK_DIALOG(dialog), GTK_RESPONSE_APPLY);
        return FALSE; /* remove timer */
    }

    /* Run another cycle */
    return TRUE;
}


static gboolean
gnc_main_window_prompt_for_save (GtkWidget *window)
{
    QofSession *session;
    QofBook *book;
    GtkWidget *dialog, *msg_area, *label;
    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_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.");
    time64 oldest_change;
    gint minutes, hours, days;
    guint timer_source = 0;
    if (!gnc_current_session_exist())
        return FALSE;
    session = gnc_get_current_session();
    book = qof_session_get_book(session);
    if (!qof_book_session_not_saved(book))
        return FALSE;
    filename = qof_session_get_url(session);
    if (!strlen (filename))
        filename = _("<unknown>");
    if ((tmp = strrchr(filename, '/')) != nullptr)
        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_session_dirty_time(book);
    minutes = (gnc_time (nullptr) - 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),
                ngettext("If you don't save, changes from the past %d minute will be discarded.",
                         "If you don't save, changes from the past %d minutes will be discarded.",
                         minutes), minutes);
    }
    gtk_dialog_add_buttons(GTK_DIALOG(dialog),
                           _("Close _Without Saving"), GTK_RESPONSE_CLOSE,
                           _("_Cancel"), GTK_RESPONSE_CANCEL,
                           _("_Save"), GTK_RESPONSE_APPLY,
                           nullptr);
    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_APPLY);

    /* If requested by the user, add a timeout to the question to save automatically
     * if the user doesn't answer after a chosen number of seconds.
     */
    if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_CLOSE_EXPIRES))
    {
        gchar *timeoutstr = nullptr;

        secs_to_save = gnc_prefs_get_int (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_CLOSE_WAIT_TIME);
        timeoutstr = g_strdup_printf (MSG_AUTO_SAVE, secs_to_save);
        label = GTK_WIDGET(gtk_label_new (timeoutstr));
        g_free (timeoutstr);
        gtk_widget_show (label);

        msg_area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG(dialog));
        gtk_box_pack_end (GTK_BOX(msg_area), label, TRUE, TRUE, 0);
        g_object_set (G_OBJECT (label), "xalign", 0.0, nullptr);

        g_object_set_data (G_OBJECT (dialog), "count-down-label", label);
        timer_source = g_timeout_add_seconds (1, (GSourceFunc)auto_save_countdown, dialog);
    }

    response = gtk_dialog_run (GTK_DIALOG (dialog));
    if (timer_source)
        g_source_remove (timer_source);
    gtk_widget_destroy(dialog);

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

    case GTK_RESPONSE_CLOSE:
        qof_book_mark_session_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 = TRUE;
    if (gnc_current_session_exist())
    {
        session = gnc_get_current_session();
        needs_save =
            qof_book_session_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)
    {
        GList *w, *next;

        /* This is not a typical list iteration. There is a possibility
         * that the window may be removed from the active_windows list so
         * we have to cache the 'next' pointer before executing any code
         * in the loop. */
        for (w = active_windows; w; w = next)
        {
            GncMainWindowPrivate *priv;
            GncMainWindow *window = static_cast<GncMainWindow*>(w->data);

            next = g_list_next (w);

            window->window_quitting = TRUE; //set window_quitting on all windows

            priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

            // if there are no pages destroy window
            if (priv->installed_pages == NULL)
                gtk_widget_destroy (GTK_WIDGET(window));
        }
        /* remove the preference callbacks from the main window */
        gnc_main_window_remove_prefs (window);
        g_timeout_add(250, gnc_main_window_timed_quit, nullptr);
        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_list_length_cmp (active_windows, 1) > 0)
    {
        gint response;
        GtkWidget *dialog;
        gchar *message = _("This window is closing and will not be restored.");

        dialog = gtk_message_dialog_new (GTK_WINDOW (window),
                                         GTK_DIALOG_DESTROY_WITH_PARENT,
                                         GTK_MESSAGE_QUESTION,
                                         GTK_BUTTONS_NONE,
                                         "%s", _("Close Window?"));
        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG(dialog),
                                                  "%s", message);

        gtk_dialog_add_buttons (GTK_DIALOG(dialog),
                              _("_Cancel"), GTK_RESPONSE_CANCEL,
                              _("_OK"), GTK_RESPONSE_YES,
                               (gchar *)NULL);
        gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_YES);
        response = gnc_dialog_run (GTK_DIALOG(dialog), GNC_PREF_WARN_CLOSING_WINDOW_QUESTION);
        gtk_widget_destroy (dialog);

        if (response == GTK_RESPONSE_CANCEL)
            return TRUE;
    }

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

    if (gnc_list_length_cmp (active_windows, 1) > 0)
        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);
    }

    if (GTK_IS_WIDGET(window) && window->window_quitting)
        gtk_widget_destroy (GTK_WIDGET(window));

    LEAVE(" ");
}


static gchar *
gnc_main_window_generate_title (GncMainWindow *window)
{
    GncMainWindowPrivate *priv;
    GncPluginPage *page;
    QofBook *book;
    gboolean immutable;
    gchar *filename = nullptr;
    const gchar *uri = nullptr;
    const gchar *dirty = "";
    const gchar *readonly_text = nullptr;
    gchar *readonly;
    gchar *title;

    if (gnc_current_session_exist())
    {
        uri = qof_session_get_url (gnc_get_current_session ());
        book = gnc_get_current_book();
        if (qof_book_session_not_saved (book))
            dirty = "*";
        if (qof_book_is_readonly(book))
        {
            /* Translators: This string is shown in the window title if this
            document is, well, read-only. */
            readonly_text = _("(read-only)");
        }
    }
    readonly = (readonly_text != nullptr)
               ? g_strdup_printf(" %s", readonly_text)
               : g_strdup("");

    if (!uri || g_strcmp0 (uri, "") == 0)
        filename = g_strdup(_("Unsaved Book"));
    else
    {
        if (gnc_uri_targets_local_fs (uri))
        {
            /* The filename is a true file.
               The Gnome HIG 2.0 recommends only the file name (no path) be used. (p15) */
            gchar *path = gnc_uri_get_path ( uri );
            filename = g_path_get_basename ( path );
            g_free ( path );
        }
        else
        {
            /* The filename is composed of database connection parameters.
               For this we will show access_method://username@database[:port] */
            filename = gnc_uri_normalize_uri (uri, FALSE);
        }
    }

    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)
           but several developers prefer to use it anyway. */
        title = g_strdup_printf("%s%s%s - %s - GnuCash", dirty, filename, readonly,
                                gnc_plugin_page_get_page_name(page));
    }
    else
    {
        title = g_strdup_printf("%s%s%s - GnuCash", dirty, filename, readonly);
    }
    /* Update the menus based upon whether this is an "immutable" page. */
    immutable = page &&
                g_object_get_data (G_OBJECT (page), PLUGIN_PAGE_IMMUTABLE);
    gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
                                    immutable_page_actions,
                                    !immutable);
    /* Trigger sensitivity updtates of other actions such as Save/Revert */
    g_signal_emit_by_name (window, "page_changed", page);
    g_free( filename );
    g_free(readonly);

    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,
                   nullptr);
}

/*  Callback function invoked when the user clicks on a GtkNotebook tab.
 *
 *  This function is needed to make it possible to close a tab
 *  when it's clicked using the middle mouse button;
 *  there does not seem to be a way to do this with GtkNotebook natively.
 *
 *  @param widget The event box in the tab, which was clicked.
 *
 *  @param event The event parameter describing where on the screen
 *  the mouse was pointing when clicked, type of click, modifiers,
 *  etc.
 *
 *  @param page This is the GncPluginPage corresponding to the tab.
 *
 *  @return Returns TRUE if this was a middle-click, meaning Gnucash
 *  handled the click.
 */
static gboolean
gnc_tab_clicked_cb(GtkWidget *widget, GdkEventButton *event, GncPluginPage *page) {
    if (event->type == GDK_BUTTON_PRESS && event->button == 2)
    {
        gnc_main_window_close_page(page);
        return TRUE;
    }
    return FALSE;
}

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, nullptr);
    gnc_main_window_update_all_titles();
#ifndef MAC_INTEGRATION
    gnc_main_window_update_all_menu_items();
#endif
}

static guint gnc_statusbar_notification_messageid = 0;
//#define STATUSBAR_NOTIFICATION_AUTOREMOVAL
#ifdef STATUSBAR_NOTIFICATION_AUTOREMOVAL
/* Removes the statusbar notification again that has been pushed to the
 * statusbar by generate_statusbar_lastmodified_message. */
static gboolean statusbar_notification_off(gpointer user_data_unused)
{
    GncMainWindow *mainwindow = GNC_MAIN_WINDOW (gnc_ui_get_main_window (nullptr));
    //g_warning("statusbar_notification_off\n");
    if (gnc_statusbar_notification_messageid == 0)
        return FALSE;

    if (mainwindow)
    {
        GtkWidget *statusbar = gnc_main_window_get_statusbar(GNC_WINDOW(mainwindow));
        gtk_statusbar_remove(GTK_STATUSBAR(statusbar), 0, gnc_statusbar_notification_messageid);
        gnc_statusbar_notification_messageid = 0;
    }
    else
    {
        g_warning("oops, no GncMainWindow obtained\n");
    }
    return FALSE; // should not be called again
}
#endif // STATUSBAR_NOTIFICATION_AUTOREMOVAL

/* Creates a statusbar message stating the last modification time of the opened
 * data file. */
static gchar *generate_statusbar_lastmodified_message()
{
    gchar *message = nullptr;
    const gchar *uri = nullptr;

    if (gnc_current_session_exist())
    {
        uri = qof_session_get_url (gnc_get_current_session ());
    }

    if (!(uri && strlen (uri)))
        return nullptr;
    else
    {
        if (gnc_uri_targets_local_fs (uri))
        {
            /* The filename is a true file. */
            gchar *filepath = gnc_uri_get_path ( uri );
            gchar *filename = g_path_get_basename ( filepath );
            GFile *file = g_file_new_for_uri (uri);
            GFileInfo *info = g_file_query_info (file,
                                                 G_FILE_ATTRIBUTE_TIME_MODIFIED,
                                                 G_FILE_QUERY_INFO_NONE,
                                                 NULL, NULL);

            if (info && g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
            {
                // Access the mtime information through stat(2)
                struct stat statbuf;
                int r = stat(filepath, &statbuf);
                if (r == 0)
                {
                    /* Translators: This is the date and time that is shown in
                    the status bar after opening a file: The date and time of
                    last modification. The string is a format string using
                    boost::date_time's format flags, see the boost docs for an
                    explanation of the modifiers. */
                    char *time_string = gnc_print_time64(statbuf.st_mtime,
                     _("Last modified on %a, %b %d, %Y at %I:%M %p"));
                    //g_warning("got time %ld, str=%s\n", mtime, time_string);
                    /* Translators: This message appears in the status bar after opening the file. */
                    message = g_strdup_printf(_("File %s opened. %s"),
                                              filename, time_string);
                    free(time_string);
                }
                else
                {
                    g_warning("Unable to read mtime for file %s\n", filepath);
                    // message is still nullptr
                }
            }
            g_free(filename);
            g_free(filepath);
            g_object_unref (info);
            g_object_unref (file);
        }
        // If the URI is not a file but a database, we can maybe also show
        // something useful, but I have no idea how to obtain this information.
    }
    return message;
}

static void
statusbar_notification_lastmodified()
{
    // First look up the first GncMainWindow to set the statusbar there
    GList *iter;
    GtkWidget *widget = nullptr;
    for (iter = active_windows; iter && !(widget && GNC_IS_MAIN_WINDOW(widget));
            iter = g_list_next(iter))
    {
        widget = static_cast<GtkWidget*>(iter->data);
    }
    if (widget && GNC_IS_MAIN_WINDOW(widget))
    {
        // Ok, we found a mainwindow where we can set a statusbar message
        GncMainWindow *mainwindow = GNC_MAIN_WINDOW(widget);
        GtkWidget *statusbar = gnc_main_window_get_statusbar(GNC_WINDOW(mainwindow));

        gchar *msg = generate_statusbar_lastmodified_message();
        if (msg)
        {
            gnc_statusbar_notification_messageid = gtk_statusbar_push(GTK_STATUSBAR(statusbar), 0, msg);
        }
        g_free(msg);

#ifdef STATUSBAR_NOTIFICATION_AUTOREMOVAL
        // Also register a timeout callback to remove that statusbar
        // notification again after 10 seconds
        g_timeout_add(10 * 1000, statusbar_notification_off, nullptr); // maybe not needed anyway?
#endif
    }
    else
    {
        g_warning("uh oh, no GNC_IS_MAIN_WINDOW\n");
    }
}


struct menu_update
{
    gchar    *action_name;

    gchar    *label;

    gboolean  visible;

    gint index;
};

#ifndef MAC_INTEGRATION

static void
gnc_main_window_update_one_menu_action (GncMainWindow *window,
                                        struct menu_update *data)
{
    GncMainWindowPrivate *priv;
    GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);
    GMenuItem *item;
    gint pos;

    ENTER("window %p, action %s, label %s, index %d, visible %d", window,
          data->action_name, data->label, data->index, data->visible);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    gsm->search_action_label = nullptr;
    gsm->search_action_name = "WindowsPlaceholder1";  // placeholder
    gsm->search_action_target = nullptr;

    if (!gnc_menubar_model_find_item (priv->menubar_model, gsm))
    {
        LEAVE("Could not find placeholder 'WindowsPlaceholder1' for windows entries");
        g_free (gsm);
        return;
    }

    pos = gsm->index + data->index + 1;

    if (!data->visible)
    {
        if (pos < g_menu_model_get_n_items (gsm->model))
            g_menu_remove (G_MENU(gsm->model), pos);

        g_free (gsm);
        LEAVE(" ");
        return;
    }

    item = g_menu_item_new (data->label, "mainwin.WindowAction");
    g_menu_item_set_attribute (item, G_MENU_ATTRIBUTE_TARGET, "i", data->index);

    if (pos < g_menu_model_get_n_items (gsm->model))
        g_menu_remove (G_MENU(gsm->model), pos);
    g_menu_insert_item (G_MENU(gsm->model), pos, item);
    g_object_unref (item);

    g_free (gsm);
    LEAVE(" ");
}

static void
gnc_main_window_update_radio_button (GncMainWindow *window)
{
    GAction *action;
    gsize index;

    ENTER("window %p", window);

    /* Show the new entry in all windows. */
    index = g_list_index (active_windows, window);

    if (index >= gnc_main_window_max_number)
    {
        LEAVE("window %" G_GSIZE_FORMAT ", only %d actions", index, gnc_main_window_max_number);
        return;
    }

    action = g_action_map_lookup_action (G_ACTION_MAP(window),
                                         "WindowAction");

    /* Block the signal so as not to affect window ordering (top to
     * bottom) on the screen */
    g_signal_handlers_block_by_func (G_OBJECT(action),
                                     (gpointer)gnc_main_window_cmd_window_raise,
                                     window);

    DEBUG("blocked signal on action %p, window %p", action, window);
    g_action_change_state (G_ACTION(action), g_variant_new_int32 (index));

    g_signal_handlers_unblock_by_func (G_OBJECT(action),
                                       (gpointer)gnc_main_window_cmd_window_raise,
                                       window);
    LEAVE(" ");
}

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

    ENTER("window %p", window);

    index = g_list_index (active_windows, window);

    if (index >= gnc_main_window_max_number)
    {
        LEAVE("skip window %" G_GSIZE_FORMAT " (only %d entries)", index, gnc_main_window_max_number);
        return;
    }

    /* Figure out the label name. Add the accelerator if possible. */
    title = gnc_main_window_generate_title (window);
    strings = g_strsplit (title, "_", 0);
    g_free (title);
    expanded = g_strjoinv ("__", strings);
    if (index < gnc_main_window_max_number)
    {
        data.label = g_strdup_printf ("_%" G_GSIZE_FORMAT " %s", (index + 1) % 10, expanded);
        g_free (expanded);
    }
    else
    {
        data.label = expanded;
    }
    g_strfreev (strings);

    data.visible = TRUE;
    data.action_name = g_strdup_printf ("Window%" G_GSIZE_FORMAT "Action", index);
    data.index = index;

    g_list_foreach (active_windows,
                    (GFunc)gnc_main_window_update_one_menu_action,
                    &data);

    g_free (data.action_name);
    g_free (data.label);

    LEAVE(" ");
}
#endif /* !MAC_INTEGRATION */

#ifndef MAC_INTEGRATION
static void
gnc_main_window_update_all_menu_items (void)
{
    struct menu_update data;

    ENTER("");
    /* First update the entries for all existing windows */
    g_list_foreach (active_windows,
                    (GFunc)gnc_main_window_update_menu_item,
                    nullptr);

    g_list_foreach (active_windows,
                    (GFunc)gnc_main_window_update_radio_button,
                    nullptr);

    /* Now hide any entries that aren't being used. */
    data.visible = FALSE;
    // need i to descend from gnc_main_window_max_number
    for (gsize i = gnc_main_window_max_number - 1; i > 0 && i >= g_list_length (active_windows); i--)
    {
        data.index = i;
        data.action_name = g_strdup_printf ("Window%dAction", data.index);
        data.label = g_strdup_printf ("mywin%" G_GSIZE_FORMAT, i % 10);

        g_list_foreach (active_windows,
                        (GFunc)gnc_main_window_update_one_menu_action,
                        &data);

        g_free (data.action_name);
        g_free (data.label);
    }
    LEAVE(" ");
}
#endif /* !MAC_INTEGRATION */

static void
gnc_main_window_update_tab_close_one_page (GncPluginPage *page,
                                           gpointer user_data)
{
    auto new_value{static_cast<gboolean*>(user_data)};
    ENTER("page %p, visible %d", page, *new_value);
    auto close_button{static_cast<GtkWidget*>(g_object_get_data(G_OBJECT (page), PLUGIN_PAGE_CLOSE_BUTTON))};
    if (!close_button)
    {
        LEAVE("no close button");
        return;
    }

    if (*new_value)
        gtk_widget_show (close_button);
    else
        gtk_widget_hide (close_button);
    LEAVE(" ");
}


static void
gnc_main_window_update_tab_close (gpointer prefs, gchar *pref, gpointer user_data)
{
    gboolean new_value;

    ENTER(" ");
    new_value = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SHOW_CLOSE_BUTTON);
    gnc_main_window_foreach_page(
        gnc_main_window_update_tab_close_one_page,
        &new_value);
    LEAVE(" ");
}


static void
gnc_main_window_update_tab_color_one_page (GncPluginPage *page,
        gpointer user_data)
{
    const gchar          *color_string;

    ENTER("page %p", page);
    color_string = gnc_plugin_page_get_page_color(page);
    main_window_update_page_color (page, color_string);
    LEAVE(" ");
}


static void
gnc_main_window_update_tab_color (gpointer gsettings, gchar *pref, gpointer user_data)
{
    ENTER(" ");
    g_return_if_fail(GNC_IS_MAIN_WINDOW(user_data));
    auto window{static_cast<GncMainWindow*>(user_data)};
    auto priv{GNC_MAIN_WINDOW_GET_PRIVATE(window)};
    if (g_strcmp0 (GNC_PREF_TAB_COLOR, pref) == 0)
        priv->show_color_tabs = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_COLOR);
    gnc_main_window_foreach_page (gnc_main_window_update_tab_color_one_page, window);
    LEAVE(" ");
}


typedef struct
{
    gint tab_width;
    gboolean tabs_left_right;
} TabWidth;

static TabWidth *
populate_tab_width_struct (void)
{
    TabWidth *tw;

    tw = g_new0 (TabWidth, 1);
    tw->tab_width = gnc_prefs_get_float (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_WIDTH);
    tw->tabs_left_right = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT) ||
                          gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT);

    return tw;
}

static void
gnc_main_window_set_tab_ellipsize (GtkWidget *label, gint tab_width, gboolean tab_left_right)
{
    const gchar *lab_text = gtk_label_get_text (GTK_LABEL(label));

    if (tab_width != 0)
    {
        gint text_length = g_utf8_strlen (lab_text, -1);
        if (text_length < tab_width)
        {
            if (tab_left_right) // tabs position is left or right
                gtk_label_set_width_chars (GTK_LABEL(label), tab_width);
            else // tabs position is top or bottom
                gtk_label_set_width_chars (GTK_LABEL(label), text_length);

            gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_NONE);
        }
        else
        {
            gtk_label_set_width_chars (GTK_LABEL(label), tab_width);
            gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
        }
    }
    else
    {
        gtk_label_set_width_chars (GTK_LABEL(label), 15);
        gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_NONE);
    }
}


static void
gnc_main_window_update_tab_width_one_page (GncPluginPage *page,
                                           gpointer user_data)
{
    auto tw{static_cast<TabWidth*>(user_data)};

    ENTER("page %p, tab width %d, tabs on left or right %d",
           page, tw->tab_width, tw->tabs_left_right);

    auto label{static_cast<GtkWidget *>(g_object_get_data(G_OBJECT (page), PLUGIN_PAGE_TAB_LABEL))};
    if (!label)
    {
        LEAVE("no label");
        return;
    }
    gnc_main_window_set_tab_ellipsize (label, tw->tab_width, tw->tabs_left_right);
    LEAVE(" ");
}


static void
gnc_main_window_update_tab_width (gpointer prefs, gchar *pref, gpointer user_data)
{
    TabWidth *tw;

    ENTER(" ");

    tw = populate_tab_width_struct ();

    gnc_main_window_foreach_page (gnc_main_window_update_tab_width_one_page, tw);
    g_free (tw);

    LEAVE(" ");
}


/************************************************************
 *                 Tab Label Implementation                 *
 ************************************************************/
static gboolean
main_window_find_tab_items (GncMainWindow *window,
                            GncPluginPage *page,
                            GtkWidget **label_p,
                            GtkWidget **entry_p)
{
    GncMainWindowPrivate *priv;
    GtkWidget *tab_hbox, *widget, *tab_widget;
    GList *children, *tmp;

    ENTER("window %p, page %p, label_p %p, entry_p %p",
          window, page, label_p, entry_p);
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    *label_p = *entry_p = nullptr;

    if (!page->notebook_page)
    {
        LEAVE("invalid notebook_page");
        return FALSE;
    }

    tab_widget = gtk_notebook_get_tab_label(GTK_NOTEBOOK(priv->notebook),
                                           page->notebook_page);

    // Walk through children to find the box containing label+entry
    tab_hbox = tab_widget;
    while (tab_hbox) {
        if (g_strcmp0(gtk_widget_get_name(tab_hbox), "tab-content") == 0) {
            break;
        }
        GList* _children = gtk_container_get_children(GTK_CONTAINER(tab_hbox));
        tab_hbox = _children ? GTK_WIDGET(_children->data) : nullptr;
        g_list_free(_children);
    }

    if (!GTK_IS_BOX(tab_hbox))
    {
        PWARN ("Unknown widget for tab label %p", tab_widget);
        return FALSE;
    }

    children = gtk_container_get_children(GTK_CONTAINER(tab_hbox));
    for (tmp = children; tmp; tmp = g_list_next(tmp))
    {
        widget = static_cast<GtkWidget*>(tmp->data);
        if (GTK_IS_LABEL(widget))
        {
            *label_p = widget;
        }
        else if (GTK_IS_ENTRY(widget))
        {
            *entry_p = widget;
        }
    }
    g_list_free(children);

    LEAVE("label %p, entry %p", *label_p, *entry_p);
    return (*label_p && *entry_p);
}

static gboolean
main_window_find_tab_widget (GncMainWindow *window,
                             GncPluginPage *page,
                             GtkWidget **widget_p)
{
    GncMainWindowPrivate *priv;

    ENTER("window %p, page %p, widget %p",
          window, page, widget_p);
    *widget_p = nullptr;

    if (!page->notebook_page)
    {
        LEAVE("invalid notebook_page");
        return FALSE;
    }

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    *widget_p = gtk_notebook_get_tab_label(GTK_NOTEBOOK(priv->notebook),
                                           page->notebook_page);

    LEAVE("widget %p", *widget_p);
    return TRUE;
}

void
main_window_update_page_long_name (GncPluginPage *page,
                                   const gchar *long_name_in)
{
    GtkWidget *tab_widget;

    ENTER(" ");

    if ((long_name_in == nullptr) || (*long_name_in == '\0'))
    {
        LEAVE("no string");
        return;
    }
    gchar *long_name = g_strstrip (g_strdup (long_name_in));
    const gchar *old_long_name = gnc_plugin_page_get_page_long_name (page);

    /* Optimization, if the long_name hasn't changed, don't update X. */
    if (*long_name == '\0' || strcmp (long_name, old_long_name) == 0)
    {
        g_free (long_name);
        LEAVE("empty string or name unchanged");
        return;
    }

    gnc_plugin_page_set_page_long_name (page, long_name);

    GncMainWindow *window = GNC_MAIN_WINDOW(page->window);
    if (!window)
    {
        g_free (long_name);
        LEAVE("no window widget available");
        return;
    }

    /* Update the notebook tab tooltip */
    if (main_window_find_tab_widget (window, page, &tab_widget))
        gtk_widget_set_tooltip_text (tab_widget, long_name);

    g_free (long_name);
    LEAVE("");
}

void
main_window_update_page_name (GncPluginPage *page,
                              const gchar *name_in)
{
    GncMainWindow *window;
    GncMainWindowPrivate *priv;
    GtkWidget *label, *entry;
    gchar *name;
    TabWidth *tw;

    ENTER(" ");

    if ((name_in == nullptr) || (*name_in == '\0'))
    {
        LEAVE("no string");
        return;
    }
    name = g_strstrip(g_strdup(name_in));

    /* Optimization, if the name hasn't changed, don't update X. */
    if (*name == '\0' || 0 == strcmp(name, gnc_plugin_page_get_page_name(page)))
    {
        g_free(name);
        LEAVE("empty string or name unchanged");
        return;
    }

    /* Update the plugin */
    gnc_plugin_page_set_page_name(page, name);

    /* Update the notebook tab */
    window = GNC_MAIN_WINDOW(page->window);
    if (!window)
    {
        g_free(name);
        LEAVE("no window widget available");
        return;
    }

    if (main_window_find_tab_items(window, page, &label, &entry))
        gtk_label_set_text(GTK_LABEL(label), name);

    /* Adjust the label width for new text */
    tw = populate_tab_width_struct ();
    gnc_main_window_update_tab_width_one_page (page, tw);
    g_free (tw);

    /* Update the notebook menu */
    if (page->notebook_page)
    {
        priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
        label = gtk_notebook_get_menu_label (GTK_NOTEBOOK(priv->notebook),
                                             page->notebook_page);
        gtk_label_set_text(GTK_LABEL(label), name);
    }

    /* Force an update of the window title */
    gnc_main_window_update_title(window);
    g_free(name);
    LEAVE("done");
}


void
main_window_update_page_color (GncPluginPage *page,
                               const gchar *color_in)
{
    GncMainWindow *window;
    GncMainWindowPrivate *priv;
    GtkWidget *tab_widget;
    GdkRGBA tab_color;
    gchar *color_string = nullptr;
    gboolean want_color = FALSE;

    ENTER(" ");
    if (color_in)
        color_string = g_strstrip(g_strdup(color_in));

    if (color_string && *color_string != '\0')
        want_color = TRUE;

    /* Update the plugin */
    window = GNC_MAIN_WINDOW(page->window);
    if (want_color)
        gnc_plugin_page_set_page_color(page, color_string);
    else
        gnc_plugin_page_set_page_color(page, nullptr);

    /* Update the notebook tab */
    main_window_find_tab_widget (window, page, &tab_widget);
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    if (want_color && gdk_rgba_parse(&tab_color, color_string) && priv->show_color_tabs)
    {
        GtkCssProvider *provider = gtk_css_provider_new();
        GtkStyleContext *stylectxt;
        gchar *col_str, *widget_css;

        if (!GTK_IS_EVENT_BOX (tab_widget))
        {
            GtkWidget *event_box = gtk_event_box_new ();
            g_object_ref (tab_widget);
            gtk_notebook_set_tab_label (GTK_NOTEBOOK(priv->notebook),
                                        page->notebook_page, event_box);
            gtk_container_add (GTK_CONTAINER(event_box), tab_widget);
            g_object_unref (tab_widget);
            tab_widget = event_box;
        }

        stylectxt = gtk_widget_get_style_context (GTK_WIDGET (tab_widget));
        col_str = gdk_rgba_to_string (&tab_color);
        widget_css = g_strconcat ("*{\n  background-color:", col_str, ";\n}\n", nullptr);

        gtk_css_provider_load_from_data (provider, widget_css, -1, nullptr);
        gtk_style_context_add_provider (stylectxt, GTK_STYLE_PROVIDER (provider),
                                        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
        g_object_unref (provider);
        g_free (col_str);
        g_free (widget_css);
    }
    else
    {
        if (GTK_IS_EVENT_BOX (tab_widget))
        {
            GtkWidget *tab_hbox = gtk_bin_get_child(GTK_BIN(tab_widget));
            g_object_ref (tab_hbox);
            gtk_container_remove (GTK_CONTAINER(tab_widget), tab_hbox);
            gtk_notebook_set_tab_label (GTK_NOTEBOOK(priv->notebook),
                                        page->notebook_page, tab_hbox);
            g_object_unref (tab_hbox);
        }
    }
    g_free(color_string);
    LEAVE("done");
}


void
main_window_update_page_set_read_only_icon (GncPluginPage *page,
                                            gboolean read_only)
{
    GncMainWindow *window;
    GtkWidget *tab_widget;
    GtkWidget *image = NULL;
    GList *children;
    gchar *image_name = NULL;
    const gchar *icon_name;

    ENTER(" ");

    g_return_if_fail (page && page->window);

    if (!GNC_IS_MAIN_WINDOW (page->window))
        return;

    window = GNC_MAIN_WINDOW(page->window);

    /* Get the notebook tab widget */
    main_window_find_tab_widget (window, page, &tab_widget);

    if (!tab_widget)
    {
        LEAVE("no tab widget");
        return;
    }

    if (GTK_IS_EVENT_BOX(tab_widget))
        tab_widget = gtk_bin_get_child (GTK_BIN(tab_widget));

    children = gtk_container_get_children (GTK_CONTAINER(tab_widget));
    /* For each, walk the list of container children to get image widget */
    for (GList *child = children; child; child = g_list_next (child))
    {
        GtkWidget *widget = static_cast<GtkWidget*>(child->data);
        if (GTK_IS_IMAGE(widget))
            image = widget;
    }
    g_list_free (children);

    if (!image)
    {
        LEAVE("no image to replace");
        return;
    }

    g_object_get (image, "icon-name", &image_name, NULL);

    if (read_only)
        icon_name = "changes-prevent-symbolic";
    else
        icon_name = GNC_PLUGIN_PAGE_GET_CLASS(page)->tab_icon;

    if (g_strcmp0 (icon_name, image_name) == 0)
    {
        LEAVE("page icon the same, no need to replace");
        g_free (image_name);
        return;
    }
    gtk_container_remove (GTK_CONTAINER(tab_widget), image);
    image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
    gtk_widget_show (image);

    gtk_container_add (GTK_CONTAINER(tab_widget), image);
    gtk_widget_set_margin_start (GTK_WIDGET(image), 5);
    gtk_box_reorder_child (GTK_BOX(tab_widget), image, 0);

    g_free (image_name);
    LEAVE("done");
}


static void
gnc_main_window_tab_entry_activate (GtkWidget *entry,
                                    GncPluginPage *page)
{
    GtkWidget *label, *entry2;

    g_return_if_fail(GTK_IS_ENTRY(entry));
    g_return_if_fail(GNC_IS_PLUGIN_PAGE(page));

    ENTER("");
    if (!main_window_find_tab_items(GNC_MAIN_WINDOW(page->window),
                                    page, &label, &entry2))
    {
        LEAVE("can't find required widgets");
        return;
    }

    main_window_update_page_name(page, gtk_entry_get_text(GTK_ENTRY(entry)));

    gtk_widget_hide(entry);
    gtk_widget_show(label);
    LEAVE("");
}


static gboolean
gnc_main_window_tab_entry_editing_done (GtkWidget *entry,
                                        GncPluginPage *page)
{
    ENTER("");
    gnc_main_window_tab_entry_activate(entry, page);
    LEAVE("");
    return FALSE;
}

static gboolean
gnc_main_window_tab_entry_focus_out_event (GtkWidget *entry,
        GdkEvent *event,
        GncPluginPage *page)
{
    ENTER("");
    gtk_cell_editable_editing_done(GTK_CELL_EDITABLE(entry));
    LEAVE("");
    return FALSE;
}

static gboolean
gnc_main_window_tab_entry_key_press_event (GtkWidget *entry,
        GdkEventKey *event,
        GncPluginPage *page)
{
    if (event->keyval == GDK_KEY_Escape)
    {
        GtkWidget *label, *entry2;

        g_return_val_if_fail(GTK_IS_ENTRY(entry), FALSE);
        g_return_val_if_fail(GNC_IS_PLUGIN_PAGE(page), FALSE);

        ENTER("");
        if (!main_window_find_tab_items(GNC_MAIN_WINDOW(page->window),
                                        page, &label, &entry2))
        {
            LEAVE("can't find required widgets");
            return FALSE;
        }

        gtk_entry_set_text(GTK_ENTRY(entry), gtk_label_get_text(GTK_LABEL(label)));
        gtk_widget_hide(entry);
        gtk_widget_show(label);
        LEAVE("");
    }
    return FALSE;
}

/************************************************************
 *                   Widget Implementation                  *
 ************************************************************/



static void
gnc_main_window_class_init (GncMainWindowClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
    GtkWidgetClass *gtkwidget_class = GTK_WIDGET_CLASS(klass);

    window_type = g_quark_from_static_string ("gnc-main-window");

    object_class->constructed = gnc_main_window_constructed;
    object_class->finalize = gnc_main_window_finalize;

    /* GtkWidget signals */
    gtkwidget_class->destroy = gnc_main_window_destroy;

    main_window_signals[PAGE_ADDED] =
        g_signal_new ("page_added",
                      G_OBJECT_CLASS_TYPE (object_class),
                      G_SIGNAL_RUN_FIRST,
                      G_STRUCT_OFFSET (GncMainWindowClass, page_added),
                      nullptr, nullptr,
                      g_cclosure_marshal_VOID__OBJECT,
                      G_TYPE_NONE, 1,
                      G_TYPE_OBJECT);

    main_window_signals[PAGE_CHANGED] =
        g_signal_new ("page_changed",
                      G_OBJECT_CLASS_TYPE (object_class),
                      G_SIGNAL_RUN_FIRST,
                      G_STRUCT_OFFSET (GncMainWindowClass, page_changed),
                      nullptr, nullptr,
                      g_cclosure_marshal_VOID__OBJECT,
                      G_TYPE_NONE, 1,
                      G_TYPE_OBJECT);

    main_window_signals[MENU_CHANGED] =
        g_signal_new ("menu_changed",
                      G_OBJECT_CLASS_TYPE (object_class),
                      G_SIGNAL_RUN_FIRST,
                      G_STRUCT_OFFSET (GncMainWindowClass, menu_changed),
                      nullptr, nullptr,
                      g_cclosure_marshal_VOID__OBJECT,
                      G_TYPE_NONE, 1,
                      G_TYPE_OBJECT);

    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_SHOW_CLOSE_BUTTON,
                           (gpointer)gnc_main_window_update_tab_close,
                           nullptr);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_TAB_WIDTH,
                           (gpointer)gnc_main_window_update_tab_width,
                           nullptr);

    gnc_hook_add_dangler(HOOK_BOOK_SAVED,
                         (GFunc)gnc_main_window_update_all_titles, nullptr, nullptr);
    gnc_hook_add_dangler(HOOK_BOOK_OPENED,
                         (GFunc)gnc_main_window_attach_to_book, nullptr, nullptr);

}


static void
gnc_main_window_init (GncMainWindow *window)
{
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    // Set the name for this dialog so it can be easily manipulated with css
    gtk_widget_set_name (GTK_WIDGET(window), "gnc-id-main-window");

    priv->event_handler_id =
        qof_event_register_handler(gnc_main_window_event_handler, window);

    priv->restoring_pages = FALSE;

    priv->display_item_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, nullptr);

    priv->previous_plugin_page_name = nullptr;
    priv->previous_menu_qualifier = nullptr;

    priv->accel_group = gtk_accel_group_new ();
    gtk_window_add_accel_group (GTK_WINDOW(window), priv->accel_group);

    /* Get the show_color_tabs value preference */
    priv->show_color_tabs = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_COLOR);

    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_TAB_COLOR,
                           (gpointer)gnc_main_window_update_tab_color,
                           window);

    gnc_main_window_setup_window (window);
}

static void
gnc_main_window_constructed (GObject *obj)
{
    gnc_gobject_tracking_remember(obj);

    G_OBJECT_CLASS (gnc_main_window_parent_class)->constructed (obj);
}

static void
gnc_main_window_finalize (GObject *object)
{
    g_return_if_fail (object != nullptr);
    g_return_if_fail (GNC_IS_MAIN_WINDOW (object));

    if (active_windows == nullptr)
    {
        /* Oops. User killed last window and we didn't catch it. */
        g_idle_add((GSourceFunc)gnc_shutdown, 0);
    }

    gnc_gobject_tracking_forget(object);
    G_OBJECT_CLASS (gnc_main_window_parent_class)->finalize (object);
}


static void
gnc_main_window_remove_prefs (GncMainWindow *window)
{
    // remove the registered preference callbacks setup in this file.
    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_TAB_COLOR,
                                 (gpointer)gnc_main_window_update_tab_color,
                                 window);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_SHOW_CLOSE_BUTTON,
                                 (gpointer)gnc_main_window_update_tab_close,
                                 nullptr);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_TAB_WIDTH,
                                 (gpointer)gnc_main_window_update_tab_width,
                                 nullptr);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_TAB_POSITION_TOP,
                                 (gpointer)gnc_main_window_update_tab_position,
                                 window);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_TAB_POSITION_BOTTOM,
                                 (gpointer)gnc_main_window_update_tab_position,
                                 window);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_TAB_POSITION_LEFT,
                                 (gpointer)gnc_main_window_update_tab_position,
                                 window);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_TAB_POSITION_RIGHT,
                                 (gpointer)gnc_main_window_update_tab_position,
                                 window);

    // remove the registered negative color preference callback.
    if (gnc_prefs_get_reg_negative_color_pref_id() > 0 && window->window_quitting)
    {
        gnc_prefs_remove_cb_by_id (GNC_PREFS_GROUP_GENERAL,
                                   gnc_prefs_get_reg_negative_color_pref_id());
        gnc_prefs_set_reg_negative_color_pref_id (0);
    }

    // remove the registered auto_raise_lists preference callback.
    if (gnc_prefs_get_reg_auto_raise_lists_id() > 0 && window->window_quitting)
    {
        gnc_prefs_remove_cb_by_id (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                   gnc_prefs_get_reg_auto_raise_lists_id());
        gnc_prefs_set_reg_auto_raise_lists_id (0);
    }
}


static void
gnc_main_window_destroy (GtkWidget *widget)
{
    GncMainWindow *window;
    GncMainWindowPrivate *priv;
    GncPluginManager *manager;
    GList *plugins;

    g_return_if_fail (widget != nullptr);
    g_return_if_fail (GNC_IS_MAIN_WINDOW (widget));

    window = GNC_MAIN_WINDOW (widget);
#ifdef MAC_INTEGRATION
    auto entry = g_list_find (active_windows, window);
    if (entry && (entry->next || entry->prev))
        gnc_quartz_set_menu (GNC_MAIN_WINDOW (entry->next ? entry->next->data : entry->prev->data));
#endif
    active_windows = g_list_remove (active_windows, window);

    /* Do these things once */
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    if (priv->event_handler_id > 0)
    {

        /* Close any pages in this window */
        while (priv->current_page)
            gnc_main_window_close_page(priv->current_page);

        if (gnc_window_get_progressbar_window() == GNC_WINDOW(window))
            gnc_window_set_progressbar_window(nullptr);
#ifndef MAC_INTEGRATION
        /* Update the "Windows" menu in all other windows */
        gnc_main_window_update_all_menu_items();
#endif
        /* remove the preference callbacks from the main window */
        gnc_main_window_remove_prefs (window);

        qof_event_unregister_handler(priv->event_handler_id);
        priv->event_handler_id = 0;

        g_hash_table_destroy (priv->display_item_hash);

        /* GncPluginManager stuff */
        manager = gnc_plugin_manager_get ();
        plugins = gnc_plugin_manager_get_plugins (manager);
        g_list_foreach (plugins, gnc_main_window_remove_plugin, window);
        g_list_free (plugins);
    }

    GTK_WIDGET_CLASS (gnc_main_window_parent_class)->destroy (widget);
}


static gboolean
gnc_main_window_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer user_data)
{
    GncMainWindowPrivate *priv;
    GdkModifierType modifiers;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(widget), FALSE);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(widget);

    modifiers = gtk_accelerator_get_default_mod_mask ();

    if ((event->state & modifiers) == (GDK_CONTROL_MASK | GDK_MOD1_MASK)) // Ctrl+Alt+
    {
        const gchar *account_key = C_ ("lower case key for short cut to 'Accounts'", "a");
        guint account_keyval = gdk_keyval_from_name (account_key);

        if ((account_keyval == event->keyval) || (account_keyval == gdk_keyval_to_lower (event->keyval)))
        {
            gint page = 0;

            for (GList *item = priv->installed_pages; item; item = g_list_next (item))
            {
                 const gchar *pname = gnc_plugin_page_get_plugin_name (GNC_PLUGIN_PAGE(item->data));

                 if (g_strcmp0 (pname, "GncPluginPageAccountTree") == 0)
                 {
                     gtk_notebook_set_current_page (GTK_NOTEBOOK(priv->notebook), page);
                     return TRUE;
                 }
                 page++;
            }
        }
        else if ((GDK_KEY_Menu == event->keyval) || (GDK_KEY_space == event->keyval))
        {
            GList *menu = gtk_menu_get_for_attach_widget (GTK_WIDGET(priv->notebook));

            if (menu)
            {
                gtk_menu_popup_at_widget (GTK_MENU(menu->data),
                                          GTK_WIDGET(priv->notebook),
                                          GDK_GRAVITY_SOUTH,
                                          GDK_GRAVITY_SOUTH,
                                          NULL);
                return TRUE;
            }
        }
    }
    return FALSE;
}


/*  Create a new gnc main window plugin.
 */
GncMainWindow *
gnc_main_window_new (void)
{
    auto window{static_cast<GncMainWindow*>(g_object_new (GNC_TYPE_MAIN_WINDOW, nullptr))};
    gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);

    auto old_window = gnc_ui_get_main_window (nullptr);
    if (old_window)
    {
        gint width, height;
        gtk_window_get_size (old_window, &width, &height);
        gtk_window_resize (GTK_WINDOW (window), width, height);
        if ((gdk_window_get_state((gtk_widget_get_window (GTK_WIDGET(old_window))))
                & GDK_WINDOW_STATE_MAXIMIZED) != 0)
        {
            gtk_window_maximize (GTK_WINDOW (window));
        }
    }
    active_windows = g_list_append (active_windows, window);
    gnc_main_window_update_title(window);
    window->window_quitting = FALSE;
    window->just_plugin_prefs = FALSE;
#ifdef MAC_INTEGRATION
    gnc_quartz_set_menu(window);
#else
    gnc_main_window_update_all_menu_items();
#endif
    gnc_engine_add_commit_error_callback( gnc_main_window_engine_commit_error_callback, window );

    // set up a callback for notebook navigation
    g_signal_connect (G_OBJECT(window), "key-press-event",
                      G_CALLBACK(gnc_main_window_key_press_event),
                      NULL);

    return window;
}

/************************************************************
 *                     Utility Functions                    *
 ************************************************************/

static void
gnc_main_window_engine_commit_error_callback( gpointer data,
        QofBackendError errcode )
{
    GncMainWindow* window = GNC_MAIN_WINDOW(data);
    GtkWidget* dialog;
    const gchar *reason = _("Unable to save to database.");
    if ( errcode == ERR_BACKEND_READONLY )
        reason = _("Unable to save to database: Book is marked read-only.");
    dialog = gtk_message_dialog_new( GTK_WINDOW(window),
                                     GTK_DIALOG_DESTROY_WITH_PARENT,
                                     GTK_MESSAGE_ERROR,
                                     GTK_BUTTONS_CLOSE,
                                     "%s",
                                     reason );
    gtk_dialog_run(GTK_DIALOG (dialog));
    gtk_widget_destroy(dialog);

}

static void
gnc_main_window_connect (GncMainWindow *window,
                         GncPluginPage *page,
                         GtkWidget *tab_hbox,
                         GtkWidget *menu_label)
{
    GncMainWindowPrivate *priv;
    GtkNotebook *notebook;
    gint current_position = -1;

    page->window = GTK_WIDGET(window);
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    notebook = GTK_NOTEBOOK (priv->notebook);

    if (!priv->restoring_pages
            && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_OPEN_ADJACENT))
        current_position = g_list_index (priv->installed_pages, priv->current_page) + 1;

    priv->installed_pages = g_list_insert (priv->installed_pages, page, current_position);
    priv->usage_order = g_list_prepend (priv->usage_order, page);
    gtk_notebook_insert_page_menu (notebook, page->notebook_page,
                                   tab_hbox, menu_label, current_position);
    gtk_notebook_set_tab_reorderable (notebook, page->notebook_page, TRUE);
    gnc_plugin_page_inserted (page);
    if (!priv->restoring_pages)
        gtk_notebook_set_current_page (notebook, current_position);

    if (GNC_PLUGIN_PAGE_GET_CLASS(page)->window_changed)
        (GNC_PLUGIN_PAGE_GET_CLASS(page)->window_changed)(page, GTK_WIDGET(window));
    g_signal_emit (window, main_window_signals[PAGE_ADDED], 0, page);

    g_signal_connect(G_OBJECT(page->notebook_page), "popup-menu",
                     G_CALLBACK(gnc_main_window_popup_menu_cb), page);
    g_signal_connect_after(G_OBJECT(page->notebook_page), "button-press-event",
                           G_CALLBACK(gnc_main_window_button_press_cb), page);
}


static void
gnc_main_window_disconnect (GncMainWindow *window,
                            GncPluginPage *page)
{
    GncMainWindowPrivate *priv;
    GtkNotebook *notebook;
    GncPluginPage *new_page;
    gint page_num;

    /* Disconnect the callbacks */
    g_signal_handlers_disconnect_by_func(G_OBJECT(page->notebook_page),
                                         (gpointer)gnc_main_window_popup_menu_cb, page);
    g_signal_handlers_disconnect_by_func(G_OBJECT(page->notebook_page),
                                         (gpointer)gnc_main_window_button_press_cb, page);

    // Remove the page_changed signal callback
    gnc_plugin_page_disconnect_page_changed (GNC_PLUGIN_PAGE(page));

    /* Disconnect the page and summarybar from the window */
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    if (priv->current_page == page)
    {
        gnc_plugin_page_unselected (page);
        priv->current_page = nullptr;
    }

    /* Remove it from the list of pages in the window */
    priv->installed_pages = g_list_remove (priv->installed_pages, page);
    priv->usage_order = g_list_remove (priv->usage_order, page);

    /* Switch to the last recently used page */
    notebook = GTK_NOTEBOOK (priv->notebook);
    if (gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_NEXT_RECENT))
    {
        new_page = static_cast<GncPluginPage*>(g_list_nth_data (priv->usage_order, 0));
        if (new_page)
        {
            page_num = gtk_notebook_page_num(notebook, new_page->notebook_page);
            gtk_notebook_set_current_page(notebook, page_num);
            /* This may have caused WebKit to schedule  a timer interrupt which it
               sometimes  forgets to cancel before deleting the object.  See
               <https://bugs.webkit.org/show_bug.cgi?id=119003>.   Get around this
               by flushing all events to get rid of the timer interrupt. */
            while (gtk_events_pending())
                gtk_main_iteration();
        }
    }

    /* Remove the page from the notebook */
    page_num =  gtk_notebook_page_num(notebook, page->notebook_page);
    gtk_notebook_remove_page (notebook, page_num);

    if ( gtk_notebook_get_current_page(notebook) == -1)
    {
        /* Need to synthesize a page changed signal when the last
         * page is removed.  The notebook doesn't generate a signal
         * for this, therefore the switch_page code in this file
         * never gets called to generate this signal. */
        gnc_main_window_switch_page(notebook, nullptr, -1, window);
        //g_signal_emit (window, main_window_signals[PAGE_CHANGED], 0, nullptr);
    }

    gnc_plugin_page_removed (page);

    gnc_window_set_status (GNC_WINDOW(window), page, nullptr);
}


/************************************************************
 *                                                          *
 ************************************************************/


void
gnc_main_window_display_page (GncPluginPage *page)
{
    GncMainWindow *window;
    GncMainWindowPrivate *priv;
    GtkNotebook *notebook;
    gint page_num;

    window = GNC_MAIN_WINDOW (page->window);
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    notebook = GTK_NOTEBOOK (priv->notebook);
    page_num = gtk_notebook_page_num(notebook, page->notebook_page);
    gtk_notebook_set_current_page (notebook, page_num);
    gtk_window_present(GTK_WINDOW(window));
}


/*  Display a data plugin page in a window.  If the page already
 *  exists in any window, then that window will be brought to the
 *  front and the notebook switch to display the specified page.  If
 *  the page is new then it will be added to the specified window.  If
 *  the window is nullptr, the new page will be added to the first
 *  window.
 */
void
gnc_main_window_open_page (GncMainWindow *window,
                           GncPluginPage *page)
{
    GncMainWindowPrivate *priv;
    GtkWidget *tab_container, *tab_clickable_area;
    GtkWidget *label, *entry;
    const gchar *icon, *text, *color_string, *lab_text;
    GtkWidget *image;
    GList *tmp;
    TabWidth *tw;

    ENTER("window %p, page %p", window, page);
    if (window)
        g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
    g_return_if_fail (GNC_IS_PLUGIN_PAGE (page));
    g_return_if_fail (gnc_plugin_page_has_books(page));

    if (gnc_main_window_page_exists(page))
    {
        gnc_main_window_display_page (page);
        return;
    }

    /* Does the page want to be in a new window? */
    if (gnc_plugin_page_get_use_new_window(page))
    {
        /* See if there's a blank window. If so, use that. */
        for (tmp = active_windows; tmp; tmp = g_list_next(tmp))
        {
            window = GNC_MAIN_WINDOW(tmp->data);
            priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
            if (priv->installed_pages == nullptr)
            {
                break;
            }
        }
        if (tmp == nullptr)
            window = gnc_main_window_new ();
        gtk_widget_show(GTK_WIDGET(window));
    }
    else if ((window == nullptr) && active_windows)
    {
        window = static_cast<GncMainWindow*>(active_windows->data);
    }

    page->window = GTK_WIDGET(window);
    page->notebook_page = gnc_plugin_page_create_widget (page);
    g_object_set_data (G_OBJECT (page->notebook_page),
                       PLUGIN_PAGE_LABEL, page);

    /*
     * The page tab.
     * Component structure:
     *
     * tab_container (GtkBox)
     * ├── tab_clickable_area (GtkEventBox)
     * │   └── tab_content (GtkBox)
     * │       ├── image (GtkImage, optional)
     * │       ├── label (GtkLabel)
     * │       └── entry (GtkEntry, hidden)
     * └── close_button (GtkButton, if not immutable)
     */
    icon = GNC_PLUGIN_PAGE_GET_CLASS(page)->tab_icon;
    lab_text = gnc_plugin_page_get_page_name(page);
    label = gtk_label_new (lab_text);
    g_object_set_data (G_OBJECT (page), PLUGIN_PAGE_TAB_LABEL, label);

    tw = populate_tab_width_struct ();
    gnc_main_window_update_tab_width_one_page (page, tw);
    g_free (tw);

    gtk_widget_show (label);

    tab_container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

    text = gnc_plugin_page_get_page_long_name(page);
    if (text)
    {
        gtk_widget_set_tooltip_text(tab_container, text);
    }

    if (g_strcmp0 (gnc_plugin_page_get_plugin_name (page), "GncPluginPageAccountTree") == 0)
        gtk_widget_set_name (GTK_WIDGET(tab_container), "gnc-id-account-page-tab-box");

    gtk_box_set_homogeneous (GTK_BOX (tab_container), FALSE);
    gtk_widget_show (tab_container);

    // Create a custom clickable area for the tab to support middle-clicking
    tab_clickable_area = gtk_event_box_new();
    gtk_widget_show(tab_clickable_area);
    gtk_box_pack_start (GTK_BOX (tab_container), tab_clickable_area, TRUE, TRUE, 0);

    // Create a box for the tab's content
    // Give it a name so we can find it later (see main_window_find_tab_items)
    GtkWidget *tab_content = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
    gtk_widget_set_name(tab_content, "tab-content");
    gtk_container_add(GTK_CONTAINER(tab_clickable_area), tab_content);
    gtk_widget_show(tab_content);

    if (icon != nullptr)
    {
        image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU);
        gtk_widget_show (image);
        gtk_box_pack_start (GTK_BOX (tab_content), image, FALSE, FALSE, 0);
        gtk_widget_set_margin_start (GTK_WIDGET(image), 5);
        gtk_box_pack_start (GTK_BOX (tab_content), label, TRUE, TRUE, 0);
    }
    else
        gtk_box_pack_start (GTK_BOX (tab_content), label, TRUE, TRUE, 0);

    entry = gtk_entry_new();
    gtk_widget_hide (entry);
    gtk_box_pack_start (GTK_BOX (tab_content), entry, TRUE, TRUE, 0);
    g_signal_connect(G_OBJECT(entry), "activate",
                     G_CALLBACK(gnc_main_window_tab_entry_activate), page);
    g_signal_connect(G_OBJECT(entry), "focus-out-event",
                     G_CALLBACK(gnc_main_window_tab_entry_focus_out_event),
                     page);
    g_signal_connect(G_OBJECT(entry), "key-press-event",
                     G_CALLBACK(gnc_main_window_tab_entry_key_press_event),
                     page);
    g_signal_connect(G_OBJECT(entry), "editing-done",
                     G_CALLBACK(gnc_main_window_tab_entry_editing_done),
                     page);

    /* Add close button - Not for immutable pages */
    if (!g_object_get_data (G_OBJECT (page), PLUGIN_PAGE_IMMUTABLE))
    {
        GtkWidget *close_image, *close_button;
        GtkRequisition requisition;

        close_button = gtk_button_new();
        gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
        close_image = gtk_image_new_from_icon_name ("window-close", GTK_ICON_SIZE_MENU);
        gtk_widget_show(close_image);
        gtk_widget_get_preferred_size (close_image, &requisition, nullptr);
        gtk_widget_set_size_request(close_button, requisition.width + 4,
                                    requisition.height + 2);
        gtk_container_add(GTK_CONTAINER(close_button), close_image);
        if (gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SHOW_CLOSE_BUTTON))
            gtk_widget_show (close_button);
        else
            gtk_widget_hide (close_button);

        // Custom handler to close on middle-clicks
        g_signal_connect(G_OBJECT(tab_clickable_area), "button-press-event",
                         G_CALLBACK(gnc_tab_clicked_cb), page);

        g_signal_connect_swapped (G_OBJECT (close_button), "clicked",
                                  G_CALLBACK(gnc_main_window_close_page), page);

        gtk_box_pack_start (GTK_BOX (tab_container), close_button, FALSE, FALSE, 0);
        gtk_widget_set_margin_end (GTK_WIDGET(close_button), 5);
        g_object_set_data (G_OBJECT (page), PLUGIN_PAGE_CLOSE_BUTTON, close_button);
    }

    /*
     * The popup menu
     */
    label = gtk_label_new (gnc_plugin_page_get_page_name(page));

    /*
     * Now install it all in the window.
     */
    gnc_main_window_connect(window, page, tab_container, label);

    color_string = gnc_plugin_page_get_page_color(page);
    main_window_update_page_color (page, color_string);
    LEAVE("");
}


/*  Remove a data plugin page from a window and display the previous
 *  page.  If the page removed was the last page in the window, and
 *  there is more than one window open, then the entire window will be
 *  destroyed.
 */
void
gnc_main_window_close_page (GncPluginPage *page)
{
    GncMainWindow *window;
    GncMainWindowPrivate *priv;

    if (!page || !page->notebook_page)
        return;

    if (!gnc_plugin_page_finish_pending(page))
        return;

    if (!GNC_IS_MAIN_WINDOW (page->window))
        return;

    window = GNC_MAIN_WINDOW (page->window);
    if (!window)
    {
        g_warning("Page is not in a window.");
        return;
    }

    gnc_main_window_disconnect(window, page);
    gnc_plugin_page_destroy_widget (page);
    g_object_unref(page);

    /* If this isn't the last window, go ahead and destroy the window. */
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    if (priv->installed_pages == nullptr)
    {
        if (window->window_quitting)
        {
            GncPluginManager *manager = gnc_plugin_manager_get ();
            GList *plugins = gnc_plugin_manager_get_plugins (manager);

            /* remove only the preference callbacks from the window plugins */
            window->just_plugin_prefs = TRUE;
            g_list_foreach (plugins, gnc_main_window_remove_plugin, window);
            window->just_plugin_prefs = FALSE;
            g_list_free (plugins);

            /* remove the preference callbacks from the main window */
            gnc_main_window_remove_prefs (window);
        }
        if (window && (gnc_list_length_cmp (active_windows, 1) > 0))
            gtk_widget_destroy (GTK_WIDGET(window));
    }
}


/*  Retrieve a pointer to the page that is currently at the front of
 *  the specified window.  Any plugin that needs to manipulate its
 *  menus based upon the currently selected menu page should connect
 *  to the "page_changed" signal on a window.  The callback function
 *  from that signal can then call this function to obtain a pointer
 *  to the current page.
 */
GncPluginPage *
gnc_main_window_get_current_page (GncMainWindow *window)
{
    GncMainWindowPrivate *priv;

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    return priv->current_page;
}


/*  Manually add a set of actions to the specified window.  Plugins
 *  whose user interface is not hard coded (e.g. the menu-additions
 *  plugin) must create their actions at run time, then use this
 *  function to install them into the window.
 */
void
gnc_main_window_manual_merge_actions (GncMainWindow *window,
                                      const gchar *group_name,
                                      GSimpleActionGroup *group)
{
    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
    g_return_if_fail (group_name != nullptr);
    g_return_if_fail (G_IS_SIMPLE_ACTION_GROUP(group));

    gtk_widget_insert_action_group (GTK_WIDGET(window), group_name,
                                    G_ACTION_GROUP(group));
}


static void
update_menu_model (GncMainWindow *window, const gchar *ui_filename,
                   const gchar **ui_updates)
{
    GncMainWindowPrivate *priv;
    GError *error = nullptr;
    gchar *res_name;
    GtkBuilder *builder = gtk_builder_new ();
    GMenuModel *menu_model_part;
    GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);

    g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
    g_return_if_fail (ui_filename != nullptr);
    g_return_if_fail (ui_updates != nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    gtk_builder_set_translation_domain (builder, PROJECT_NAME);
    res_name = g_strconcat (GNUCASH_RESOURCE_PREFIX "/", ui_filename, NULL);

    gtk_builder_add_from_resource (builder, res_name, &error);
    g_free (res_name);

    if (error)
    {
        g_critical ("Failed to load, Error %s", error->message);
        g_error_free (error);
        return;
    }

    for (gint i = 0; ui_updates[i]; i++)
    {
        menu_model_part = (GMenuModel *)gtk_builder_get_object (builder, ui_updates[i]);

        gsm->search_action_label = nullptr;
        gsm->search_action_name = ui_updates[i];
        gsm->search_action_target = nullptr;

        if (gnc_menubar_model_find_item (priv->menubar_model, gsm))
            g_menu_insert_section (G_MENU(gsm->model), gsm->index, NULL, G_MENU_MODEL(menu_model_part));
        else
            PERR("Could not find '%s' in menu model", ui_updates[i]);
    }
    g_free (gsm);
    g_object_unref (builder);
}


/*  Add a set of actions to the specified window.  This function
 *  should not need to be called directly by plugin implementors.
 *  Correctly assigning values to the GncPluginClass fields during
 *  plugin initialization will cause this routine to be automatically
 *  called.
 */
void
gnc_main_window_merge_actions (GncMainWindow *window,
                               const gchar *group_name,
                               GActionEntry *actions,
                               guint n_actions,
                               const gchar **ui_updates,
                               const gchar *ui_filename,
                               gpointer user_data)
{
    GncMainWindowActionData *data;
    GSimpleActionGroup *simple_action_group;

    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
    g_return_if_fail (group_name != nullptr);
    g_return_if_fail (actions != nullptr);
    g_return_if_fail (n_actions > 0);

    data = g_new0 (GncMainWindowActionData, 1);
    data->window = window;
    data->data = user_data;

    simple_action_group = g_simple_action_group_new ();

    g_action_map_add_action_entries (G_ACTION_MAP(simple_action_group),
                                     actions,
                                     n_actions,
                                     data);

    gtk_widget_insert_action_group (GTK_WIDGET(window), group_name,
                                    G_ACTION_GROUP(simple_action_group));

    if (ui_filename)
        update_menu_model (window, ui_filename, ui_updates);
}


/*  Remove a set of actions from the specified window.  This function
 *  should not need to be called directly by plugin implementors.  It
 *  will automatically be called when a plugin is removed from a
 *  window.
 */
void
gnc_main_window_unmerge_actions (GncMainWindow *window,
                                 const gchar *group_name)
{
    g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
    g_return_if_fail (group_name != nullptr);

    gtk_widget_insert_action_group (GTK_WIDGET(window), group_name, nullptr);
}

GAction *
gnc_main_window_find_action (GncMainWindow *window, const gchar *action_name)
{
    GAction *action = nullptr;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
    g_return_val_if_fail (action_name != nullptr, nullptr);

    action = g_action_map_lookup_action (G_ACTION_MAP(window),
                                         action_name);

    return action;
}

GAction *
gnc_main_window_find_action_in_group (GncMainWindow *window,
                                      const gchar *group_name,
                                      const gchar *action_name)
{
    GAction *action = nullptr;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
    g_return_val_if_fail (group_name != nullptr, nullptr);
    g_return_val_if_fail (action_name != nullptr, nullptr);

    auto action_group = gtk_widget_get_action_group (GTK_WIDGET(window), group_name);

    if (action_group)
        action = g_action_map_lookup_action (G_ACTION_MAP(action_group), action_name);

    return action;
}


/*  Retrieve a specific set of user interface actions from a window.
 *  This function can be used to get an group of action to be
 *  manipulated when the front page of a window has changed.
 */
GSimpleActionGroup *
gnc_main_window_get_action_group (GncMainWindow *window,
                                  const gchar *group_name)
{
    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
    g_return_val_if_fail (group_name != nullptr, nullptr);

    auto action_group = gtk_widget_get_action_group (GTK_WIDGET(window), group_name);
    return (GSimpleActionGroup*)action_group;
}

GtkWidget *
gnc_main_window_toolbar_find_tool_item (GncMainWindow *window, const gchar *action_name)
{
    GncMainWindowPrivate *priv;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
    g_return_val_if_fail (action_name != nullptr, nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    return gnc_find_toolbar_item (priv->toolbar, action_name);
}

GtkWidget *
gnc_main_window_menu_find_menu_item (GncMainWindow *window, const gchar *action_name)
{
    GncMainWindowPrivate *priv;
    GtkWidget *menu_item;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
    g_return_val_if_fail (action_name != nullptr, nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    menu_item = GTK_WIDGET(g_hash_table_lookup (priv->display_item_hash, action_name));

    if (!menu_item)
    {
        menu_item = gnc_menubar_model_find_menu_item (priv->menubar_model, priv->menubar, action_name);

        g_hash_table_insert (priv->display_item_hash, g_strdup (action_name), menu_item);
    }
    return menu_item;
}


void
gnc_main_window_menu_add_accelerator_keys (GncMainWindow *window)
{
    GncMainWindowPrivate *priv;

    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    gnc_add_accelerator_keys_for_menu (priv->menubar, priv->menubar_model, priv->accel_group);
}


gboolean
gnc_main_window_update_menu_for_action (GncMainWindow *window,
                                        const gchar *action_name,
                                        const gchar *label,
                                        const gchar *tooltip)
{
    GncMainWindowPrivate *priv;
    gboolean found = false;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), false);
    g_return_val_if_fail (action_name != nullptr, false);
    g_return_val_if_fail (label != nullptr, false);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    found =  gnc_menubar_model_update_item (priv->menubar_model, action_name,
                                            nullptr, _(label), nullptr, _(tooltip));

    // add tooltip redirect call backs
    gnc_plugin_add_menu_tooltip_callbacks (priv->menubar,
                                           priv->menubar_model,
                                           priv->statusbar);

    return found;
}

void
gnc_main_window_set_vis_of_items_by_action (GncMainWindow *window,
                                            const gchar **action_names,
                                            gboolean vis)
{
    GncMainWindowPrivate *priv;

    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    for (gint i = 0; action_names[i]; i++)
    {
        GtkWidget *tool_item = gnc_find_toolbar_item (priv->toolbar, action_names[i]);
        GtkWidget *menu_item = gnc_main_window_menu_find_menu_item (window, action_names[i]);

        if (menu_item)
        {
            PINFO("Found menu_item %p with action name '%s', seting vis to '%s'",
                    menu_item, action_names[i], vis ? "true" : "false");
            gtk_widget_set_visible (menu_item, vis);
        }
        else
            PINFO("Did not find menu_item with action name '%s' to set vis '%s'",
                   action_names[i], vis ? "true" : "false");

        if (tool_item)
        {
            PINFO("Found tool_item %p with action name '%s', seting vis to '%s'",
                    tool_item, action_names[i], vis ? "true" : "false");
            gtk_widget_set_visible (tool_item, vis);
        }
        else
             PINFO("Did not find tool_item with action name '%s' to set vis '%s'",
                    action_names[i], vis ? "true" : "false");
    }
}


void
gnc_main_window_init_short_names (GncMainWindow *window,
                                  GncToolBarShortNames *toolbar_labels)
{
    GncMainWindowPrivate *priv;

    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
    g_return_if_fail (toolbar_labels != nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    gnc_plugin_init_short_names (priv->toolbar, toolbar_labels);
}


static void
gnc_main_window_update_toolbar (GncMainWindow *window, GncPluginPage *page,
                                const gchar *toolbar_qualifier)
{
    GncMainWindowPrivate *priv;
    GtkBuilder *builder;
    GAction *action;

    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    builder = gnc_plugin_page_get_builder (page);

    if (builder)
    {
        gchar *toolbar_name;
        gtk_container_remove (GTK_CONTAINER(priv->menu_dock), priv->toolbar);

        if (toolbar_qualifier)
            toolbar_name = g_strconcat ("mainwin-toolbar-", toolbar_qualifier, nullptr);
        else
            toolbar_name = g_strdup ("mainwin-toolbar");

        priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, toolbar_name);

        if (!priv->toolbar)
            priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "mainwin-toolbar");

        g_object_set (priv->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
        gtk_container_add (GTK_CONTAINER(priv->menu_dock), priv->toolbar);
        g_free (toolbar_name);
    }

    action = gnc_main_window_find_action (window, "ViewToolbarAction");

    // set visibility of toolbar
    if (action)
    {
        GVariant *state = g_action_get_state (G_ACTION(action));
        gtk_widget_set_visible (priv->toolbar, g_variant_get_boolean (state));
        g_variant_unref (state);
    }
    // add tooltip redirect call backs
    gnc_plugin_add_toolbar_tooltip_callbacks (priv->toolbar, priv->statusbar);
}


void
gnc_main_window_update_menu_and_toolbar (GncMainWindow *window,
                                         GncPluginPage *page,
                                         const gchar **ui_updates)
{
    GncMainWindowPrivate *priv;
    const gchar *plugin_page_actions_group_name;
    GtkBuilder *builder;
    const gchar *menu_qualifier;

    GMenuModel *menu_model_part;
#ifdef MAC_INTEGRATION
    auto theApp{static_cast<GtkosxApplication *>(g_object_new(GTKOSX_TYPE_APPLICATION, nullptr))};
#endif
    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
    g_return_if_fail (page != nullptr);
    g_return_if_fail (ui_updates != nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    builder = gnc_plugin_page_get_builder (page);

    if (!builder)
        return;

    menu_qualifier = gnc_plugin_page_get_menu_qualifier (page);

    plugin_page_actions_group_name = gnc_plugin_page_get_simple_action_group_name (page);

    if (!plugin_page_actions_group_name)
        return;

    gtk_widget_insert_action_group (GTK_WIDGET(window), gnc_plugin_page_get_simple_action_group_name (page),
                                    G_ACTION_GROUP(gnc_plugin_page_get_action_group (page)));

    if ((g_strcmp0 (priv->previous_plugin_page_name,
                    plugin_page_actions_group_name) == 0) &&
        (g_strcmp0 (priv->previous_menu_qualifier,
                    menu_qualifier) == 0))
        return;

    priv->previous_plugin_page_name = plugin_page_actions_group_name;
    priv->previous_menu_qualifier = menu_qualifier;

    gnc_main_window_update_toolbar (window, page, menu_qualifier);

    // reset hash table and remove added menu items
    g_hash_table_remove_all (priv->display_item_hash);
    gnc_menubar_model_remove_items_with_attrib (priv->menubar_model,
                                                GNC_MENU_ATTRIBUTE_TEMPORARY);

    GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);
    for (gint i = 0; ui_updates[i]; i++)
    {
        gchar *menu_name;

        if (menu_qualifier)
            menu_name = g_strconcat (ui_updates[i], "-", menu_qualifier, nullptr);
        else
            menu_name = g_strdup (ui_updates[i]);

        menu_model_part = (GMenuModel *)gtk_builder_get_object (builder, menu_name);

        if (!menu_model_part)
            menu_model_part = (GMenuModel *)gtk_builder_get_object (builder, ui_updates[i]);

        gsm->search_action_label = nullptr;
        gsm->search_action_name = ui_updates[i];
        gsm->search_action_target = nullptr;

        if (gnc_menubar_model_find_item (priv->menubar_model, gsm))
            g_menu_insert_section (G_MENU(gsm->model), gsm->index,
                                   nullptr, G_MENU_MODEL(menu_model_part));
        else
            PERR("Could not find '%s' in menu model", ui_updates[i]);

        g_free (menu_name);
    }

    // add tooltip redirect call backs
    gnc_plugin_add_menu_tooltip_callbacks (priv->menubar, priv->menubar_model, priv->statusbar);

    // need to add the accelerator keys
    gnc_add_accelerator_keys_for_menu (priv->menubar, priv->menubar_model, priv->accel_group);
#ifdef MAC_INTEGRATION
    gtkosx_application_sync_menubar (theApp);
    g_object_unref (theApp);
#endif
    // need to signal menu has been changed
    g_signal_emit_by_name (window, "menu_changed", page);

    g_free (gsm);
}


static void
gnc_main_window_update_tab_position (gpointer prefs, gchar *pref, gpointer user_data)
{
    GncMainWindow *window;
    GtkPositionType position = GTK_POS_TOP;
    gint item = 0;
    GncMainWindowPrivate *priv;
    GAction *action;

    g_return_if_fail (GNC_IS_MAIN_WINDOW(user_data));

    window = GNC_MAIN_WINDOW(user_data);

    ENTER ("window %p", window);

    /* Ignore notification of the preference that is being set to false when
     * the choice of tab position changes. */
    if (pref && !gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, pref))
        return;

    if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM))
    {
        position = GTK_POS_BOTTOM;
        item = 1;
    }
    else if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT))
    {
        position = GTK_POS_LEFT;
        item = 2;
    }
    else if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT))
    {
        position = GTK_POS_RIGHT;
        item = 3;
    }

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    gtk_notebook_set_tab_pos (GTK_NOTEBOOK(priv->notebook), position);

    action = g_action_map_lookup_action (G_ACTION_MAP(window),
                                         "ViewTabPositionAction");

    g_signal_handlers_block_by_func (G_OBJECT(action),
                                     (gpointer)gnc_main_window_cmd_view_tab_position,
                                     window);
    g_action_change_state (G_ACTION(action), g_variant_new_int32 (item));
    g_signal_handlers_unblock_by_func (G_OBJECT(action),
                                       (gpointer)gnc_main_window_cmd_view_tab_position,
                                       window);

    gnc_main_window_update_tab_width (nullptr, (char*)GNC_PREF_TAB_WIDTH, nullptr);

    LEAVE ("");
}

/*
 * Based on code from Epiphany (src/ephy-window.c)
 */
static void
gnc_main_window_update_edit_actions_sensitivity (GncMainWindow *window, gboolean hide)
{
    GncMainWindowPrivate *priv;
    GncPluginPage *page;
    GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window));
    GAction *action;
    gboolean can_copy = false, can_cut = false, can_paste = false;

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    page = priv->current_page;

    if (page && GNC_PLUGIN_PAGE_GET_CLASS(page)->update_edit_menu_actions)
    {
        (GNC_PLUGIN_PAGE_GET_CLASS(page)->update_edit_menu_actions)(page, hide);
        return;
    }

    if (GTK_IS_EDITABLE (widget))
    {
        gboolean has_selection;

        has_selection = gtk_editable_get_selection_bounds
                        (GTK_EDITABLE (widget), nullptr, nullptr);

        can_copy = has_selection;
        can_cut = has_selection;
        can_paste = TRUE;
    }
    else if (GTK_IS_TEXT_VIEW (widget))
    {
        gboolean has_selection;
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
        has_selection = gtk_text_buffer_get_selection_bounds
                        (text_buffer, nullptr, nullptr);

        can_copy = has_selection;
        can_cut = has_selection;
        can_paste = TRUE;
    }
    else
    {
#ifdef ORIGINAL_EPIPHANY_CODE
        /* For now we assume all actions are possible */
        can_copy = can_cut = can_paste = true;
#else
        /* If its not a GtkEditable, we don't know what to do
         * with it. */
        can_copy = can_cut = can_paste = false;
#endif
    }
    action = gnc_main_window_find_action (window, "EditCopyAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), can_copy);

    action = gnc_main_window_find_action (window, "EditCutAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), can_cut);

    action = gnc_main_window_find_action (window, "EditPasteAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), can_paste);
}

static void
gnc_main_window_enable_edit_actions_sensitivity (GncMainWindow *window)
{
    GAction *action;

    action = gnc_main_window_find_action (window, "EditCopyAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);

    action = gnc_main_window_find_action (window, "EditCutAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);

    action = gnc_main_window_find_action (window, "EditPasteAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);

}

static void
gnc_main_window_edit_menu_show_cb (GtkWidget *menu,
                                   GncMainWindow *window)
{
    gnc_main_window_update_edit_actions_sensitivity (window, FALSE);
}

static void
gnc_main_window_edit_menu_hide_cb (GtkWidget *menu,
                                   GncMainWindow *window)
{
    gnc_main_window_enable_edit_actions_sensitivity (window);
}

static void
gnc_main_window_init_menu_updaters (GncMainWindow *window)
{
    GtkWidget *edit_menu_item, *edit_menu;

    edit_menu_item = gnc_main_window_menu_find_menu_item (window, "EditAction");

    edit_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM(edit_menu_item));

    g_signal_connect (edit_menu, "show",
                      G_CALLBACK(gnc_main_window_edit_menu_show_cb), window);
    g_signal_connect (edit_menu, "hide",
                      G_CALLBACK(gnc_main_window_edit_menu_hide_cb), window);
}

/* This is used to prevent the tab having focus */
static gboolean
gnc_main_window_page_focus_in (GtkWidget *widget, GdkEvent  *event,
                               gpointer user_data)
{
    auto window{static_cast<GncMainWindow *>(user_data)};
    GncPluginPage *page = gnc_main_window_get_current_page (window);

    g_signal_emit (window, main_window_signals[PAGE_CHANGED], 0, page);
    return FALSE;
}

static GAction *
gnc_main_window_get_redirect (GncMainWindow *window, const gchar *action_name)
{
    GncMainWindowPrivate *priv;
    GAction *action = nullptr;
    const gchar *group_name;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window), nullptr);
    g_return_val_if_fail (action_name != nullptr, nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    group_name = gnc_plugin_page_get_simple_action_group_name (priv->current_page);

    PINFO("action anme is '%s', group_name is '%s'", action_name, group_name);

    if (group_name)
    {
        action = gnc_main_window_find_action_in_group (window, group_name, action_name);

        if (!action)
            action = gnc_plugin_page_get_action (priv->current_page, action_name);
    }

    PINFO("Redirect action is %p for action anme '%s' and group_name '%s'",
           action, action_name, group_name);
    return action;
}

static void
main_window_realize_cb (GtkWidget *widget, gpointer user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    gnc_add_accelerator_keys_for_menu (GTK_WIDGET(priv->menubar), priv->menubar_model, priv->accel_group);

    /* need to signal menu has been changed, this will call the
       business function 'bind_extra_toolbuttons_visibility' */
    g_signal_emit_by_name (window, "menu_changed", nullptr);
}

static void
gnc_main_window_setup_window (GncMainWindow *window)
{
    GncMainWindowPrivate *priv;
    GtkWidget *main_vbox;
    GtkBuilder *builder;
    GncPluginManager *manager;
    GList *plugins;
    GError *error = nullptr;
    GAction *action;

    ENTER(" ");

    /* Catch window manager delete signal */
    g_signal_connect (G_OBJECT (window), "delete-event",
                      G_CALLBACK (gnc_main_window_delete_event), window);

    /* Create widgets and add them to the window */
    main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_set_homogeneous (GTK_BOX (main_vbox), FALSE);
    gtk_widget_show (main_vbox);
    gtk_container_add (GTK_CONTAINER (window), main_vbox);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    priv->menu_dock = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_set_homogeneous (GTK_BOX (priv->menu_dock), FALSE);
    gtk_widget_show (priv->menu_dock);
    gtk_box_pack_start (GTK_BOX (main_vbox), priv->menu_dock,
                        FALSE, TRUE, 0);

    priv->notebook = gtk_notebook_new ();
    g_object_set(G_OBJECT(priv->notebook),
                 "scrollable", TRUE,
                 "enable-popup", TRUE,
                 (char *)nullptr);
    gtk_widget_show (priv->notebook);
    g_signal_connect (G_OBJECT (priv->notebook), "switch-page",
                      G_CALLBACK (gnc_main_window_switch_page), window);
    g_signal_connect (G_OBJECT (priv->notebook), "page-reordered",
                      G_CALLBACK (gnc_main_window_page_reordered), window);
    g_signal_connect (G_OBJECT (priv->notebook), "focus-in-event",
                      G_CALLBACK (gnc_main_window_page_focus_in), window);
    gtk_box_pack_start (GTK_BOX (main_vbox), priv->notebook,
                        TRUE, TRUE, 0);

    priv->statusbar = gtk_statusbar_new ();
    gtk_widget_show (priv->statusbar);
    gtk_box_pack_start (GTK_BOX (main_vbox), priv->statusbar,
                        FALSE, TRUE, 0);

    priv->progressbar = gtk_progress_bar_new ();
    gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR(priv->progressbar), TRUE);
    gtk_progress_bar_set_text(GTK_PROGRESS_BAR(priv->progressbar), " ");
    gtk_widget_show (priv->progressbar);
    gtk_box_pack_start (GTK_BOX (priv->statusbar), priv->progressbar,
                        FALSE, TRUE, 0);
    gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(priv->progressbar),
                                    0.01);

    builder = gtk_builder_new ();
    gtk_builder_set_translation_domain (builder, PROJECT_NAME);
    gtk_builder_add_from_resource (builder, GNUCASH_RESOURCE_PREFIX "/gnc-main-window.ui", &error);

    if (error)
    {
        g_critical ("Failed to load, Error %s", error->message);
        g_error_free (error);
        return;
    }

    g_action_map_add_action_entries (G_ACTION_MAP(window),
                                     gnc_menu_actions,
                                     gnc_menu_n_actions,
                                     window);

    priv->menubar_model = (GMenuModel *)gtk_builder_get_object (builder, "mainwin-menu");
    priv->menubar = gtk_menu_bar_new_from_model (priv->menubar_model);
    gtk_container_add (GTK_CONTAINER(priv->menu_dock), priv->menubar);
    gtk_widget_show (GTK_WIDGET(priv->menubar));

    priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "mainwin-toolbar");
    g_object_set (priv->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
    gtk_container_add (GTK_CONTAINER(priv->menu_dock), GTK_WIDGET(priv->toolbar));
    gtk_widget_show (GTK_WIDGET(priv->toolbar));

    g_object_unref (builder);

    gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
                                    initially_insensitive_actions,
                                    FALSE);
    gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
                                    always_insensitive_actions,
                                    FALSE);

    gnc_main_window_set_vis_of_items_by_action (window, always_hidden_actions,
                                                false);

    gtk_widget_insert_action_group (GTK_WIDGET(window), "mainwin",
                                    G_ACTION_GROUP(window));

    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_TAB_POSITION_TOP,
                           (gpointer)gnc_main_window_update_tab_position,
                           window);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_TAB_POSITION_BOTTOM,
                           (gpointer)gnc_main_window_update_tab_position,
                           window);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_TAB_POSITION_LEFT,
                           (gpointer)gnc_main_window_update_tab_position,
                           window);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_TAB_POSITION_RIGHT,
                           (gpointer)gnc_main_window_update_tab_position,
                           window);
    gnc_main_window_update_tab_position (nullptr, nullptr, window);

    gnc_main_window_init_menu_updaters (window);

    /* Disable the Transaction menu */
    action = gnc_main_window_find_action (window, "TransactionAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), false);
    /* Disable the Schedule menu */
    action = gnc_main_window_find_action (window, "ScheduledAction");
    g_simple_action_set_enabled (G_SIMPLE_ACTION(action), false);

    /* Now update the "eXtensions" menu */
    if (!gnc_prefs_is_extra_enabled())
    {
        action = gnc_main_window_find_action (window, "ExtensionsAction");
        g_simple_action_set_enabled (G_SIMPLE_ACTION(action), false);
    }

    /* GncPluginManager stuff */
    manager = gnc_plugin_manager_get ();
    plugins = gnc_plugin_manager_get_plugins (manager);
    g_list_foreach (plugins, gnc_main_window_add_plugin, window);
    g_list_free (plugins);

    g_signal_connect (G_OBJECT (manager), "plugin-added",
                      G_CALLBACK (gnc_main_window_plugin_added), window);
    g_signal_connect (G_OBJECT (manager), "plugin-removed",
                      G_CALLBACK (gnc_main_window_plugin_removed), window);

    // need to add the accelerator keys this way, mainly for --nofile
    g_signal_connect (G_OBJECT(window), "realize",
                      G_CALLBACK(main_window_realize_cb), window);

    LEAVE(" ");
}

#ifdef MAC_INTEGRATION
/* Event handlers for the shutdown process.  Gnc_quartz_shutdown is
 * connected to NSApplicationWillTerminate, the last chance to do
 * anything before quitting. The problem is that it's launched from a
 * CFRunLoop, not a g_main_loop, and if we call anything that would
 * affect the main_loop we get an assert that we're in a subidiary
 * loop.
 */
static void
gnc_quartz_shutdown (GtkosxApplication *theApp, gpointer data)
{
    /* Do Nothing. It's too late. */
}
/* Should quit responds to NSApplicationBlockTermination; returning TRUE means
 * "don't terminate", FALSE means "do terminate". gnc_main_window_quit() queues
 * a timer that starts an orderly shutdown in 250ms and if we tell macOS it's OK
 * to quit GnuCash gets terminated instead of doing its orderly shutdown,
 * leaving the book locked.
 */
static gboolean
gnc_quartz_should_quit (GtkosxApplication *theApp, GncMainWindow *window)
{
    if (gnc_main_window_all_finish_pending())
        gnc_main_window_quit (window);
    return TRUE;
}
/* Enable GtkMenuItem accelerators */
static gboolean
can_activate_cb(GtkWidget *widget, guint signal_id, gpointer data)
{
    //return gtk_widget_is_sensitive (widget);
    return TRUE;
}

static void
gnc_quartz_set_menu (GncMainWindow* window)
{
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    auto theApp{static_cast<GtkosxApplication *>(g_object_new(GTKOSX_TYPE_APPLICATION, nullptr))};
    GtkWidget       *item = nullptr;
    GClosure *quit_closure;

    gtk_widget_hide (priv->menubar);
    gtk_widget_set_no_show_all (priv->menubar, true);

    gtkosx_application_set_menu_bar (theApp, GTK_MENU_SHELL(priv->menubar));

    // File Quit
    item = gnc_main_window_menu_find_menu_item (window, "FileQuitAction");
    if (item)
        gtk_widget_hide (GTK_WIDGET(item));

    quit_closure = g_cclosure_new (G_CALLBACK (gnc_quartz_should_quit),
                                   window, NULL);
    gtk_accel_group_connect (priv->accel_group, 'q', GDK_META_MASK,
                             GTK_ACCEL_MASK, quit_closure);


    // Help About
    item = gnc_main_window_menu_find_menu_item (window, "HelpAboutAction");
    if (item)
    {
        gtk_widget_hide (item);
        gtkosx_application_insert_app_menu_item (theApp, GTK_WIDGET(item), 0);
    }

    // Edit Preferences
    item = gnc_main_window_menu_find_menu_item (window, "EditPreferencesAction");
    if (item)
    {
        gtk_widget_hide (GTK_WIDGET(item));
        gtkosx_application_insert_app_menu_item (theApp, GTK_WIDGET(item), 2);
    }

    // Help Menu
    item = gnc_main_window_menu_find_menu_item (window, "HelpAction");
    if (item)
        gtkosx_application_set_help_menu (theApp, GTK_MENU_ITEM(item));
    // Windows Menu
    item = gnc_main_window_menu_find_menu_item (window, "WindowsAction");
    if (item)
        gtkosx_application_set_window_menu (theApp, GTK_MENU_ITEM(item));

    g_signal_connect (theApp, "NSApplicationBlockTermination",
                      G_CALLBACK(gnc_quartz_should_quit), window);

    g_signal_connect (priv->menubar, "can-activate-accel",
                      G_CALLBACK (can_activate_cb), nullptr);

    gtkosx_application_set_use_quartz_accelerators (theApp, FALSE);
    g_object_unref (theApp);
}
#endif //MAC_INTEGRATION

/* Callbacks */

static gboolean
gnc_main_window_show_summarybar (GncMainWindow *window, GAction *action)
{
    GVariant *state;
    gboolean visible;

    if (action == nullptr)
        action = g_action_map_lookup_action (G_ACTION_MAP(window),
                                             "ViewSummaryAction");
    if (action == nullptr)
        return TRUE;

    state = g_action_get_state (G_ACTION(action));

    visible = g_variant_get_boolean (state);

    g_variant_unref (state);

    return visible;
}

static void
gnc_main_window_switch_page (GtkNotebook *notebook,
                             gpointer *notebook_page,
                             gint pos,
                             GncMainWindow *window)
{
    GncMainWindowPrivate *priv;
    GtkWidget *child;
    GncPluginPage *page;
    gboolean visible;

    ENTER("Notebook %p, page, %p, index %d, window %p",
          notebook, notebook_page, pos, window);
    g_return_if_fail (GNC_IS_MAIN_WINDOW (window));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    if (priv->current_page != nullptr)
    {
        page = priv->current_page;
        gnc_plugin_page_unselected (page);
    }

    child = gtk_notebook_get_nth_page (notebook, pos);
    if (child)
    {
        page = static_cast<GncPluginPage*>(g_object_get_data (G_OBJECT (child), PLUGIN_PAGE_LABEL));
    }
    else
    {
        page = nullptr;
    }

    priv->current_page = page;

    if (page != nullptr)
    {
        /* Update the user interface (e.g. menus and toolbars */
        gnc_plugin_page_merge_actions (page);
        visible = gnc_main_window_show_summarybar (window, nullptr);
        gnc_plugin_page_show_summarybar (page, visible);

        /* Allow page specific actions */
        gnc_plugin_page_selected (page);
        gnc_window_update_status (GNC_WINDOW(window), page);

        /* Update the page reference info */
        priv->usage_order = g_list_remove (priv->usage_order, page);
        priv->usage_order = g_list_prepend (priv->usage_order, page);
    }

    gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
                                    multiple_page_actions,
                                    g_list_length (priv->installed_pages) > 1);

    gnc_main_window_update_title(window);
#ifndef MAC_INTEGRATION
    gnc_main_window_update_menu_item(window);
#endif
    g_signal_emit (window, main_window_signals[PAGE_CHANGED], 0, page);
    LEAVE(" ");
}

static void
gnc_main_window_page_reordered (GtkNotebook *notebook,
                                GtkWidget *child,
                                guint pos,
                                GncMainWindow *window)
{
    GncMainWindowPrivate *priv;
    GncPluginPage *page;
    GList *old_link;

    ENTER("Notebook %p, child %p, index %d, window %p",
          notebook, child, pos, window);
    g_return_if_fail (GNC_IS_MAIN_WINDOW (window));

    if (!child) return;

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    page = static_cast<GncPluginPage*>(g_object_get_data (G_OBJECT (child), PLUGIN_PAGE_LABEL));
    if (!page) return;

    old_link = g_list_find (priv->installed_pages, page);
    if (!old_link) return;

    priv->installed_pages = g_list_delete_link (priv->installed_pages,
                            old_link);
    priv->installed_pages = g_list_insert (priv->installed_pages,
                                           page, pos);

    LEAVE(" ");
}

static void
gnc_main_window_plugin_added (GncPlugin *manager,
                              GncPlugin *plugin,
                              GncMainWindow *window)
{
    g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
    g_return_if_fail (GNC_IS_PLUGIN (plugin));

    gnc_plugin_add_to_window (plugin, window, window_type);
}

static void
gnc_main_window_plugin_removed (GncPlugin *manager,
                                GncPlugin *plugin,
                                GncMainWindow *window)
{
    g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
    g_return_if_fail (GNC_IS_PLUGIN (plugin));

    gnc_plugin_remove_from_window (plugin, window, window_type);
}


/* Command callbacks */
static void
gnc_main_window_cmd_redirect (GSimpleAction *simple,
                              GVariant      *parameter,
                              gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GAction *redirect_action;

    PINFO("Redirect action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));

    redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));

    if (redirect_action)
    {
        PINFO("Found action %p", redirect_action);
        g_action_activate (redirect_action, nullptr);
        return;
    }
}

static void
gnc_main_window_cmd_page_setup (GSimpleAction *simple,
                                GVariant      *parameter,
                                gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GtkWindow *gtk_window;

    g_return_if_fail(GNC_IS_MAIN_WINDOW(window));

    gtk_window = gnc_window_get_gtk_window(GNC_WINDOW(window));
    gnc_ui_page_setup(gtk_window);
}

gboolean
gnc_book_options_dialog_apply_helper(GncOptionDB * options)
{
    QofBook *book = gnc_get_current_book ();
    gboolean use_split_action_for_num_before =
        qof_book_use_split_action_for_num_field (book);
    gint use_read_only_threshold_before =
        qof_book_get_num_days_autoreadonly (book);
    gboolean use_split_action_for_num_after;
    gint use_read_only_threshold_after;
    gboolean return_val = FALSE;
    GList *results = nullptr, *iter;

    if (!options) return return_val;

    results = gnc_option_db_commit (options);
    for (iter = results; iter; iter = iter->next)
    {
        GtkWidget *dialog = gtk_message_dialog_new(gnc_ui_get_main_window (nullptr),
                                                   (GtkDialogFlags)0,
                                                   GTK_MESSAGE_ERROR,
                                                   GTK_BUTTONS_OK,
                                                   "%s",
                                                   (char*)iter->data);
        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        g_free (iter->data);
    }
    g_list_free (results);
    qof_book_begin_edit (book);
    qof_book_save_options (book, gnc_option_db_save, options, TRUE);
    use_split_action_for_num_after =
        qof_book_use_split_action_for_num_field (book);

    // mark cached value as invalid so we get new value
    book->cached_num_days_autoreadonly_isvalid = FALSE;
    use_read_only_threshold_after = qof_book_get_num_days_autoreadonly (book);

    if (use_split_action_for_num_before != use_split_action_for_num_after)
    {
        gnc_book_option_num_field_source_change_cb (
                                                use_split_action_for_num_after);
        return_val = TRUE;
    }
    if (use_read_only_threshold_before != use_read_only_threshold_after)
        return_val = TRUE;

    qof_book_commit_edit (book);
    return return_val;
}

static void
gnc_book_options_dialog_apply_cb(GncOptionsDialog * optionwin,
                                 gpointer user_data)
{
    auto options{static_cast<GncOptionDB *>(user_data)};

    if (!options) return;

    if (gnc_book_options_dialog_apply_helper (options))
        gnc_gui_refresh_all ();
}

static void
gnc_book_options_dialog_close_cb(GncOptionsDialog * optionwin,
                                 gpointer user_data)
{
    auto options{static_cast<GncOptionDB *>(user_data)};

    delete optionwin;
    gnc_option_db_destroy(options);
}

void
gnc_book_option_num_field_source_change_cb (gboolean num_action)
{
    gnc_suspend_gui_refresh ();
    if (num_action)
    {
        /* Set a feature flag in the book for use of the split action field as number.
         * This will prevent older GnuCash versions that don't support this feature
         * from opening this file. */
        gnc_features_set_used (gnc_get_current_book(),
                               GNC_FEATURE_NUM_FIELD_SOURCE);
    }
    gnc_book_option_num_field_source_change (num_action);
    gnc_resume_gui_refresh ();
}

static gboolean
show_handler (const char *class_name, gint component_id,
              gpointer user_data, gpointer iter_data)
{
    auto optwin{static_cast<GncOptionsDialog*>(user_data)};

    if (!optwin)
        return(FALSE);

    auto widget = optwin->get_widget();
    gtk_window_present(GTK_WINDOW(widget));
    return(TRUE);
}

GtkWidget *
gnc_book_options_dialog_cb (gboolean modal, gchar *title, GtkWindow* parent)
{
    auto book = gnc_get_current_book ();

    auto options = gnc_option_db_new();
    gnc_option_db_book_options(options);
    qof_book_load_options (book, gnc_option_db_load, options);
    gnc_option_db_clean (options);

    /* Only allow one Book Options dialog if called from file->properties
       menu */
    if (gnc_forall_gui_components(DIALOG_BOOK_OPTIONS_CM_CLASS,
                                  show_handler, nullptr))
    {
        return nullptr;
    }
    auto optionwin = new GncOptionsDialog (modal,
                                           (title ? title : _( "Book Options")),
                                           DIALOG_BOOK_OPTIONS_CM_CLASS, parent);
    optionwin->build_contents(options);
    optionwin->set_book_help_cb();
    optionwin->set_apply_cb(gnc_book_options_dialog_apply_cb,
                            (gpointer)options);
    optionwin->set_close_cb ( gnc_book_options_dialog_close_cb,
                              (gpointer)options);
    if (modal)
        gnc_options_dialog_set_new_book_option_values (options);
    return optionwin->get_widget();
}

static void
gnc_main_window_cmd_file_properties (GSimpleAction *simple,
                                     GVariant      *parameter,
                                     gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    gnc_book_options_dialog_cb (FALSE, nullptr, GTK_WINDOW (window));
}

static void
gnc_main_window_cmd_file_close (GSimpleAction *simple,
                                GVariant      *parameter,
                                gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv;
    GncPluginPage *page;

    g_return_if_fail(GNC_IS_MAIN_WINDOW(window));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    page = priv->current_page;
    gnc_main_window_close_page(page);
}

static void
gnc_main_window_cmd_file_quit (GSimpleAction *simple,
                               GVariant      *parameter,
                               gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    if (!gnc_main_window_all_finish_pending())
        return;

    gnc_main_window_quit(window);
}

static void
gnc_main_window_cmd_edit_cut (GSimpleAction *simple,
                              GVariant      *parameter,
                              gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
    GAction *redirect_action;

    PINFO("Copy action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));

    redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));

    if (redirect_action)
    {
        PINFO("Found action %p", redirect_action);
        g_action_activate (redirect_action, nullptr);
        return;
    }

    if (GTK_IS_EDITABLE(widget))
    {
        gtk_editable_cut_clipboard (GTK_EDITABLE(widget));
    }
    else if (GTK_IS_TEXT_VIEW(widget))
    {
        GtkTextBuffer *text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
        GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET(widget),
                                                            GDK_SELECTION_CLIPBOARD);
        gboolean editable = gtk_text_view_get_editable (GTK_TEXT_VIEW(widget));

        if (clipboard)
            gtk_text_buffer_cut_clipboard (text_buffer, clipboard, editable);
    }
}

static void
gnc_main_window_cmd_edit_copy (GSimpleAction *simple,
                               GVariant      *parameter,
                               gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
    GAction *redirect_action;

    PINFO("Copy action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));

    redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));

    if (redirect_action)
    {
        PINFO("Found action %p", redirect_action);
        g_action_activate (redirect_action, nullptr);
        return;
    }

    if (GTK_IS_EDITABLE(widget))
    {
        gtk_editable_copy_clipboard (GTK_EDITABLE(widget));
    }
    else if (GTK_IS_TEXT_VIEW(widget))
    {
        GtkTextBuffer *text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
        GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET(widget),
                                                            GDK_SELECTION_CLIPBOARD);
        if (clipboard)
            gtk_text_buffer_copy_clipboard (text_buffer, clipboard);
    }
}

static void
gnc_main_window_cmd_edit_paste (GSimpleAction *simple,
                                GVariant      *parameter,
                                gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
    GAction *redirect_action;

    PINFO("Paste action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));

    redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));

    if (redirect_action)
    {
        PINFO("Found action %p", redirect_action);
        g_action_activate (redirect_action, nullptr);
        return;
    }

    if (GTK_IS_EDITABLE(widget))
    {
        gtk_editable_paste_clipboard (GTK_EDITABLE(widget));
    }
    else if (GTK_IS_TEXT_VIEW(widget))
    {
        auto clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_CLIPBOARD);

        if (clipboard)
        {
            auto text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
            auto editable = gtk_text_view_get_editable (GTK_TEXT_VIEW(widget));
            gtk_text_buffer_paste_clipboard (text_buffer, clipboard, nullptr,
                                             editable);
        }
    }
}

static void
gnc_main_window_cmd_edit_preferences (GSimpleAction *simple,
                                      GVariant      *parameter,
                                      gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    gnc_preferences_dialog (GTK_WINDOW(window));
}

static void
gnc_main_window_cmd_view_refresh (GSimpleAction *simple,
                                  GVariant      *parameter,
                                  gpointer       user_data)
{
}

static void
gnc_main_window_cmd_actions_reset_warnings (GSimpleAction *simple,
                                            GVariant      *parameter,
                                            gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    gnc_reset_warnings_dialog(GTK_WINDOW(window));
}

static void
gnc_main_window_cmd_actions_rename_page (GSimpleAction *simple,
                                         GVariant      *parameter,
                                         gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv;
    GncPluginPage *page;
    GtkWidget *label, *entry;

    ENTER(" ");
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    page = priv->current_page;
    if (!page)
    {
        LEAVE("No current page");
        return;
    }

    if (!main_window_find_tab_items(window, page, &label, &entry))
    {
        LEAVE("can't find required widgets");
        return;
    }

    gtk_entry_set_text(GTK_ENTRY(entry), gtk_label_get_text(GTK_LABEL(label)));
    gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
    gtk_widget_hide(label);
    gtk_widget_show(entry);
    gtk_widget_grab_focus(entry);
    LEAVE("opened for editing");
}

static void
gnc_main_window_cmd_view_toolbar (GSimpleAction *simple,
                                  GVariant      *parameter,
                                  gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    GVariant *state = g_action_get_state (G_ACTION(simple));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    g_action_change_state (G_ACTION(simple), g_variant_new_boolean (!g_variant_get_boolean (state)));

    if (!g_variant_get_boolean (state))
        gtk_widget_show (priv->toolbar);
    else
        gtk_widget_hide (priv->toolbar);

    g_variant_unref (state);
}

static void
gnc_main_window_cmd_view_summary (GSimpleAction *simple,
                                  GVariant      *parameter,
                                  gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    GList *item;
    gboolean visible;

    visible = gnc_main_window_show_summarybar (window, G_ACTION(simple));

    g_action_change_state (G_ACTION(simple), g_variant_new_boolean (!visible));

    for (item = priv->installed_pages; item; item = g_list_next (item))
    {
        gnc_plugin_page_show_summarybar (static_cast<GncPluginPage*>(item->data),
                                         !visible);
    }
}

static void
gnc_main_window_cmd_view_statusbar (GSimpleAction *simple,
                                    GVariant      *parameter,
                                    gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    GVariant *state = g_action_get_state (G_ACTION(simple));

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    g_action_change_state (G_ACTION(simple), g_variant_new_boolean (!g_variant_get_boolean (state)));

    if (!g_variant_get_boolean (state))
        gtk_widget_show (priv->statusbar);
    else
        gtk_widget_hide (priv->statusbar);

    g_variant_unref (state);
}

static void
gnc_main_window_cmd_window_new (GSimpleAction *simple,
                                GVariant      *paramter,
                                gpointer       user_data)
{
    GncMainWindow *new_window;

    /* Create the new window */
    ENTER(" ");
    new_window = gnc_main_window_new ();
    gtk_widget_show(GTK_WIDGET(new_window));
    LEAVE(" ");
}

static void
gnc_main_window_cmd_window_move_page (GSimpleAction *simple,
                                      GVariant      *paramter,
                                      gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindowPrivate *priv;
    GncMainWindow *new_window;
    GncPluginPage *page;
    GtkNotebook *notebook;
    GtkWidget *tab_widget, *menu_widget;

    ENTER("action %p, window %p", simple, window);

    /* Setup */
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    page = priv->current_page;
    if (!page)
    {
        LEAVE("invalid page");
        return;
    }
    if (!page->notebook_page)
    {
        LEAVE("invalid notebook_page");
        return;
    }

#ifndef MAC_INTEGRATION
    if (gnc_list_length_cmp (active_windows, gnc_main_window_max_number) == 0)
        gnc_info_dialog (GTK_WINDOW(window), "%s",
            _("The maximum number of window menu entries reached, no more entries will be added."));
#endif /* !MAC_INTEGRATION */

    notebook = GTK_NOTEBOOK (priv->notebook);
    tab_widget = gtk_notebook_get_tab_label (notebook, page->notebook_page);
    menu_widget = gtk_notebook_get_menu_label (notebook, page->notebook_page);

    // Remove the page_changed signal callback
    gnc_plugin_page_disconnect_page_changed (GNC_PLUGIN_PAGE(page));

    /* Ref the page components, then remove it from its old window */
    g_object_ref(page);
    g_object_ref(tab_widget);
    g_object_ref(menu_widget);
    g_object_ref(page->notebook_page);
    gnc_main_window_disconnect(window, page);

    /* Create the new window */
    new_window = gnc_main_window_new ();
    gtk_widget_show(GTK_WIDGET(new_window));

    /* Now add the page to the new window */
    gnc_main_window_connect (new_window, page, tab_widget, menu_widget);

    /* Unref the page components now that we're done */
    g_object_unref(page->notebook_page);
    g_object_unref(menu_widget);
    g_object_unref(tab_widget);
    g_object_unref(page);

    /* just a little debugging. :-) */
    DEBUG("Moved page %p from window %p to new window %p",
          page, window, new_window);
    DEBUG("Old window current is %p, new window current is %p",
          priv->current_page, priv->current_page);

    LEAVE("page moved");
}

static void
gnc_main_window_cmd_view_tab_position (GSimpleAction *simple,
                                       GVariant      *parameter,
                                       gpointer       user_data)
{
    gint item = g_variant_get_int32 (parameter);

    g_action_change_state (G_ACTION(simple), parameter);

    if (item < 0 || item > 3)
        return;

    if (item != 0 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_TOP))
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_TOP, FALSE);

    if (item != 1 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM))
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM, FALSE);

    if (item != 2 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT))
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT, FALSE);

    if (item != 3 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT))
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT, FALSE);

    switch (item)
    {
    case 0:
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_TOP, TRUE);
        break;

    case 1:
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM, TRUE);
        break;

    case 2:
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT, TRUE);
        break;

    case 3:
        gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT, TRUE);
        break;
    }

}

#ifndef MAC_INTEGRATION
static void
gnc_main_window_cmd_window_raise (GSimpleAction *simple,
                                  GVariant      *parameter,
                                  gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    GncMainWindow *new_window;
    gint item;

    g_return_if_fail (G_IS_SIMPLE_ACTION(simple));
    g_return_if_fail (GNC_IS_MAIN_WINDOW(window));

    item = g_variant_get_int32 (parameter);

    ENTER("action %p, window %p, item %d", simple, window, item);

    g_action_change_state (G_ACTION(simple), parameter);

    new_window = static_cast<GncMainWindow*>(g_list_nth_data (active_windows, item));
    gtk_window_present (GTK_WINDOW(new_window));

    /* revert the change in the radio group
     * impossible while handling "changed" (G_SIGNAL_NO_RECURSE) */
    g_idle_add ((GSourceFunc)gnc_main_window_update_radio_button, window);
    LEAVE(" ");
}
#endif /* !MAC_INTEGRATION */

static void
gnc_main_window_cmd_help_tutorial (GSimpleAction *simple,
                                   GVariant      *paramter,
                                   gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    gnc_gnome_help (GTK_WINDOW(window), DF_GUIDE, NULL);
}

static void
gnc_main_window_cmd_help_contents (GSimpleAction *simple,
                                   GVariant      *paramter,
                                   gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    gnc_gnome_help (GTK_WINDOW(window), DF_MANUAL, NULL);
}

static gchar *
get_file (const gchar *partial)
{
    gchar *filename, *text = nullptr;
    gsize length;

    filename = gnc_filepath_locate_doc_file(partial);
    if (filename && g_file_get_contents(filename, &text, &length, nullptr))
    {
        if (length)
        {
            g_free(filename);
            return text;
        }
        g_free(text);
    }
    g_free (filename);
    return nullptr;
}


static gchar **
get_file_strsplit (const gchar *partial)
{
    gchar *text, **lines;

    text = get_file(partial);
    if (!text)
        return nullptr;

    lines = g_strsplit_set(text, "\r\n", -1);
    g_free(text);
    return lines;
}
static gboolean
url_signal_cb (GtkAboutDialog *dialog, gchar *uri, gpointer data)
{
    gnc_launch_doclink (GTK_WINDOW(dialog), uri);
    return TRUE;
}

static gboolean
link_button_cb (GtkLinkButton *button, gpointer user_data)
{
   const gchar *uri = gtk_link_button_get_uri (button);
   gchar *escaped_uri = g_uri_escape_string (uri, ":/.\\", true);
   gnc_launch_doclink (GTK_WINDOW(user_data), escaped_uri);
   g_free (escaped_uri);
   return TRUE;
}

static void
add_about_paths (GtkDialog *dialog)
{
    GtkWidget *page_vbox = gnc_get_dialog_widget_from_id (dialog, "page_vbox");
    GtkWidget *grid;
    gint i = 0;

    if (!page_vbox)
    {
        PWARN("Unable to find AboutDialog 'page_vbox' Widget");
        return;
    }

    grid = gtk_grid_new ();

    for (const auto& ep : gnc_list_all_paths ())
    {
        gchar *env_name = g_strconcat (ep.env_name, ":", NULL);
        GtkWidget *label = gtk_label_new (env_name);
        const gchar *uri = gnc_uri_create_uri ("file", NULL, 0, NULL, NULL, ep.env_path);
        gchar *display_uri = gnc_doclink_get_unescaped_just_uri (uri);
        GtkWidget *widget = gtk_link_button_new_with_label (uri, display_uri);

        gtk_grid_attach (GTK_GRID(grid), label, 0, i, 1, 1);
        gtk_widget_set_halign (label, GTK_ALIGN_END);
        gtk_grid_attach (GTK_GRID(grid), widget, 1, i, 1, 1);
        gtk_widget_set_halign (widget, GTK_ALIGN_START);
        gtk_widget_set_margin_top (widget, 0);
        gtk_widget_set_margin_bottom (widget, 0);

        if (ep.modifiable)
        {
            GtkWidget *mod_lab = gtk_label_new (_("(user modifiable)"));
            gtk_grid_attach (GTK_GRID(grid), mod_lab, 2, i, 1, 1);
            gtk_widget_show (mod_lab);
        }
        g_signal_connect (widget, "activate-link",
                          G_CALLBACK(link_button_cb), dialog);
        i++;

        g_free (display_uri);
        g_free (env_name);
    }
    gtk_container_add_with_properties (GTK_CONTAINER(page_vbox), grid,
                                       "position", 1, NULL);
    gtk_widget_show_all (grid);
}

static void
gnc_main_window_cmd_help_about (GSimpleAction *simple,
                                GVariant      *paramter,
                                gpointer       user_data)
{
    GncMainWindow *window = (GncMainWindow*)user_data;
    /* Translators: %s will be replaced with the current year */
    gchar *copyright = g_strdup_printf(_("Copyright © 1997-%s The GnuCash contributors."),
                                       GNC_VCS_REV_YEAR);
    gchar **authors = get_file_strsplit("AUTHORS");
    gchar **documenters = get_file_strsplit("DOCUMENTERS");
    gchar *license = get_file("LICENSE");
    GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
    GdkPixbuf *logo = gtk_icon_theme_load_icon (icon_theme,
                                                GNC_ICON_APP,
                                                128,
                                                GTK_ICON_LOOKUP_USE_BUILTIN,
                                                nullptr);
    gchar *version = g_strdup_printf ("%s: %s\n%s: %s\nFinance::Quote: %s",
                                      _("Version"), gnc_version(),
                                      _("Build ID"), gnc_build_id(),
                                      gnc_quote_source_fq_version ()
                                      ? gnc_quote_source_fq_version ()
                                      : "-");
    GtkDialog *dialog = GTK_DIALOG (gtk_about_dialog_new ());
    g_object_set (G_OBJECT (dialog),
                  "authors", authors,
                  "documenters", documenters,
                  "comments", _("Accounting for personal and small business finance."),
                  "copyright", copyright,
                  "license", license,
                  "logo", logo,
                  "name", "GnuCash",
                  /* Translators: the following string will be shown in Help->About->Credits
                     Enter your name or that of your team and an email contact for feedback.
                     The string can have multiple rows, so you can also add a list of
                     contributors. */
                  "translator-credits", _("translator-credits"),
                  "version", version,
                  "website", PACKAGE_URL,
                  "website-label", _("Visit the GnuCash website."),
                  nullptr);

    g_free(version);
    g_free(copyright);
    if (license)
        g_free(license);
    if (documenters)
        g_strfreev(documenters);
    if (authors)
        g_strfreev(authors);
    g_object_unref (logo);
    g_signal_connect (dialog, "activate-link",
                      G_CALLBACK (url_signal_cb), nullptr);

    // Add environment paths
    add_about_paths (dialog);

    /* Set dialog to resize. */
    gtk_window_set_resizable(GTK_WINDOW (dialog), TRUE);

    gtk_window_set_transient_for (GTK_WINDOW (dialog),
                                  GTK_WINDOW (window));
    gtk_dialog_run (dialog);
    gtk_widget_destroy (GTK_WIDGET (dialog));
}


/************************************************************
 *                                                          *
 ************************************************************/

void
gnc_main_window_show_all_windows(void)
{
    GList *window_iter;
#ifdef MAC_INTEGRATION
    auto theApp{static_cast<GtkosxApplication *>(g_object_new(GTKOSX_TYPE_APPLICATION, nullptr))};
#endif
    for (window_iter = active_windows; window_iter != nullptr; window_iter = window_iter->next)
    {
        gtk_widget_show(GTK_WIDGET(window_iter->data));
    }
#ifdef MAC_INTEGRATION
    g_signal_connect(theApp, "NSApplicationWillTerminate",
                     G_CALLBACK(gnc_quartz_shutdown), nullptr);
    gtkosx_application_ready(theApp);
    g_object_unref (theApp);
#endif
}

GtkWindow *
gnc_ui_get_gtk_window (GtkWidget *widget)
{
    GtkWidget *toplevel;

    if (!widget)
        return nullptr;

    toplevel = gtk_widget_get_toplevel (widget);
    if (toplevel && GTK_IS_WINDOW (toplevel))
        return GTK_WINDOW (toplevel);
    else
        return nullptr;
}

GtkWindow *
gnc_ui_get_main_window (GtkWidget *widget)
{
    GList *window;

    GtkWindow *toplevel = gnc_ui_get_gtk_window (widget);
    while (toplevel && !GNC_IS_MAIN_WINDOW (toplevel))
        toplevel = gtk_window_get_transient_for(toplevel);

    if (toplevel)
        return toplevel;

    for (window = active_windows; window; window = window->next)
        if (gtk_window_is_active (GTK_WINDOW (window->data)))
            return static_cast<GtkWindow*>(window->data);

    for (window = active_windows; window; window = window->next)
        if (gtk_widget_get_mapped (GTK_WIDGET(window->data)))
            return static_cast<GtkWindow*>(window->data);

    return nullptr;
}


static GtkWindow *
gnc_main_window_get_gtk_window (GncWindow *window)
{
    g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window), nullptr);
    return GTK_WINDOW(window);
}


static GtkWidget *
gnc_main_window_get_statusbar (GncWindow *window_in)
{
    GncMainWindowPrivate *priv;
    GncMainWindow *window;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window_in), nullptr);

    window = GNC_MAIN_WINDOW(window_in);
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    return priv->statusbar;
}


static GtkWidget *
gnc_main_window_get_progressbar (GncWindow *window_in)
{
    GncMainWindowPrivate *priv;
    GncMainWindow *window;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window_in), nullptr);

    window = GNC_MAIN_WINDOW(window_in);
    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
    return priv->progressbar;
}


static GtkWidget *
gnc_main_window_get_menubar (GncWindow *window)
{
    GncMainWindowPrivate *priv;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    return priv->menubar;
}

static GtkWidget *
gnc_main_window_get_toolbar (GncWindow *window)
{
    GncMainWindowPrivate *priv;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    return priv->toolbar;
}

static GMenuModel *
gnc_main_window_get_menubar_model (GncWindow *window)
{
    GncMainWindowPrivate *priv;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    return priv->menubar_model;
}

static GtkAccelGroup *
gnc_main_window_get_accel_group (GncWindow *window)
{
    GncMainWindowPrivate *priv;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    return priv->accel_group;
}

static void
gnc_window_main_window_init (GncWindowInterface *iface)
{
    iface->get_gtk_window      = gnc_main_window_get_gtk_window;
    iface->get_statusbar       = gnc_main_window_get_statusbar;
    iface->get_progressbar     = gnc_main_window_get_progressbar;
    iface->get_menubar         = gnc_main_window_get_menubar;
    iface->get_toolbar         = gnc_main_window_get_toolbar;
    iface->get_menubar_model   = gnc_main_window_get_menubar_model;
    iface->get_accel_group     = gnc_main_window_get_accel_group;
}


/*  Set the window where all progressbar updates should occur.  This
 *  is a wrapper around the gnc_window_set_progressbar_window()
 *  function.
 */
void
gnc_main_window_set_progressbar_window (GncMainWindow *window)
{
    GncWindow *gncwin;
    gncwin = GNC_WINDOW(window);
    gnc_window_set_progressbar_window(gncwin);
}


static void
do_popup_menu (GncPluginPage *page, GdkEventButton *event)
{
    GtkBuilder *builder;
    GMenuModel *menu_model;
    GtkWidget *menu;
    const gchar *menu_qualifier;
    gchar *popup_menu_name;
    GncWindow* gnc_window;
    GtkWidget *statusbar;

    g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));

    ENTER("page %p, event %p", page, event);

    gnc_window = GNC_WINDOW(GNC_PLUGIN_PAGE(page)->window);

    statusbar = gnc_window_get_statusbar (gnc_window);

    builder = gnc_plugin_page_get_builder (page);

    menu_qualifier = gnc_plugin_page_get_menu_popup_qualifier (page);

    if (!menu_qualifier)
        menu_qualifier = gnc_plugin_page_get_menu_qualifier (page);

    if (builder == nullptr)
    {
        LEAVE("no builder");
        return;
    }

    if (menu_qualifier)
        popup_menu_name = g_strconcat ("mainwin-popup-", menu_qualifier, nullptr);
    else
        popup_menu_name = g_strdup ("mainwin-popup");

    menu_model = (GMenuModel *)gtk_builder_get_object (builder, popup_menu_name);

    if (!menu_model)
        menu_model = (GMenuModel *)gtk_builder_get_object (builder, "mainwin-popup");

    menu = gtk_menu_new_from_model (menu_model);

    if (!menu)
    {
        LEAVE("no menu");
        return;
    }

    // add tooltip redirect call backs
    gnc_plugin_add_menu_tooltip_callbacks (menu, menu_model, statusbar);

    gtk_menu_attach_to_widget (GTK_MENU(menu), GTK_WIDGET(page->window), nullptr);
    gtk_menu_popup_at_pointer (GTK_MENU(menu), (GdkEvent *) event);

    g_free (popup_menu_name);

    LEAVE(" ");
}


gboolean
gnc_main_window_popup_menu_cb (GtkWidget *widget,
                               GncPluginPage *page)
{
    ENTER("widget %p, page %p", widget, page);
    do_popup_menu(page, nullptr);
    LEAVE(" ");
    return TRUE;
}


/*  Callback function invoked when the user clicks in the content of
 *  any Gnucash window.  If this was a "right-click" then Gnucash will
 *  popup the contextual menu.
 */
gboolean
gnc_main_window_button_press_cb (GtkWidget *whatever,
                                 GdkEventButton *event,
                                 GncPluginPage *page)
{
    g_return_val_if_fail(GNC_IS_PLUGIN_PAGE(page), FALSE);

    ENTER("widget %p, event %p, page %p", whatever, event, page);
    /* Ignore double-clicks and triple-clicks */
    if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
    {
        do_popup_menu(page, event);
        LEAVE("menu shown");
        return TRUE;
    }

    LEAVE("other click");
    return FALSE;
}

void
gnc_main_window_all_action_set_sensitive (const gchar *action_name,
                                          gboolean sensitive)
{
    for (auto tmp = active_windows; tmp; tmp = g_list_next(tmp))
    {
        auto action{gnc_main_window_find_action (static_cast<GncMainWindow*>(tmp->data), action_name)};
        g_simple_action_set_enabled (G_SIMPLE_ACTION(action), sensitive);
    }
}

GMenuModel *
gnc_main_window_get_menu_model (GncMainWindow *window)
{
    GncMainWindowPrivate *priv;

    g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);

    priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);

    return priv->menubar_model;
}

gboolean
gnc_main_window_just_plugin_prefs (GncMainWindow* window)
{
    return window->just_plugin_prefs;
}