gnc-gtk-utils.c

/********************************************************************\
 * gnc-gtk-utils.c -- utility functions based on glib functions     *
 * Copyright (C) 2006 David Hampton <hampton@employees.org>         *
 *                                                                  *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/

#include <config.h>

#include "gnc-gtk-utils.h"

#define LAST_INDEX "last_index"
#define CHANGED_ID "changed_id"


void
gnc_cbwe_set_by_string(GtkComboBox *cbwe,
                      const gchar *text)
{
    GtkTreeModel *model;
    GtkTreeIter iter;
    gchar *tree_string;
    gint column, index, id;
    gboolean match;

    model = gtk_combo_box_get_model(GTK_COMBO_BOX(cbwe));
    if (!gtk_tree_model_get_iter_first(model, &iter))
    {
        /* empty tree */
        gtk_combo_box_set_active(GTK_COMBO_BOX(cbwe), -1);
        return;
    }

    column = gtk_combo_box_get_entry_text_column(cbwe);
    do
    {
        gtk_tree_model_get(model, &iter, column, &tree_string, -1);
        match = g_utf8_collate(text, tree_string) == 0;
        g_free(tree_string);
        if (!match)
            continue;

        /* Found a matching string */
        id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cbwe), CHANGED_ID));
        g_signal_handler_block(cbwe, id);
        gtk_combo_box_set_active_iter(GTK_COMBO_BOX(cbwe), &iter);
        g_signal_handler_unblock(cbwe, id);

        index = gtk_combo_box_get_active(GTK_COMBO_BOX(cbwe));
        g_object_set_data(G_OBJECT(cbwe), LAST_INDEX, GINT_TO_POINTER(index));
        return;
    }
    while (gtk_tree_model_iter_next(model, &iter));
}


static void
gnc_cbwe_changed_cb (GtkComboBox *widget,
                    GtkComboBox *cbwe)
{
    gint index;

    index = gtk_combo_box_get_active(widget);
    if (index == -1)
        return;
    g_object_set_data(G_OBJECT(cbwe), LAST_INDEX, GINT_TO_POINTER(index));
}


static gboolean
gnc_cbwe_match_selected_cb (GtkEntryCompletion *completion,
                            GtkTreeModel       *comp_model,
                            GtkTreeIter        *comp_iter,
                            GtkComboBox        *cbwe)
{
    gint column;
    gchar *text;

    column = gtk_combo_box_get_entry_text_column(cbwe);
    gtk_tree_model_get(comp_model, comp_iter, column, &text, -1);
    gnc_cbwe_set_by_string(cbwe, text);
    g_free(text);
    return FALSE;
}


static gboolean
gnc_cbwe_focus_out_cb (GtkEntry *entry,
                       GdkEventFocus *event,
                       GtkComboBox *cbwe)
{
    const gchar *text;
    gint index;

    /* Make a final attempt to match the current text. */
    text = gtk_entry_get_text(entry);
    gnc_cbwe_set_by_string(cbwe, text);

    /* Get the last known index (which may have just been set). */
    index = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cbwe), LAST_INDEX));
    gtk_combo_box_set_active(GTK_COMBO_BOX(cbwe), index);
    return FALSE;
}

void
gnc_cbwe_add_completion (GtkComboBox *cbwe)
{
    GtkEntry *entry;
    GtkEntryCompletion *completion;
    GtkTreeModel *model;

    entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(cbwe)));
    completion = gtk_entry_get_completion(entry);
    if (completion)
        return;

    /* No completion yet? Set one up. */
    completion = gtk_entry_completion_new();
    model = gtk_combo_box_get_model(GTK_COMBO_BOX(cbwe));
    gtk_entry_completion_set_model(completion, model);
    gtk_entry_completion_set_text_column(completion, 0);
    gtk_entry_set_completion(entry, completion);
    g_object_unref(completion);
}

void
gnc_cbwe_require_list_item (GtkComboBox *cbwe)
{
    GtkEntry *entry;
    GtkEntryCompletion *completion;
    GtkTreeModel *model;
    GtkTreeIter iter;
    gint index, id;

    /* Ensure completion is set up. */
    gnc_cbwe_add_completion(cbwe);

    /* If an item in the combo box isn't already selected, then force
     * select the first item. Take care, the combo box may not have been
     * filled yet.  */
    entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(cbwe)));
    completion = gtk_entry_get_completion(entry);
    index = gtk_combo_box_get_active(GTK_COMBO_BOX(cbwe));
    if (index == -1)
    {
        model = gtk_entry_completion_get_model(completion);
        if (gtk_tree_model_get_iter_first(model, &iter))
        {
            gtk_combo_box_set_active(GTK_COMBO_BOX(cbwe), 0);
            index = 0;
        }
    }
    g_object_set_data(G_OBJECT(cbwe), LAST_INDEX, GINT_TO_POINTER(index));

    /* Now the signals to make sure the user can't leave the
       widget without a valid match. */
    id = g_signal_connect(cbwe, "changed",
                          G_CALLBACK(gnc_cbwe_changed_cb), cbwe);
    g_signal_connect(completion, "match_selected",
                     G_CALLBACK(gnc_cbwe_match_selected_cb), cbwe);
    g_signal_connect(entry, "focus-out-event",
                     G_CALLBACK(gnc_cbwe_focus_out_cb), cbwe);

    g_object_set_data(G_OBJECT(cbwe), CHANGED_ID, GINT_TO_POINTER(id));
}

gboolean
gnc_is_dark_theme (GdkRGBA *fg_color)
{
    gboolean is_dark = FALSE;

    // Counting the perceptive luminance - human eye favors green color...
    double lightness = (0.299 * fg_color->red + 0.587 * fg_color->green + 0.114 * fg_color->blue);

    if (lightness > 0.5)
        is_dark = TRUE;

    return is_dark;
}

void
gnc_style_context_get_background_color (GtkStyleContext *context,
                                        GtkStateFlags    state,
                                        GdkRGBA         *color)
{
    GdkRGBA *c;

    g_return_if_fail (color != NULL);
    g_return_if_fail (GTK_IS_STYLE_CONTEXT (context));

    gtk_style_context_get (context,
                           state,
                           GTK_STYLE_PROPERTY_BACKGROUND_COLOR, &c,
                           NULL);
    *color = *c;
    gdk_rgba_free (c);
}

void
gnc_style_context_get_border_color (GtkStyleContext *context,
                                    GtkStateFlags    state,
                                    GdkRGBA         *color)
{
    GdkRGBA *c;

    g_return_if_fail (color != NULL);
    g_return_if_fail (GTK_IS_STYLE_CONTEXT (context));

    gtk_style_context_get (context,
                           state,
                           GTK_STYLE_PROPERTY_BORDER_COLOR, &c,
                           NULL);
    *color = *c;
    gdk_rgba_free (c);
}

static gpointer
find_widget_func (GtkWidget *widget, const gchar *id)
{
    const gchar *name = gtk_buildable_get_name (GTK_BUILDABLE(widget));
    GtkWidget *ret = NULL;

    if (g_strcmp0 (name, id) == 0)
        return widget;

    if (GTK_IS_CONTAINER(widget))
    {
        GList *container_list = gtk_container_get_children (GTK_CONTAINER(widget));
        for (GList *n = container_list; !ret && n; n = n->next)
            ret = find_widget_func (n->data, id);
        g_list_free (container_list);
    }

    return ret;
}

GtkWidget *
gnc_get_dialog_widget_from_id (GtkDialog *dialog, const gchar *id)
{
    GtkWidget *content_area = gtk_dialog_get_content_area (dialog);
    return find_widget_func (content_area, id);
}


void
gnc_disable_all_actions_in_group (GSimpleActionGroup *action_group)
{
    gchar **actions;
    gint num_actions;

    g_return_if_fail (action_group != NULL);

    actions = g_action_group_list_actions (G_ACTION_GROUP(action_group));
    num_actions = g_strv_length (actions);

    // Disable the actions
    for (gint i = 0; i < num_actions; i++)
    {
        GAction *action = g_action_map_lookup_action (G_ACTION_MAP(action_group),
                                                      actions[i]);
        g_simple_action_set_enabled (G_SIMPLE_ACTION(action), FALSE);
    }
    g_strfreev (actions);
}


static void
accel_map_foreach_func (gpointer user_data, const gchar* accel_path, guint accel_key,
                        GdkModifierType accel_mods, gboolean changed)
{
    GMenuModel *menu_model = user_data;
    gchar **accel_path_parts = NULL;
    guint  accel_size = 0;
    gchar *target = NULL;
    gchar *accel_name_tmp = gtk_accelerator_name (accel_key, accel_mods);
    gchar *accel_name = g_strescape (accel_name_tmp, NULL);

    accel_path_parts = g_strsplit (accel_path, "/", -1);
    accel_size = g_strv_length (accel_path_parts);

    if (accel_size == 4)
        target = g_strdup (accel_path_parts[3]);

    if (accel_size >=3)
        gnc_menubar_model_update_item (menu_model, accel_path_parts[2],
                                       target, NULL, accel_name, NULL);

    g_strfreev (accel_path_parts);
    g_free (target);
    g_free (accel_name_tmp);
    g_free (accel_name);
}

static void
add_accel_for_menu_lookup (GtkWidget *widget, gpointer user_data)
{
    if (GTK_IS_MENU_ITEM(widget))
    {
        GtkMenuItem* menuItem = GTK_MENU_ITEM(widget);
        GtkWidget* subMenu = gtk_menu_item_get_submenu (menuItem);
        GtkWidget *accel_label = gtk_bin_get_child (GTK_BIN(widget));

        if (accel_label)
        {
            gboolean added = GPOINTER_TO_INT(g_object_get_data (G_OBJECT(menuItem),
                                                                "accel-added"));
            guint key;
            GdkModifierType mods;

            gtk_accel_label_get_accel (GTK_ACCEL_LABEL(accel_label), &key, &mods);

            if (key > 0 && !added)
            {
                g_object_set_data (G_OBJECT(menuItem), "accel-added", GINT_TO_POINTER(1));
                gtk_widget_add_accelerator (GTK_WIDGET(widget), "activate",
                                            GTK_ACCEL_GROUP(user_data),
                                            key, mods, GTK_ACCEL_VISIBLE);
            }
        }
        if (GTK_IS_CONTAINER(subMenu))
            gtk_container_foreach (GTK_CONTAINER(subMenu),
                                   add_accel_for_menu_lookup, user_data);
    }
}

void
gnc_add_accelerator_keys_for_menu (GtkWidget *menu, GMenuModel *model, GtkAccelGroup *accel_group)
{
    g_return_if_fail (GTK_IS_WIDGET(menu));
    g_return_if_fail (model != NULL);
    g_return_if_fail (accel_group != NULL);

    // this updates the menu accelerators based on accelerator-map
    gtk_accel_map_foreach (model, (GtkAccelMapForeach)accel_map_foreach_func);

    gtk_container_foreach (GTK_CONTAINER(menu), add_accel_for_menu_lookup, accel_group);
}


static gpointer
find_menu_item_func (GtkWidget *widget, const gchar *action_name, const gchar *action_label)
{
    GtkWidget *ret = NULL;

    if (GTK_IS_MENU_ITEM(widget))
    {
        GtkWidget* subMenu;

        if (action_name)
        {
            if (GTK_IS_ACTIONABLE(widget))
            {
                const gchar *a_name = gtk_actionable_get_action_name (GTK_ACTIONABLE(widget));

                if (g_strcmp0 (a_name, action_name) == 0)
                    return widget;
            }
        }

        if (action_label)
        {
            GtkWidget *accel_label = gtk_bin_get_child (GTK_BIN(widget));

            if (accel_label)
            {
                // use gtk_label_get_text to get text with no underlines
                const gchar *al_name = gtk_label_get_label (GTK_LABEL(accel_label));

                if (g_strcmp0 (al_name, action_label) == 0)
                    return widget;
             }
        }

        subMenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM(widget));

        if (GTK_IS_CONTAINER(subMenu))
        {
            GList *container_list = gtk_container_get_children (GTK_CONTAINER(subMenu));
            for (GList *n = container_list; !ret && n; n = n->next)
                ret = find_menu_item_func (n->data, action_name, action_label);
            g_list_free (container_list);
        }
    }
    return ret;
}

GtkWidget *
gnc_find_menu_item_by_action_name (GtkWidget *menu, const gchar *action_name)
{
    GtkWidget *ret = NULL;
    const gchar *action_label = NULL;

    g_return_val_if_fail (GTK_IS_WIDGET(menu), NULL);
    g_return_val_if_fail (action_name != NULL, NULL);

    if (GTK_IS_CONTAINER(menu))
    {
        GList *container_list = gtk_container_get_children (GTK_CONTAINER(menu));
        for (GList *n = container_list; !ret && n; n = n->next)
            ret = find_menu_item_func (n->data, action_name, action_label);
        g_list_free (container_list);
    }
    return ret;
}


GtkWidget *
gnc_find_menu_item_by_action_label (GtkWidget *menu, const gchar *action_label)
{
    GtkWidget *ret = NULL;
    const gchar *action_name = NULL;

    g_return_val_if_fail (GTK_IS_WIDGET(menu), NULL);
    g_return_val_if_fail (action_label != NULL, NULL);

    if (GTK_IS_CONTAINER(menu))
    {
        GList *container_list = gtk_container_get_children (GTK_CONTAINER(menu));
        for (GList *n = container_list; !ret && n; n = n->next)
            ret = find_menu_item_func (n->data, action_name, action_label);
        g_list_free (container_list);
    }
    return ret;
}


static void
menu_item_list (GtkWidget *widget, gpointer user_data)
{
    GList **list = user_data;

    if (GTK_IS_MENU_ITEM(widget))
    {
        GtkWidget* subMenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM(widget));

        *list = g_list_prepend (*list, widget);

        if (GTK_IS_CONTAINER(subMenu))
            gtk_container_foreach (GTK_CONTAINER(subMenu),
                                   menu_item_list, user_data);
    }
}

GList *
gnc_menu_get_items (GtkWidget *menu)
{
    GList *list = NULL;

    g_return_val_if_fail (GTK_IS_WIDGET(menu), NULL);

    gtk_container_foreach (GTK_CONTAINER(menu), menu_item_list, &list);

    return list;
}


struct find_tool_item_struct
{
    GtkWidget   *found_tool_item;
    const gchar *action_name;
};

static void
find_tool_action (GtkWidget *widget, gpointer user_data)
{
    struct find_tool_item_struct *ftis = user_data;

    if (GTK_IS_ACTIONABLE(widget))
    {
        // this returns the full action name
        const gchar *item_action_name = gtk_actionable_get_action_name (GTK_ACTIONABLE(widget));

        if (g_str_has_suffix (item_action_name, ftis->action_name))
            ftis->found_tool_item = GTK_WIDGET(widget);
    }
}

GtkWidget *
gnc_find_toolbar_item (GtkWidget *toolbar, const gchar *action_name)
{
    struct find_tool_item_struct ftis;

    g_return_val_if_fail (GTK_IS_TOOLBAR(toolbar), NULL);
    g_return_val_if_fail (action_name != NULL, NULL);

    ftis.action_name = action_name;
    ftis.found_tool_item = NULL;

    gtk_container_foreach (GTK_CONTAINER(toolbar), find_tool_action, &ftis);

    return ftis.found_tool_item;
}


static void
extract_items_from_model (GMenuModel *model,
                          gint        item,
                          gpointer    user_data)
{
    GMenuAttributeIter *iter;
    const gchar *key;
    GVariant *value;
    GncMenuModelSearch *gsm = user_data;
    const gchar *action = NULL;
    const gchar *label = NULL;
    const gchar *tooltip = NULL;
    const gchar *target_char = NULL;
    gint         target_int = -1;

    iter = g_menu_model_iterate_item_attributes (model, item);
    while (g_menu_attribute_iter_get_next (iter, &key, &value))
    {
        if (g_str_equal (key, GNC_MENU_ATTRIBUTE_TOOLTIP) &&
            g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
            tooltip = g_variant_get_string (value, NULL);
        else if (g_str_equal (key, G_MENU_ATTRIBUTE_LABEL) &&
                 g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
            label = g_variant_get_string (value, NULL);
        else if (g_str_equal (key, G_MENU_ATTRIBUTE_ACTION) &&
                 g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
            action = g_variant_get_string (value, NULL);
        else if (g_str_equal (key, G_MENU_ATTRIBUTE_TARGET) &&
                 g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
            target_char = g_variant_get_string (value, NULL);
        else if (g_str_equal (key, G_MENU_ATTRIBUTE_TARGET) &&
                 g_variant_is_of_type (value, G_VARIANT_TYPE_INT32))
            target_int = g_variant_get_int32 (value);
        g_variant_unref (value);
    }

    if (gsm->search_action_target)
    {
        gboolean target_test = FALSE;

        if (target_int != -1 && target_int == atoi (gsm->search_action_target))
            target_test = TRUE;

        if (target_char && g_strcmp0 (target_char, gsm->search_action_target) == 0)
            target_test = TRUE;

        if (!target_test)
        {
            g_object_unref (iter);
            return;
        }
    }

    if (action && gsm->search_action_name)
    {
        if (g_str_has_suffix (action, gsm->search_action_name))
        {
            gsm->model = model;
            gsm->index = item;
            gsm->tooltip = tooltip;
            gsm->search_action_label = label;
        }
    }
    if (label && gsm->search_action_label)
    {
        if (g_strcmp0 (label, gsm->search_action_label) == 0)
        {
            gsm->model = model;
            gsm->index = item;
            gsm->tooltip = tooltip;
            gsm->search_action_name = action;
        }
    }
    g_object_unref (iter);
}

static void
items_from_model (GMenuModel *model,
                  gpointer user_data)
{
    GncMenuModelSearch *gsm = user_data;

    for (gint i = 0; i < g_menu_model_get_n_items (model); i++)
    {
        GMenuLinkIter *iter;
        GMenuModel *sub_model;

        if (gsm->model)
            return;

        extract_items_from_model (model, i, user_data);

        iter = g_menu_model_iterate_item_links (model, i);
        while (g_menu_link_iter_get_next (iter, NULL, &sub_model))
        {
            items_from_model (sub_model, user_data);
            g_object_unref (sub_model);
        }
        g_object_unref (iter);
    }
}

gboolean
gnc_menubar_model_find_item (GMenuModel *menu_model, GncMenuModelSearch *gsm)
{

    g_return_val_if_fail (menu_model != NULL, FALSE);
    g_return_val_if_fail (gsm != NULL, FALSE);

    gsm->model = NULL;

    items_from_model (menu_model, gsm);

    if (gsm->model)
       return TRUE;

    return FALSE;
}


GtkWidget *
gnc_menubar_model_find_menu_item (GMenuModel *menu_model, GtkWidget *menu, const gchar *action_name)
{
    GncMenuModelSearch *gsm;
    GtkWidget *menu_item = NULL;

    g_return_val_if_fail (menu_model != NULL, NULL);
    g_return_val_if_fail (menu != NULL, NULL);
    g_return_val_if_fail (action_name != NULL, NULL);

    gsm = g_new0 (GncMenuModelSearch, 1);

    gsm->search_action_label = NULL;
    gsm->search_action_name = action_name;
    gsm->search_action_target = NULL;

    if (gnc_menubar_model_find_item (menu_model, gsm))
        menu_item = gnc_find_menu_item_by_action_label (menu, gsm->search_action_label);

    g_free (gsm);
    return menu_item;
}


gboolean
gnc_menubar_model_update_item (GMenuModel *menu_model, const gchar *action_name,
                               const gchar *target, const gchar *label,
                               const gchar *accel_name, const gchar *tooltip)
{
    GncMenuModelSearch *gsm;
    gboolean found = FALSE;

    g_return_val_if_fail (menu_model != NULL, FALSE);
    g_return_val_if_fail (action_name != NULL, FALSE);

    gsm = g_new0 (GncMenuModelSearch, 1);

    gsm->search_action_label = NULL;
    gsm->search_action_name = action_name;
    gsm->search_action_target = target;

    if (gnc_menubar_model_find_item (menu_model, gsm))
    {
        GMenuAttributeIter *iter;
        const gchar *key;
        GVariant *value;
        GVariant *old_target = NULL;
        const gchar *old_action = NULL;
        const gchar *old_temp = NULL;
        const gchar *old_accel = NULL;
        const gchar *old_tooltip = NULL;

        iter = g_menu_model_iterate_item_attributes (gsm->model, gsm->index);
        while (g_menu_attribute_iter_get_next (iter, &key, &value))
        {
            if (g_str_equal (key, GNC_MENU_ATTRIBUTE_TEMPORARY) &&
                g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
                old_temp = g_variant_get_string (value, NULL);
            else if (g_str_equal (key, G_MENU_ATTRIBUTE_ACTION) &&
                     g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
                old_action = g_variant_get_string (value, NULL);
            else if (g_str_equal (key, GNC_MENU_ATTRIBUTE_ACCELERATOR) &&
                     g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
                old_accel = g_variant_get_string (value, NULL);
            else if (g_str_equal (key, GNC_MENU_ATTRIBUTE_TOOLTIP) &&
                     g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
                old_tooltip = g_variant_get_string (value, NULL);
            else if (g_str_equal (key, G_MENU_ATTRIBUTE_TARGET))
                old_target = g_variant_ref (value);

            g_variant_unref (value);
        }
        g_object_unref (iter);

        if (!label && !gsm->search_action_label)
        {
            if (old_target)
                g_variant_unref (old_target);

            g_free (gsm);
            return found;
        }

        if ((accel_name && g_strcmp0 (old_accel, accel_name) != 0) ||
            (tooltip && g_strcmp0 (old_tooltip, tooltip) != 0) ||
            (label && g_strcmp0 (gsm->search_action_label, label) != 0))
        {
            GMenuItem *item = NULL;

            if (label)
                item = g_menu_item_new (label, old_action);
            else
                item = g_menu_item_new (gsm->search_action_label, old_action);

            if (tooltip)
                g_menu_item_set_attribute (item, GNC_MENU_ATTRIBUTE_TOOLTIP, "s", tooltip);
            else
            {
                if (old_tooltip)
                   g_menu_item_set_attribute (item, GNC_MENU_ATTRIBUTE_TOOLTIP, "s", old_tooltip);
            }
            if (accel_name)
                g_menu_item_set_attribute (item, GNC_MENU_ATTRIBUTE_ACCELERATOR, "s", accel_name);
            else
            {
                if (old_accel)
                    g_menu_item_set_attribute (item, GNC_MENU_ATTRIBUTE_ACCELERATOR, "s", old_accel);
            }
            if (old_temp)
                g_menu_item_set_attribute (item, GNC_MENU_ATTRIBUTE_TEMPORARY, "s", old_temp);

            if (old_target)
                g_menu_item_set_attribute_value (item, G_MENU_ATTRIBUTE_TARGET, old_target);

            g_menu_remove (G_MENU(gsm->model), gsm->index);
            g_menu_insert_item (G_MENU(gsm->model), gsm->index, item);
            g_object_unref (item);
            found = TRUE;
        }
        if (old_target)
            g_variant_unref (old_target);
    }
    g_free (gsm);
    return found;
}


typedef struct
{
    GMenuModel *model;
    gint        index;
} to_remove;

static void
item_to_remove_from_model (GMenuModel  *model,
                           gint         item,
                           GList      **remove_list,
                           const gchar *attrib)
{
    GVariant *value = g_menu_model_get_item_attribute_value (model, item,
                                                             attrib, NULL);

    if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
    {
        to_remove *tr = g_new0 (to_remove, 1);
        tr->model = model;
        tr->index = item;

        // to keep the order append
        *remove_list = g_list_append (*remove_list, tr);
        g_variant_unref (value);
    }
}

static void
remove_items_from_model (GMenuModel *model,
                         GList **remove_list,
                         const gchar *attrib)
{
    // Note: item high to low
    for (gint i = g_menu_model_get_n_items (model) -1; i >= 0; i--)
    {
        GMenuLinkIter *iter;
        GMenuModel *sub_model;

        item_to_remove_from_model (model, i, remove_list, attrib);

        iter = g_menu_model_iterate_item_links (model, i);
        while (g_menu_link_iter_get_next (iter, NULL, &sub_model))
        {
            remove_items_from_model (sub_model, remove_list, attrib);
            g_object_unref (sub_model);
        }
        g_object_unref (iter);
    }
}

static void
remove_items (gpointer data, gpointer user_data)
{
    to_remove *tr = (to_remove*)data;
    g_menu_remove (G_MENU(tr->model), tr->index);
    g_free (tr);
}

void
gnc_menubar_model_remove_items_with_attrib (GMenuModel *menu_model, const gchar *attrib)
{
    GList *remove_list = NULL;

    g_return_if_fail (menu_model != NULL);
    g_return_if_fail (attrib != NULL);

    remove_items_from_model (menu_model, &remove_list, attrib);

    g_list_foreach (remove_list, (GFunc)remove_items, NULL);
    g_list_free (remove_list);
}


static void
statusbar_push (GtkWidget *statusbar, const gchar *text)
{
    gtk_statusbar_push (GTK_STATUSBAR(statusbar), 0,
                        text ? text : " ");
}

static void
statusbar_pop (GtkWidget *statusbar)
{
    gtk_statusbar_pop (GTK_STATUSBAR(statusbar), 0);
}

static void
menu_item_select_cb (GtkWidget *menu_item, GtkWidget *statusbar)
{
    GtkWidget *accel_label = gtk_bin_get_child (GTK_BIN(menu_item));
    GMenuModel *menubar_model = g_object_get_data (G_OBJECT(statusbar), "menu-model");

    if (!menubar_model)
        return;

    if (accel_label)
    {
        GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);

        gsm->search_action_label = gtk_label_get_label (GTK_LABEL(accel_label));
        gsm->search_action_name = NULL;

        if (gnc_menubar_model_find_item (menubar_model, gsm))
        {
            if (gsm->model)
                statusbar_push (statusbar, gsm->tooltip);
        }
        g_free (gsm);
    }
}

static void
menu_item_deselect_cb (GtkWidget *menu_item, GtkWidget *statusbar)
{
    statusbar_pop (statusbar);
}

void
gnc_menu_item_setup_tooltip_to_statusbar_callback (GtkWidget *menu_item,
                                                   GtkWidget *statusbar)
{
    g_return_if_fail (menu_item != NULL);
    g_return_if_fail (statusbar != NULL);

    if (GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_item), "added-callbacks")))
        return;

    g_signal_connect (menu_item, "select",
                      G_CALLBACK(menu_item_select_cb),
                      statusbar);
    g_signal_connect (menu_item, "deselect",
                      G_CALLBACK(menu_item_deselect_cb),
                      statusbar);
    g_object_set (G_OBJECT(menu_item), "has-tooltip", FALSE, NULL);

    g_object_set_data (G_OBJECT(menu_item), "added-callbacks", GINT_TO_POINTER(1));
}


static gboolean
tool_item_enter_event (GtkWidget *button, GdkEvent *event,
                       gpointer user_data)
{
    GtkWidget *tool_item = gtk_widget_get_parent (button);
    gchar *tooltip = gtk_widget_get_tooltip_text (tool_item);
    statusbar_push (user_data, tooltip);
    g_free (tooltip);
    return FALSE;
}

static gboolean
tool_item_leave_event (GtkWidget *button, GdkEvent *event,
                       gpointer user_data)
{
    statusbar_pop (user_data);
    return FALSE;
}

void
gnc_tool_item_setup_tooltip_to_statusbar_callback (GtkWidget *tool_item,
                                                   GtkWidget *statusbar)
{
    GtkWidget *child;

    g_return_if_fail (tool_item != NULL);
    g_return_if_fail (statusbar != NULL);

    child = gtk_bin_get_child (GTK_BIN(tool_item));

    gtk_widget_add_events (GTK_WIDGET(child),
                           GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK
                           | GDK_FOCUS_CHANGE_MASK);

    g_signal_connect (child, "enter-notify-event",
                      G_CALLBACK (tool_item_enter_event),
                      statusbar);

    g_signal_connect (child, "leave-notify-event",
                      G_CALLBACK (tool_item_leave_event),
                      statusbar);

    g_object_set (G_OBJECT(tool_item), "has-tooltip", FALSE, NULL);
}