scaffolding.c

Go to the documentation of this file.

/*
 * Copyright 2019 Vincent Sanders <vince@netsurf-browser.org>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf 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; version 2 of the License.
 *
 * NetSurf 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, see <http://www.gnu.org/licenses/>.
 */
 
#include <gtk/gtk.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
 
#include "utils/utils.h"
#include "utils/log.h"
#include "utils/messages.h"
#include "utils/nsurl.h"
#include "utils/nsoption.h"
#include "netsurf/browser_window.h"
#include "desktop/browser_history.h"
#include "desktop/hotlist.h"
 
#include "gtk/compat.h"
#include "gtk/toolbar_items.h"
#include "gtk/menu.h"
#include "gtk/local_history.h"
#include "gtk/gui.h"
#include "gtk/download.h"
#include "gtk/window.h"
#include "gtk/warn.h"
#include "gtk/tabs.h"
#include "gtk/resources.h"
#include "gtk/scaffolding.h"
 
 
/**
 * menu entry context
 */
struct nsgtk_menu {
        GtkWidget *main; /* main menu entry */
        GtkWidget *burger; /* right click menu */
        GtkWidget *popup; /* popup menu entry */
        /**
         * menu item handler
         */
        gboolean (*mhandler)(GtkMenuItem *widget, gpointer data);
        const char *iconname; /* name of the icon to use */
        bool sensitivity; /* menu item is sensitive */
};
 
/**
 * Core scaffolding structure.
 */
struct nsgtk_scaffolding {
        /** global linked list of scaffolding for gui interface adjustments */
        struct nsgtk_scaffolding *next, *prev;
 
        /** currently active gui browsing context */
        struct gui_window *top_level;
 
        /** Builder object scaffold was created from */
        GtkBuilder *builder;
 
        /** scaffold container window */
        GtkWindow *window;
 
        /** tab widget holding displayed pages */
        GtkNotebook *notebook;
 
        /** handler id for tabs remove callback */
        gulong tabs_remove_handler_id;
 
        /** menu bar hierarchy */
        struct nsgtk_bar_submenu *menu_bar;
 
        /** burger menu hierarchy */
        struct nsgtk_burger_menu *burger_menu;
 
        /** right click popup menu hierarchy */
        struct nsgtk_popup_menu *popup_menu;
 
        /** link popup menu */
        struct nsgtk_link_menu *link_menu;
 
        /** menu entries widgets for sensitivity adjustment */
        struct nsgtk_menu menus[PLACEHOLDER_BUTTON];
};
 
/**
 * current scaffold for model dialogue use
 */
static struct nsgtk_scaffolding *scaf_current;
 
/**
 * global list for interface changes
 */
static struct nsgtk_scaffolding *scaf_list = NULL;
 
/**
 * holds the context data for what's under the pointer, when the
 *  contextual menu is opened.
 */
static struct browser_window_features current_menu_features;
 
 
/**
 * Helper to hide popup menu entries by grouping.
 *
 * \param menu The popup menu to modify.
 * \param nav flag to indicate if navigation entries should be hidden.
 * \param cnp flag to indicate if cut and paste entries should be hidden.
 * \param custom flag to indicate if menu customisation is hidden.
 */
static void
popup_menu_hide(struct nsgtk_popup_menu *menu, bool nav, bool cnp)
{
        if (nav) {
                gtk_widget_hide(GTK_WIDGET(menu->back_menuitem));
                gtk_widget_hide(GTK_WIDGET(menu->forward_menuitem));
                gtk_widget_hide(GTK_WIDGET(menu->stop_menuitem));
                gtk_widget_hide(GTK_WIDGET(menu->reload_menuitem));
 
                gtk_widget_hide(menu->first_separator);
        }
 
        if (cnp) {
                gtk_widget_hide(GTK_WIDGET(menu->cut_menuitem));
                gtk_widget_hide(GTK_WIDGET(menu->copy_menuitem));
                gtk_widget_hide(GTK_WIDGET(menu->paste_menuitem));
 
                gtk_widget_hide(menu->second_separator);
        }
 
 
}
 
 
/**
 * Helper to show popup menu entries by grouping.
 *
 * \param menu The popup menu to modify.
 * \param nav flag to indicate if navigation entries should be visible.
 * \param cnp flag to indicate if cut and paste entries should be visible.
 * \param custom flag to indicate if menu customisation is visible.
 */
static void
popup_menu_show(struct nsgtk_popup_menu *menu, bool nav, bool cnp)
{
        if (nav) {
                gtk_widget_show(GTK_WIDGET(menu->back_menuitem));
                gtk_widget_show(GTK_WIDGET(menu->forward_menuitem));
                gtk_widget_show(GTK_WIDGET(menu->stop_menuitem));
                gtk_widget_show(GTK_WIDGET(menu->reload_menuitem));
 
                gtk_widget_show(menu->first_separator);
        }
 
        if (cnp) {
                gtk_widget_show(GTK_WIDGET(menu->cut_menuitem));
                gtk_widget_show(GTK_WIDGET(menu->copy_menuitem));
                gtk_widget_show(GTK_WIDGET(menu->paste_menuitem));
 
                gtk_widget_show(menu->second_separator);
        }
 
}
 
 
/**
 * resource cleanup function for window destruction.
 *
 * gtk event called when window is being destroyed. Need to free any
 * resources associated with this scaffold,
 *
 * \param widget the widget being destroyed
 * \param data The context pointer passed when the connection was made.
 */
static void scaffolding_window_destroy(GtkWidget *widget, gpointer data)
{
        struct nsgtk_scaffolding *gs = data;
 
        NSLOG(netsurf, INFO, "scaffold:%p", gs);
 
        nsgtk_local_history_hide();
 
        /* ensure scaffolding being destroyed is not current */
        if (scaf_current == gs) {
                scaf_current = NULL;
                /* attempt to select nearest scaffold instead of just selecting the first */
                if (gs->prev != NULL) {
                        scaf_current = gs->prev;
                } else if (gs->next != NULL) {
                        scaf_current = gs->next;
                }
        }
 
        /* remove scaffolding from list */
        if (gs->prev != NULL) {
                gs->prev->next = gs->next;
        } else {
                scaf_list = gs->next;
        }
        if (gs->next != NULL) {
                gs->next->prev = gs->prev;
        }
 
        NSLOG(netsurf, INFO, "scaffold list head: %p", scaf_list);
 
        /* ensure menu resources are freed */
        nsgtk_menu_bar_destroy(gs->menu_bar);
        nsgtk_burger_menu_destroy(gs->burger_menu);
        nsgtk_popup_menu_destroy(gs->popup_menu);
        nsgtk_link_menu_destroy(gs->link_menu);
 
        g_signal_handler_disconnect(gs->notebook, gs->tabs_remove_handler_id);
 
        free(gs);
 
        if (scaf_list == NULL) {
                /* no more open windows - stop the browser */
                nsgtk_complete = true;
        }
}
 
 
/**
 * gtk event callback on window delete event.
 *
 * prevent window close if download is in progress
 *
 * \param widget The widget receiving the delete event
 * \param event The event
 * \param data The context pointer passed when the connection was made.
 * \return TRUE to indicate message handled.
 */
static gboolean
scaffolding_window_delete_event(GtkWidget *widget,
                                GdkEvent *event,
                                gpointer data)
{
        struct nsgtk_scaffolding *g = data;
 
        if (nsgtk_check_for_downloads(GTK_WINDOW(widget)) == false) {
                gtk_widget_destroy(GTK_WIDGET(g->window));
        }
        return TRUE;
}
 
 
/**
 * Update the scaffolding controls
 *
 * The button sensitivity, url bar and local history visibility are updated
 *
 * \param g The scaffolding context to update
 */
static void scaffolding_update_context(struct nsgtk_scaffolding *g)
{
        struct browser_window *bw = nsgtk_get_browser_window(g->top_level);
 
        g->menus[BACK_BUTTON].sensitivity =
                browser_window_history_back_available(bw);
        g->menus[FORWARD_BUTTON].sensitivity =
                browser_window_history_forward_available(bw);
 
        nsgtk_scaffolding_set_sensitivity(g);
 
        nsgtk_local_history_hide();
}
 
 
/**
 * edit the sensitivity of focused widget
 *
 * \todo this needs to update toolbar sensitivity
 *
 * \param g The scaffolding context.
 */
static guint
nsgtk_scaffolding_update_edit_actions_sensitivity(struct nsgtk_scaffolding *g)
{
        GtkWidget *widget = gtk_window_get_focus(g->window);
 
        if (GTK_IS_EDITABLE(widget)) {
                gboolean has_selection;
                has_selection = gtk_editable_get_selection_bounds(
                                        GTK_EDITABLE(widget), NULL, NULL);
                g->menus[COPY_BUTTON].sensitivity = has_selection;
                g->menus[CUT_BUTTON].sensitivity = has_selection;
                g->menus[PASTE_BUTTON].sensitivity = true;
        } else {
                struct browser_window *bw =
                        nsgtk_get_browser_window(g->top_level);
                browser_editor_flags edit_f =
                        browser_window_get_editor_flags(bw);
 
                g->menus[COPY_BUTTON].sensitivity =
                        edit_f & BW_EDITOR_CAN_COPY;
                g->menus[CUT_BUTTON].sensitivity =
                        edit_f & BW_EDITOR_CAN_CUT;
                g->menus[PASTE_BUTTON].sensitivity =
                        edit_f & BW_EDITOR_CAN_PASTE;
        }
 
        nsgtk_scaffolding_set_sensitivity(g);
 
        return ((g->menus[COPY_BUTTON].sensitivity) |
                (g->menus[CUT_BUTTON].sensitivity) |
                (g->menus[PASTE_BUTTON].sensitivity));
}
 
 
/**
 * make edit actions sensitive
 *
 * \todo toolbar sensitivity
 *
 * \param g The scaffolding context.
 */
static void
nsgtk_scaffolding_enable_edit_actions_sensitivity(struct nsgtk_scaffolding *g)
{
        g->menus[PASTE_BUTTON].sensitivity = true;
        g->menus[COPY_BUTTON].sensitivity = true;
        g->menus[CUT_BUTTON].sensitivity = true;
        nsgtk_scaffolding_set_sensitivity(g);
 
        popup_menu_show(g->popup_menu, false, true);
}
 
/* signal handling functions for the toolbar, URL bar, and menu bar */
 
/**
 * gtk event for edit menu being show
 *
 * \param widget The menu widget
 * \param g scaffolding handle
 * \return TRUE to indicate event handled
 */
static gboolean
nsgtk_window_edit_menu_shown(GtkWidget *widget,
                             struct nsgtk_scaffolding *g)
{
        nsgtk_scaffolding_update_edit_actions_sensitivity(g);
 
        return TRUE;
}
 
/**
 * gtk event handler for edit menu being hidden
 *
 * \param widget The menu widget
 * \param g scaffolding handle
 * \return TRUE to indicate event handled
 */
static gboolean
nsgtk_window_edit_menu_hidden(GtkWidget *widget,
                              struct nsgtk_scaffolding *g)
{
        nsgtk_scaffolding_enable_edit_actions_sensitivity(g);
 
        return TRUE;
}
 
 
/**
 * gtk event handler for popup menu being hidden.
 *
 * \param widget The menu widget
 * \param g scaffolding handle
 * \return TRUE to indicate event handled
 */
static gboolean
nsgtk_window_popup_menu_hidden(GtkWidget *widget, struct nsgtk_scaffolding *g)
{
        nsgtk_scaffolding_enable_edit_actions_sensitivity(g);
        return TRUE;
}
 
 
/**
 * Update the menus when the number of tabs changes.
 *
 * \todo toolbar sensitivity
 * \todo next/previous tab ought to only be visible if there is such a tab
 *
 * \param notebook The notebook all the tabs are in
 * \param page The newly added page container widget
 * \param page_num The index of the newly added page
 * \param g The scaffolding context containing the notebook
 */
static void
nsgtk_window_tabs_add(GtkNotebook *notebook,
                      GtkWidget *page,
                      guint page_num,
                      struct nsgtk_scaffolding *g)
{
        gboolean visible = gtk_notebook_get_show_tabs(g->notebook);
        g_object_set(g->menu_bar->view_submenu->tabs_menuitem,
                     "visible",
                     visible,
                     NULL);
        g_object_set(g->burger_menu->view_submenu->tabs_menuitem,
                     "visible",
                     visible,
                     NULL);
 
        g->menus[NEXTTAB_BUTTON].sensitivity = visible;
        g->menus[PREVTAB_BUTTON].sensitivity = visible;
        g->menus[CLOSETAB_BUTTON].sensitivity = visible;
 
        nsgtk_scaffolding_set_sensitivity(g);
}
 
 
/**
 * Update the menus when the number of tabs changes.
 *
 * \todo toolbar sensitivity
 *
 * \param notebook The notebook all the tabs are in
 * \param page The page container widget being removed
 * \param page_num The index of the removed page
 * \param gs The scaffolding context containing the notebook
 */
static void
nsgtk_window_tabs_remove(GtkNotebook *notebook,
                         GtkWidget *page,
                         guint page_num,
                         struct nsgtk_scaffolding *gs)
{
        gboolean visible;
 
        /* if the scaffold is being destroyed it is not useful to
         * update the state, further many of the widgets may have
         * already been destroyed.
         */
        if (gtk_widget_in_destruction(GTK_WIDGET(gs->window)) == TRUE) {
                return;
        }
 
        /* if this is the last tab destroy the scaffold in addition */
        if (gtk_notebook_get_n_pages(notebook) == 1) {
                gtk_widget_destroy(GTK_WIDGET(gs->window));
                return;
        }
 
        visible = gtk_notebook_get_show_tabs(gs->notebook);
        g_object_set(gs->menu_bar->view_submenu->tabs_menuitem,
                     "visible", visible, NULL);
        g_object_set(gs->burger_menu->view_submenu->tabs_menuitem,
                     "visible", visible, NULL);
 
        gs->menus[NEXTTAB_BUTTON].sensitivity = visible;
        gs->menus[PREVTAB_BUTTON].sensitivity = visible;
        gs->menus[CLOSETAB_BUTTON].sensitivity = visible;
 
        nsgtk_scaffolding_set_sensitivity(gs);
}
 
 
/* signal handlers for menu entries */
 
/**
 * handle menu activate signals by calling toolbar item activation
 */
#define TOOLBAR_ITEM_p(identifier, name)                                \
        static gboolean                                                 \
nsgtk_on_##name##_activate_menu(GtkMenuItem *widget, gpointer data)     \
{                                                                       \
        struct nsgtk_scaffolding *gs = (struct nsgtk_scaffolding *)data;\
        nsgtk_window_item_activate(gs->top_level, identifier);          \
        return TRUE;                                                    \
}
#define TOOLBAR_ITEM_y(identifier, name)
#define TOOLBAR_ITEM_n(identifier, name)
#define TOOLBAR_ITEM(identifier, name, sensitivity, clicked, activate, label, iconame) \
        TOOLBAR_ITEM_ ## activate(identifier, name)
#include "gtk/toolbar_items.h"
#undef TOOLBAR_ITEM_y
#undef TOOLBAR_ITEM_n
#undef TOOLBAR_ITEM_p
#undef TOOLBAR_ITEM
 
 
static gboolean
nsgtk_on_savelink_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *) data;
        struct gui_window *gui = g->top_level;
        struct browser_window *bw = nsgtk_get_browser_window(gui);
        nserror err;
 
        if (current_menu_features.link == NULL)
                return FALSE;
 
        err = browser_window_navigate(bw,
                                current_menu_features.link,
                                NULL,
                                BW_NAVIGATE_DOWNLOAD,
                                NULL,
                                NULL,
                                NULL);
        if (err != NSERROR_OK) {
                nsgtk_warning(messages_get_errorcode(err), 0);
        }
 
        return TRUE;
}
 
 
/**
 * Handler for opening new window from a link. attached to the popup menu.
 */
static gboolean
nsgtk_on_link_openwin_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *) data;
        struct gui_window *gui = g->top_level;
        struct browser_window *bw = nsgtk_get_browser_window(gui);
        nserror err;
 
        if (current_menu_features.link == NULL)
                return FALSE;
 
        err = browser_window_create(BW_CREATE_CLONE | BW_CREATE_HISTORY,
                                current_menu_features.link, NULL, bw, NULL);
        if (err != NSERROR_OK) {
                nsgtk_warning(messages_get_errorcode(err), 0);
        }
 
        return TRUE;
}
 
 
/**
 * Handler for opening new tab from a link. attached to the popup menu.
 */
static gboolean
nsgtk_on_link_opentab_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *) data;
        struct gui_window *gui = g->top_level;
        struct browser_window *bw = nsgtk_get_browser_window(gui);
        nserror err;
 
        if (current_menu_features.link == NULL)
                return FALSE;
 
        err = browser_window_create(BW_CREATE_CLONE |
                                    BW_CREATE_HISTORY |
                                    BW_CREATE_TAB,
                                    current_menu_features.link, NULL, bw, NULL);
        if (err != NSERROR_OK) {
                nsgtk_warning(messages_get_errorcode(err), 0);
        }
 
        return TRUE;
}
 
 
/**
 * Handler for bookmarking a link. attached to the popup menu.
 */
static gboolean
nsgtk_on_link_bookmark_activate_menu(GtkMenuItem *widget, gpointer data)
{
        if (current_menu_features.link == NULL)
                return FALSE;
 
        hotlist_add_url(current_menu_features.link);
 
        return TRUE;
}
 
 
/**
 * Handler for copying a link. attached to the popup menu.
 */
static gboolean
nsgtk_on_link_copy_activate_menu(GtkMenuItem *widget, gpointer data)
{
        GtkClipboard *clipboard;
 
        if (current_menu_features.link == NULL)
                return FALSE;
 
        clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
        gtk_clipboard_set_text(clipboard,
                               nsurl_access(current_menu_features.link), -1);
 
        return TRUE;
}
 
 
static gboolean nsgtk_on_find_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *)data;
 
        nsgtk_window_search_toggle(g->top_level);
 
        return TRUE;
}
 
static nserror get_bar_show(bool *menu, bool *tool)
{
        const char *cur_bar_show;
 
        *menu = false;
        *tool = false;
 
        cur_bar_show = nsoption_charp(bar_show);
        if (cur_bar_show != NULL) {
                if (strcmp(cur_bar_show, "menu/tool") == 0) {
                        *menu = true;
                        *tool = true;
                } else if (strcmp(cur_bar_show, "menu") == 0) {
                        *menu = true;
                } else if (strcmp(cur_bar_show, "tool") == 0) {
                        *tool = true;
                }
        }
 
        return NSERROR_OK;
}
 
static nserror set_bar_show(const char *bar, bool show)
{
        bool menu;
        bool tool;
        const char *new_bar_show;
 
        get_bar_show(&menu, &tool);
 
        if (strcmp(bar, "menu") == 0) {
                menu = show;
        } else if (strcmp(bar, "tool") == 0) {
                tool = show;
        }
 
        if ((menu == true) && (tool == true)) {
                new_bar_show = "menu/tool";
        } else if (menu == true) {
                new_bar_show = "menu";
        } else if (tool == true) {
                new_bar_show = "tool";
        } else {
                new_bar_show = "none";
        }
        nsoption_set_charp(bar_show, strdup(new_bar_show));
 
        return NSERROR_OK;
}
 
static gboolean
nsgtk_on_menubar_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *gs = (struct nsgtk_scaffolding *)data;
        GtkCheckMenuItem *bmcmi; /* burger menu check */
        GtkCheckMenuItem *mbcmi; /* menu bar check */
        GtkCheckMenuItem *tbcmi; /* popup menu check */
 
        bmcmi = GTK_CHECK_MENU_ITEM(gs->burger_menu->view_submenu->toolbars_submenu->menubar_menuitem);
        mbcmi = GTK_CHECK_MENU_ITEM(gs->menu_bar->view_submenu->toolbars_submenu->menubar_menuitem);
        tbcmi = GTK_CHECK_MENU_ITEM(gs->popup_menu->toolbars_submenu->menubar_menuitem);
 
        /* ensure menubar and burger menu checkboxes are both updated */
        if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
                if (gtk_check_menu_item_get_active(bmcmi) == FALSE) {
                        gtk_check_menu_item_set_active(bmcmi, TRUE);
                }
 
                if (gtk_check_menu_item_get_active(mbcmi) == FALSE) {
                        gtk_check_menu_item_set_active(mbcmi, TRUE);
                }
 
                if (gtk_check_menu_item_get_active(tbcmi) == FALSE) {
                        gtk_check_menu_item_set_active(tbcmi, TRUE);
                }
 
                gtk_widget_show(GTK_WIDGET(gs->menu_bar->bar_menu));
                set_bar_show("menu", true);
        } else {
                if (gtk_check_menu_item_get_active(bmcmi) == TRUE) {
                        gtk_check_menu_item_set_active(bmcmi, FALSE);
                }
 
                if (gtk_check_menu_item_get_active(mbcmi) == TRUE) {
                        gtk_check_menu_item_set_active(mbcmi, FALSE);
                }
 
                if (gtk_check_menu_item_get_active(tbcmi) == TRUE) {
                        gtk_check_menu_item_set_active(tbcmi, FALSE);
                }
 
                gtk_widget_hide(GTK_WIDGET(gs->menu_bar->bar_menu));
                set_bar_show("menu", false);
        }
        return TRUE;
}
 
 
static gboolean
nsgtk_on_toolbar_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *gs = (struct nsgtk_scaffolding *)data;
        GtkCheckMenuItem *bmcmi; /* burger menu check */
        GtkCheckMenuItem *mbcmi; /* menu bar check */
        GtkCheckMenuItem *tbcmi; /* popup menu check */
 
        bmcmi = GTK_CHECK_MENU_ITEM(gs->burger_menu->view_submenu->toolbars_submenu->toolbar_menuitem);
        mbcmi = GTK_CHECK_MENU_ITEM(gs->menu_bar->view_submenu->toolbars_submenu->toolbar_menuitem);
        tbcmi = GTK_CHECK_MENU_ITEM(gs->popup_menu->toolbars_submenu->toolbar_menuitem);
 
        /* ensure menubar and burger menu checkboxes are both updated */
        if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
                if (gtk_check_menu_item_get_active(bmcmi) == FALSE) {
                        gtk_check_menu_item_set_active(bmcmi, TRUE);
                }
 
                if (gtk_check_menu_item_get_active(mbcmi) == FALSE) {
                        gtk_check_menu_item_set_active(mbcmi, TRUE);
                }
 
                if (gtk_check_menu_item_get_active(tbcmi) == FALSE) {
                        gtk_check_menu_item_set_active(tbcmi, TRUE);
                }
 
                nsgtk_window_toolbar_show(gs, true);
                set_bar_show("tool", true);
        } else {
                if (gtk_check_menu_item_get_active(bmcmi) == TRUE) {
                        gtk_check_menu_item_set_active(bmcmi, FALSE);
                }
 
                if (gtk_check_menu_item_get_active(mbcmi) == TRUE) {
                        gtk_check_menu_item_set_active(mbcmi, FALSE);
                }
 
                if (gtk_check_menu_item_get_active(tbcmi) == TRUE) {
                        gtk_check_menu_item_set_active(tbcmi, FALSE);
                }
 
                nsgtk_window_toolbar_show(gs, false);
                set_bar_show("tool", false);
        }
        return TRUE;
}
 
 
static gboolean
nsgtk_on_nexttab_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *)data;
 
        nsgtk_tab_next(g->notebook);
 
        return TRUE;
}
 
 
static gboolean
nsgtk_on_prevtab_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *)data;
 
        nsgtk_tab_prev(g->notebook);
 
        return TRUE;
}
 
 
/**
 * menu signal handler for activation on close tab item
 */
static gboolean
nsgtk_on_closetab_activate_menu(GtkMenuItem *widget, gpointer data)
{
        struct nsgtk_scaffolding *g = (struct nsgtk_scaffolding *)data;
 
        nsgtk_tab_close_current(g->notebook);
 
        return TRUE;
}
 
/* end of menu callback handlers */
 
/**
 * attach gtk signal handlers for menus
 */
static void nsgtk_menu_connect_signals(struct nsgtk_scaffolding *g)
{
        int idx; /* item index */
        for (idx = BACK_BUTTON; idx < PLACEHOLDER_BUTTON; idx++) {
                if (g->menus[idx].main != NULL) {
                        g_signal_connect(g->menus[idx].main,
                                         "activate",
                                         G_CALLBACK(g->menus[idx].mhandler),
                                         g);
                }
                if (g->menus[idx].burger != NULL) {
                        g_signal_connect(g->menus[idx].burger,
                                         "activate",
                                         G_CALLBACK(g->menus[idx].mhandler),
                                         g);
                }
                if (g->menus[idx].popup != NULL) {
                        g_signal_connect(g->menus[idx].popup,
                                         "activate",
                                        G_CALLBACK(g->menus[idx].mhandler),
                                         g);
                }
        }
}
 
 
/**
 * Create and connect handlers to bar menu.
 *
 * \param gs scaffolding to attach popup menu to.
 * \param group The accelerator group to use for the popup.
 * \param showmenu if the bar menu should be shown
 * \param showtool if the toolabar should be shown
 * \return menu structure on success or NULL on error.
 */
static struct nsgtk_bar_submenu *
create_scaffolding_bar_menu(struct nsgtk_scaffolding *gs,
                            GtkAccelGroup *group,
                            bool showmenu,
                            bool showtool)
{
        GtkMenuShell *menushell;
        struct nsgtk_bar_submenu *nmenu;
 
        menushell = GTK_MENU_SHELL(gtk_builder_get_object(gs->builder,
                                                          "menubar"));
 
        nmenu = nsgtk_menu_bar_create(menushell, group);
        if (nmenu == NULL) {
                return NULL;
        }
 
        /* set menu bar visibility */
        if (showmenu) {
                gtk_widget_show(GTK_WIDGET(nmenu->bar_menu));
        } else {
                gtk_widget_hide(GTK_WIDGET(nmenu->bar_menu));
        }
 
        /* set checks correct way on toolbar submenu */
        gtk_check_menu_item_set_active(nmenu->view_submenu->toolbars_submenu->menubar_menuitem, showmenu);
        gtk_check_menu_item_set_active(nmenu->view_submenu->toolbars_submenu->toolbar_menuitem, showtool);
 
        /* bar menu signal handlers for edit controls */
        g_signal_connect(nmenu->edit_submenu->edit,
                         "show",
                         G_CALLBACK(nsgtk_window_edit_menu_shown),
                         gs);
 
        g_signal_connect(nmenu->edit_submenu->edit,
                         "hide",
                         G_CALLBACK(nsgtk_window_edit_menu_hidden),
                         gs);
 
        /*
         * attach signal handlers for menubar and toolbar visibility toggling
         */
        g_signal_connect(nmenu->view_submenu->toolbars_submenu->menubar_menuitem,
                         "toggled",
                         G_CALLBACK(nsgtk_on_menubar_activate_menu),
                         gs);
 
        g_signal_connect(nmenu->view_submenu->toolbars_submenu->toolbar_menuitem,
                         "toggled",
                         G_CALLBACK(nsgtk_on_toolbar_activate_menu),
                         gs);
 
 
        return nmenu;
}
 
 
/**
 * Create and connect handlers to burger menu.
 *
 * \param g scaffolding to attach popup menu to.
 * \param group The accelerator group to use for the popup.
 * \param showbar if the bar menu should be shown
 * \param showtool if the toolabar should be shown
 * \return menu structure on success or NULL on error.
 */
static struct nsgtk_burger_menu *
create_scaffolding_burger_menu(struct nsgtk_scaffolding *gs,
                               GtkAccelGroup *group,
                               bool showbar,
                               bool showtool)
{
        struct nsgtk_burger_menu *nmenu;
 
        nmenu = nsgtk_burger_menu_create(group);
 
        if (nmenu == NULL) {
                return NULL;
        }
 
        /* set checks correct way on toolbar submenu */
        gtk_check_menu_item_set_active(nmenu->view_submenu->toolbars_submenu->menubar_menuitem, showbar);
        gtk_check_menu_item_set_active(nmenu->view_submenu->toolbars_submenu->toolbar_menuitem, showtool);
 
        g_signal_connect(nmenu->view_submenu->toolbars_submenu->menubar_menuitem,
                         "toggled",
                         G_CALLBACK(nsgtk_on_menubar_activate_menu),
                         gs);
        g_signal_connect(nmenu->view_submenu->toolbars_submenu->toolbar_menuitem,
                         "toggled",
                         G_CALLBACK(nsgtk_on_toolbar_activate_menu),
                         gs);
        return nmenu;
}
 
 
/**
 * Create and connect handlers to popup menu.
 *
 * \param gs scaffolding to attach popup menu to.
 * \param group The accelerator group to use for the popup.
 * \param showbar if the bar menu should be shown
 * \param showtool if the toolabar should be shown
 * \return menu structure on success or NULL on error.
 */
static struct nsgtk_popup_menu *
create_scaffolding_popup_menu(struct nsgtk_scaffolding *gs,
                              GtkAccelGroup *group,
                              bool showbar,
                              bool showtool)
{
        struct nsgtk_popup_menu *nmenu;
 
        nmenu = nsgtk_popup_menu_create(group);
 
        if (nmenu == NULL) {
                return NULL;
        }
        /* set checks correct way on toolbar submenu */
        gtk_check_menu_item_set_active(nmenu->toolbars_submenu->menubar_menuitem, showbar);
        gtk_check_menu_item_set_active(nmenu->toolbars_submenu->toolbar_menuitem, showtool);
 
        g_signal_connect(nmenu->popup_menu,
                         "hide",
                         G_CALLBACK(nsgtk_window_popup_menu_hidden),
                         gs);
 
        g_signal_connect(nmenu->toolbars_submenu->menubar_menuitem,
                         "toggled",
                         G_CALLBACK(nsgtk_on_menubar_activate_menu),
                         gs);
        g_signal_connect(nmenu->toolbars_submenu->toolbar_menuitem,
                         "toggled",
                         G_CALLBACK(nsgtk_on_toolbar_activate_menu),
                         gs);
 
        /* set initial popup menu visibility */
        popup_menu_hide(nmenu, false, false);
 
        return nmenu;
}
 
 
/**
 * Create and connect handlers to link popup menu.
 *
 * \param g scaffolding to attach popup menu to.
 * \param group The accelerator group to use for the popup.
 * \return true on success or false on error.
 */
static struct nsgtk_link_menu *
create_scaffolding_link_menu(struct nsgtk_scaffolding *g, GtkAccelGroup *group)
{
        struct nsgtk_link_menu *nmenu;
 
        nmenu = nsgtk_link_menu_create(group);
 
        if (nmenu == NULL) {
                return NULL;
        }
 
        g_signal_connect(nmenu->save_menuitem,
                         "activate",
                         G_CALLBACK(nsgtk_on_savelink_activate_menu),
                         g);
 
        g_signal_connect(nmenu->opentab_menuitem,
                         "activate",
                         G_CALLBACK(nsgtk_on_link_opentab_activate_menu),
                         g);
 
        g_signal_connect(nmenu->openwin_menuitem,
                         "activate",
                         G_CALLBACK(nsgtk_on_link_openwin_activate_menu),
                         g);
 
        g_signal_connect(nmenu->bookmark_menuitem,
                         "activate",
                         G_CALLBACK(nsgtk_on_link_bookmark_activate_menu),
                         g);
 
        g_signal_connect(nmenu->copy_menuitem,
                         "activate",
                         G_CALLBACK(nsgtk_on_link_copy_activate_menu),
                         g);
 
        return nmenu;
}
 
 
/**
 * initialiase the menu signal handlers ready for connection
 */
static nserror nsgtk_menu_initialise(struct nsgtk_scaffolding *g)
{
#define TOOLBAR_ITEM_p(identifier, name, iconame)                       \
        g->menus[identifier].mhandler = nsgtk_on_##name##_activate_menu; \
        g->menus[identifier].iconname = iconame;
#define TOOLBAR_ITEM_y(identifier, name, iconame)                       \
        g->menus[identifier].mhandler = nsgtk_on_##name##_activate_menu; \
        g->menus[identifier].iconname = iconame;
#define TOOLBAR_ITEM_n(identifier, name, iconame)                       \
        g->menus[identifier].mhandler = NULL;                           \
        g->menus[identifier].iconname = iconame;
#define TOOLBAR_ITEM(identifier, name, snstvty, clicked, activate, label, iconame) \
        g->menus[identifier].sensitivity = snstvty;                     \
        TOOLBAR_ITEM_ ## activate(identifier, name, iconame)
#include "gtk/toolbar_items.h"
#undef TOOLBAR_ITEM_y
#undef TOOLBAR_ITEM_n
#undef TOOLBAR_ITEM
 
        /* items on menubar, burger */
#define ITEM_MB(p, q, r)                                                \
        g->menus[p##_BUTTON].main = g->menu_bar->r##_submenu->q##_menuitem; \
        g->menus[p##_BUTTON].burger = g->burger_menu->r##_submenu->q##_menuitem
 
        /* items on menubar, burger and context popup submenu */
#define ITEM_MBP(p, q, r)                                               \
        g->menus[p##_BUTTON].main = g->menu_bar->r##_submenu->q##_menuitem; \
        g->menus[p##_BUTTON].burger = g->burger_menu->r##_submenu->q##_menuitem; \
        g->menus[p##_BUTTON].popup = g->popup_menu->r##_submenu->q##_menuitem
 
        /* items on menubar, burger and context popup */
#define ITEM_MBp(p, q, r)                                               \
        g->menus[p##_BUTTON].main = g->menu_bar->r##_submenu->q##_menuitem; \
        g->menus[p##_BUTTON].burger = g->burger_menu->r##_submenu->q##_menuitem; \
        g->menus[p##_BUTTON].popup = g->popup_menu->q##_menuitem
 
 
        /* file menu */
        ITEM_MB(NEWWINDOW, newwindow, file);
        ITEM_MB(NEWTAB, newtab, file);
        ITEM_MB(OPENFILE, openfile, file);
        ITEM_MB(CLOSEWINDOW, closewindow, file);
        ITEM_MB(PRINTPREVIEW, printpreview, file);
        ITEM_MB(PRINT, print, file);
        ITEM_MB(QUIT, quit, file);
        /* file - export submenu */
        ITEM_MB(SAVEPAGE, savepage, file_submenu->export);
        ITEM_MB(PLAINTEXT, plaintext, file_submenu->export);
        ITEM_MB(PDF, pdf, file_submenu->export);
 
        /* edit menu */
        ITEM_MBp(CUT, cut, edit);
        ITEM_MBp(COPY, copy, edit);
        ITEM_MBp(PASTE, paste, edit);
        ITEM_MB(DELETE, delete, edit);
        ITEM_MB(SELECTALL, selectall, edit);
        ITEM_MB(FIND, find, edit);
        ITEM_MB(PREFERENCES, preferences, edit);
 
        /* view menu */
        ITEM_MB(FULLSCREEN, fullscreen, view);
        ITEM_MB(SAVEWINDOWSIZE, savewindowsize, view);
        /* view - scale submenu */
        ITEM_MB(ZOOMPLUS, zoomplus, view_submenu->scaleview);
        ITEM_MB(ZOOMMINUS, zoomminus, view_submenu->scaleview);
        ITEM_MB(ZOOMNORMAL, zoomnormal, view_submenu->scaleview);
        /* view - tabs submenu */
        ITEM_MB(NEXTTAB, nexttab, view_submenu->tabs);
        ITEM_MB(PREVTAB, prevtab, view_submenu->tabs);
        ITEM_MB(CLOSETAB, closetab, view_submenu->tabs);
        /* view - toolbars submenu */
        ITEM_MB(CUSTOMIZE, customize, view_submenu->toolbars);
        g->menus[CUSTOMIZE_BUTTON].popup = g->popup_menu->toolbars_submenu->customize_menuitem;
 
        /* navigation menu */
        ITEM_MBp(BACK, back, nav);
        ITEM_MBp(FORWARD, forward, nav);
        ITEM_MBp(STOP, stop, nav);
        ITEM_MBp(RELOAD, reload, nav);
        ITEM_MB(HOME, home, nav);
        ITEM_MB(LOCALHISTORY, localhistory, nav);
        ITEM_MB(GLOBALHISTORY, globalhistory, nav);
        ITEM_MB(ADDBOOKMARKS, addbookmarks, nav);
        ITEM_MB(SHOWBOOKMARKS, showbookmarks, nav);
        ITEM_MB(OPENLOCATION, openlocation, nav);
 
        /* tools menu */
        ITEM_MBP(DOWNLOADS, downloads, tools);
        ITEM_MBP(SHOWCOOKIES, showcookies, tools);
        /* tools > developer submenu */
        ITEM_MBP(VIEWSOURCE, viewsource, tools_submenu->developer);
        ITEM_MBP(TOGGLEDEBUGGING, toggledebugging, tools_submenu->developer);
        ITEM_MBP(SAVEBOXTREE, debugboxtree, tools_submenu->developer);
        ITEM_MBP(SAVEDOMTREE, debugdomtree, tools_submenu->developer);
 
        /* help menu */
        ITEM_MB(CONTENTS, contents, help);
        ITEM_MB(GUIDE, guide, help);
        ITEM_MB(INFO, info, help);
        ITEM_MB(ABOUT, about, help);
 
 
#undef ITEM_MB
#undef ITEM_MBp
#undef ITEM_MBP
 
        return NSERROR_OK;
}
 
 
static void nsgtk_menu_set_sensitivity(struct nsgtk_scaffolding *g)
{
 
        for (int i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++) {
                if (g->menus[i].main != NULL) {
                        gtk_widget_set_sensitive(GTK_WIDGET(
                                        g->menus[i].main),
                                        g->menus[i].sensitivity);
                }
                if (g->menus[i].burger != NULL) {
                        gtk_widget_set_sensitive(GTK_WIDGET(
                                        g->menus[i].burger),
                                        g->menus[i].sensitivity);
                }
                if (g->menus[i].popup != NULL) {
                        gtk_widget_set_sensitive(GTK_WIDGET(
                                        g->menus[i].popup),
                                        g->menus[i].sensitivity);
                }
        }
}
 
 
/* set menu items to have icons */
static void nsgtk_menu_set_icons(struct nsgtk_scaffolding *g)
{
        GtkWidget *img;
        for (int i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++) {
                /* ensure there is an icon name */
                if (g->menus[i].iconname == NULL) {
                        continue;
                }
 
                if (g->menus[i].main != NULL) {
                img = gtk_image_new_from_icon_name(g->menus[i].iconname,
                                                   GTK_ICON_SIZE_MENU);
                        nsgtk_image_menu_item_set_image(GTK_WIDGET(g->menus[i].main), img);
                }
                if (g->menus[i].burger != NULL) {
                img = gtk_image_new_from_icon_name(g->menus[i].iconname,
                                                   GTK_ICON_SIZE_MENU);
                        nsgtk_image_menu_item_set_image(GTK_WIDGET(g->menus[i].burger), img);
                }
                if (g->menus[i].popup != NULL) {
                img = gtk_image_new_from_icon_name(g->menus[i].iconname,
                                                   GTK_ICON_SIZE_MENU);
                        nsgtk_image_menu_item_set_image(GTK_WIDGET(g->menus[i].popup), img);
                }
        }
}
 
 
/**
 * create and initialise menus
 *
 * There are four menus held by the scaffolding:
 *
 *  1. Main menubar menu.
 *     This can be hidden which causes the right click popup context menu
 *       to use the burger menu.
 *  2. Burger menu.
 *     This can be opened from a burger icon on the toolbar.
 *  3. popup context menu.
 *     This is opened by right mouse clicking on the toolbar or browser area
 *  4. link context menu
 *     Opened like the other popup menu when the mouse is over a link in the
 *        browser area
 *
 * The cut, copy, paste, delete and back, forwards, stop, reload groups of
 *   menu entries are context sensitive and must be updated as appropriate
 *   when a menu is opened which contains those groups.
 */
static nserror nsgtk_menus_create(struct nsgtk_scaffolding *gs)
{
        GtkAccelGroup *group;
        bool showmenu; /* show menubar */
        bool showtool; /* show toolbar */
 
        get_bar_show(&showmenu, &showtool);
 
        group = gtk_accel_group_new();
 
        gtk_window_add_accel_group(gs->window, group);
 
        gs->menu_bar = create_scaffolding_bar_menu(gs, group, showmenu, showtool);
        gs->burger_menu = create_scaffolding_burger_menu(gs, group, showmenu, showtool);
        gs->popup_menu = create_scaffolding_popup_menu(gs, group, showmenu, showtool);
        gs->link_menu = create_scaffolding_link_menu(gs, group);
 
        /* set up the menu signal handlers */
        nsgtk_menu_initialise(gs);
        nsgtk_menu_set_icons(gs);
        nsgtk_menu_connect_signals(gs);
        nsgtk_menu_set_sensitivity(gs);
 
        return NSERROR_OK;
}
 
 
/* exported function documented in gtk/scaffolding.h */
void nsgtk_scaffolding_set_title(struct gui_window *gw, const char *title)
{
        struct nsgtk_scaffolding *gs = nsgtk_get_scaffold(gw);
        int title_len;
        char *newtitle;
 
        /* only set window title if top level window */
        if (gs->top_level != gw) {
                return;
        }
 
        if (title == NULL || title[0] == '\0') {
                gtk_window_set_title(gs->window, "NetSurf");
                return;
        }
 
        title_len = strlen(title) + SLEN(" - NetSurf") + 1;
        newtitle = malloc(title_len);
        if (newtitle == NULL) {
                return;
        }
 
        snprintf(newtitle, title_len, "%s - NetSurf", title);
 
        gtk_window_set_title(gs->window, newtitle);
 
        free(newtitle);
 
}
 
 
/* exported interface documented in scaffolding.h */
nserror nsgtk_scaffolding_throbber(struct gui_window* gw, bool active)
{
        struct nsgtk_scaffolding *gs = nsgtk_get_scaffold(gw);
        if (active) {
                gs->menus[STOP_BUTTON].sensitivity = true;
                gs->menus[RELOAD_BUTTON].sensitivity = false;
        } else {
                gs->menus[STOP_BUTTON].sensitivity = false;
                gs->menus[RELOAD_BUTTON].sensitivity = true;
        }
        scaffolding_update_context(gs);
 
        return NSERROR_OK;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
nserror nsgtk_scaffolding_destroy_all(void)
{
        struct nsgtk_scaffolding *gs;
 
        gs = scaf_list;
        assert(gs != NULL);
 
        if (nsgtk_check_for_downloads(gs->window) == true) {
                return NSERROR_INVALID;
        }
 
        /* iterate all scaffolding windows and destroy them */
        while (gs != NULL) {
                struct nsgtk_scaffolding *next = gs->next;
                gtk_widget_destroy(GTK_WIDGET(gs->window));
                gs = next;
        }
        return NSERROR_OK;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
GtkWindow* nsgtk_scaffolding_window(struct nsgtk_scaffolding *g)
{
        return g->window;
}
 
/* exported interface documented in gtk/scaffolding.h */
GtkNotebook* nsgtk_scaffolding_notebook(struct nsgtk_scaffolding *g)
{
        return g->notebook;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
GtkMenuBar *nsgtk_scaffolding_menu_bar(struct nsgtk_scaffolding *gs)
{
        if (gs == NULL) {
                return NULL;
        }
        return gs->menu_bar->bar_menu;
}
 
/* exported interface documented in gtk/scaffolding.h */
struct nsgtk_scaffolding *nsgtk_scaffolding_iterate(struct nsgtk_scaffolding *g)
{
        if (g == NULL) {
                return scaf_list;
        }
        return g->next;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
struct gui_window *nsgtk_scaffolding_top_level(struct nsgtk_scaffolding *g)
{
        return g->top_level;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
void nsgtk_scaffolding_set_top_level(struct gui_window *gw)
{
        struct browser_window *bw;
        struct nsgtk_scaffolding *sc;
 
        assert(gw != NULL);
 
        bw = nsgtk_get_browser_window(gw);
 
        assert(bw != NULL);
 
        sc = nsgtk_get_scaffold(gw);
        assert(sc != NULL);
 
        scaf_current = sc;
 
        sc->top_level = gw;
 
        /* Synchronise the history */
        scaffolding_update_context(sc);
 
        /* Ensure the window's title bar is updated */
        nsgtk_scaffolding_set_title(gw, browser_window_get_title(bw));
}
 
 
/* exported interface documented in scaffolding.h */
void nsgtk_scaffolding_set_sensitivity(struct nsgtk_scaffolding *g)
{
        int i;
#define SENSITIVITY(q)                                                  \
        i = q##_BUTTON;                                                 \
        if (g->menus[i].main != NULL)                                   \
                gtk_widget_set_sensitive(GTK_WIDGET(g->menus[i].main),  \
                                         g->menus[i].sensitivity);      \
        if (g->menus[i].burger != NULL)                                 \
                gtk_widget_set_sensitive(GTK_WIDGET(g->menus[i].burger), \
                                         g->menus[i].sensitivity);      \
        if (g->menus[i].popup != NULL)                                  \
                gtk_widget_set_sensitive(GTK_WIDGET(g->menus[i].popup), \
                                         g->menus[i].sensitivity);
 
        SENSITIVITY(STOP)
        SENSITIVITY(RELOAD)
        SENSITIVITY(CUT)
        SENSITIVITY(COPY)
        SENSITIVITY(PASTE)
        SENSITIVITY(BACK)
        SENSITIVITY(FORWARD)
        SENSITIVITY(NEXTTAB)
        SENSITIVITY(PREVTAB)
        SENSITIVITY(CLOSETAB)
#undef SENSITIVITY
 
}
 
 
/* exported interface documented in gtk/scaffolding.h */
nserror nsgtk_scaffolding_toolbar_context_menu(struct nsgtk_scaffolding *gs)
{
        /* set visibility for right-click popup menu */
        popup_menu_hide(gs->popup_menu, false, true);
 
        nsgtk_menu_popup_at_pointer(gs->popup_menu->popup_menu, NULL);
 
        return NSERROR_OK;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
nserror nsgtk_scaffolding_burger_menu(struct nsgtk_scaffolding *gs)
{
        nsgtk_menu_popup_at_pointer(gs->burger_menu->burger_menu, NULL);
 
        return NSERROR_OK;
}
 
 
/* exported interface documented in gtk/scaffolding.h */
void
nsgtk_scaffolding_context_menu(struct nsgtk_scaffolding *g,
                               gdouble x,
                               gdouble y)
{
        GtkMenu *gtkmenu;
        struct browser_window *bw;
 
        bw = nsgtk_get_browser_window(g->top_level);
 
        /* update the global context menu features */
        browser_window_get_features(bw, x, y, &current_menu_features);
 
        if (current_menu_features.link != NULL) {
                /* menu is opening over a link */
                gtkmenu = g->link_menu->link_menu;
        } else {
                gtkmenu = g->popup_menu->popup_menu;
 
                nsgtk_scaffolding_update_edit_actions_sensitivity(g);
 
                if (!(g->menus[COPY_BUTTON].sensitivity)) {
                        gtk_widget_hide(GTK_WIDGET(g->popup_menu->copy_menuitem));
                } else {
                        gtk_widget_show(GTK_WIDGET(g->popup_menu->copy_menuitem));
                }
 
                if (!(g->menus[CUT_BUTTON].sensitivity)) {
                        gtk_widget_hide(GTK_WIDGET(g->popup_menu->cut_menuitem));
                } else {
                        gtk_widget_show(GTK_WIDGET(g->popup_menu->cut_menuitem));
                }
 
                if (!(g->menus[PASTE_BUTTON].sensitivity)) {
                        gtk_widget_hide(GTK_WIDGET(g->popup_menu->paste_menuitem));
                } else {
                        gtk_widget_show(GTK_WIDGET(g->popup_menu->paste_menuitem));
                }
 
        }
 
        nsgtk_menu_popup_at_pointer(gtkmenu, NULL);
}
 
/* exported interface documented in gtk/scaffolding.h */
struct nsgtk_scaffolding *nsgtk_current_scaffolding(void)
{
        if (scaf_current == NULL) {
                scaf_current = scaf_list;
        }
        return scaf_current;
}
 
/* exported interface documented in gtk/scaffolding.h */
struct nsgtk_scaffolding *nsgtk_scaffolding_from_notebook(GtkNotebook *notebook)
{
        struct nsgtk_scaffolding *gs;
        gs = scaf_list;
        while (gs != NULL) {
                if (gs->notebook == notebook) {
                        break;
                }
                gs = gs->next;
        }
        return gs;
}
 
/* exported interface documented in gtk/scaffolding.h */
struct nsgtk_scaffolding *nsgtk_new_scaffolding(struct gui_window *toplevel)
{
        nserror res;
        struct nsgtk_scaffolding *gs;
 
        gs = calloc(1, sizeof(*gs));
        if (gs == NULL) {
                return NULL;
        }
 
        NSLOG(netsurf, INFO,
              "Constructing a scaffold of %p for gui_window %p", gs, toplevel);
 
        gs->top_level = toplevel;
 
        /* Construct UI widgets */
        if (nsgtk_builder_new_from_resname("netsurf", &gs->builder) != NSERROR_OK) {
                free(gs);
                return NULL;
        }
 
        gtk_builder_connect_signals(gs->builder, NULL);
 
        /* containing window setup */
        gs->window = GTK_WINDOW(gtk_builder_get_object(gs->builder,
                                                       "wndBrowser"));
 
        /**
         * set this window's size and position to what's in the options, or
         *   some sensible default if they are not set yet.
         */
        if (nsoption_int(window_width) > 0) {
                gtk_window_move(gs->window,
                                nsoption_int(window_x),
                                nsoption_int(window_y));
                gtk_window_resize(gs->window,
                                  nsoption_int(window_width),
                                  nsoption_int(window_height));
        } else {
                /* Set to 1000x700, so we're very likely to fit even on
                 * 1024x768 displays, not being able to take into account
                 * window furniture or panels.
                 */
                gtk_window_set_default_size(gs->window, 1000, 700);
        }
 
        g_signal_connect(gs->window,
                         "delete-event",
                         G_CALLBACK(scaffolding_window_delete_event),
                         gs);
 
        g_signal_connect(gs->window,
                         "destroy",
                         G_CALLBACK(scaffolding_window_destroy),
                         gs);
 
 
        /* notebook */
        res = nsgtk_notebook_create(gs->builder, &gs->notebook);
        if (res != NSERROR_OK) {
                free(gs);
                return NULL;
        }
 
        g_signal_connect_after(gs->notebook,
                               "page-added",
                               G_CALLBACK(nsgtk_window_tabs_add),
                               gs);
        gs->tabs_remove_handler_id = g_signal_connect_after(gs->notebook,
                               "page-removed",
                               G_CALLBACK(nsgtk_window_tabs_remove),
                               gs);
 
 
        res = nsgtk_menus_create(gs);
        if (res != NSERROR_OK) {
                free(gs);
                return NULL;
        }
 
        /* attach to the list */
        if (scaf_list) {
                scaf_list->prev = gs;
        }
        gs->next = scaf_list;
        gs->prev = NULL;
        scaf_list = gs;
 
        /* finally, show the window. */
        gtk_widget_show(GTK_WIDGET(gs->window));
 
        NSLOG(netsurf, INFO, "creation complete");
 
        return gs;
}
 
/* exported interface documented in gtk/scaffolding.h */
nserror nsgtk_scaffolding_position_page_info(struct nsgtk_scaffolding *gs,
                                             struct nsgtk_pi_window *win)
{
        return nsgtk_window_position_page_info(gs->top_level, win);
}
 
/* exported interface documented in gtk/scaffolding.h */
nserror nsgtk_scaffolding_position_local_history(struct nsgtk_scaffolding *gs)
{
        return nsgtk_window_position_local_history(gs->top_level);
}