dialog-search.c

/*
 * dialog-search.c -- Search Dialog
 * Copyright (C) 2002 Derek Atkins
 * Author: Derek Atkins <warlord@MIT.EDU>
 *
 * 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 <gtk/gtk.h>
#include <glib/gi18n.h>
 
#include "dialog-utils.h"
#include "gnc-component-manager.h"
#include "gnc-ui-util.h"
#include "gnc-ui.h"
#include "gnc-gui-query.h"
#include "gnc-query-view.h"
#include "gnc-prefs.h"
#include "gnc-session.h"
#include "qof.h"
#include "engine-helpers.h"
#include "qofbookslots.h"
 
#include "Transaction.h"    /* for the SPLIT_* and TRANS_* */
 
#include "dialog-search.h"
#include "search-core-type.h"
#include "search-param.h"
 
/* This static indicates the debugging module that this .o belongs to.  */
static QofLogModule log_module = G_LOG_DOMAIN;
 
#define DIALOG_SEARCH_CM_CLASS "dialog-search"
#define GNC_PREFS_GROUP_SEARCH_GENERAL "dialogs.search"
#define GNC_PREF_NEW_SEARCH_LIMIT  "new-search-limit"
#define GNC_PREF_ACTIVE_ONLY       "search-for-active-only"
 
typedef enum
{
    GNC_SEARCH_MATCH_ALL = 0,
    GNC_SEARCH_MATCH_ANY = 1
} GNCSearchType;
 
enum search_cols
{
    SEARCH_COL_NAME = 0,
    SEARCH_COL_POINTER,
    NUM_SEARCH_COLS
};
 
struct _GNCSearchWindow
{
    GtkWidget               *dialog;
    GtkWidget               *grouping_combo;
    GtkWidget               *match_all_label;
    GtkWidget               *criteria_table;
    GtkWidget               *criteria_scroll_window;
    GtkWidget               *result_hbox;
 
    /* The "results" sub-window widgets */
    GtkWidget               *result_view;
 
    /* The search_type radio-buttons */
    GtkWidget               *new_rb;
    GtkWidget               *narrow_rb;
    GtkWidget               *add_rb;
    GtkWidget               *del_rb;
    GtkWidget               *active_only_check;
 
    /* The Select button */
    GtkWidget               *select_button;
    GList                   *button_list;
 
    /* The close/cancel buttons */
    GtkWidget               *close_button;
    GtkWidget               *cancel_button;
 
    /* Callbacks */
    GNCSearchResultCB        result_cb;
    GNCSearchNewItemCB       new_item_cb;
    GNCSearchCallbackButton *buttons;
    GNCSearchFree            free_cb;
    gpointer                 user_data;
 
    GNCSearchSelectedCB      selected_cb;
    gpointer                 select_arg;
    gboolean                 allow_clear;
 
    /* What we're searching for, and how */
    const gchar              *type_label;
    QofIdTypeConst            search_for;
    GNCSearchType             grouping;     /* Match Any, Match All */
    const QofParam           *get_guid;     /* Function to GetGUID from the object */
    int                       search_type;  /* New, Narrow, Add, Delete */
 
    /* Our query status */
    QofQuery                 *q;
    QofQuery                 *start_q;      /* The query to start from, if any */
 
    /* The list of criteria */
    GNCSearchParam           *last_param;
    GList                    *params_list;  /* List of GNCSearchParams */
    GList                    *display_list; /* List of GNCSearchParamSimples for Display */
    gint                      num_cols;     /* Number of Display Columns */
    GList                    *crit_list;    /* List of crit_data */
 
    gint                      component_id;
    const gchar              *prefs_group;
};
 
struct _crit_data
{
    GNCSearchParam    *param;
    GNCSearchCoreType *element;
    GtkWidget         *elemwidget;
    GtkWidget         *container;
    GtkWidget         *button;
    GtkDialog         *dialog;
};
 
static void search_clear_criteria (GNCSearchWindow *sw);
static void gnc_search_dialog_display_results (GNCSearchWindow *sw);
 
static void
gnc_search_callback_button_execute (GNCSearchCallbackButton *cb,
                                    GNCSearchWindow *sw)
{
    GNCQueryView     *qview = GNC_QUERY_VIEW(sw->result_view);
 
    // Sanity check
    g_assert(qview);
 
    /* Do we have a callback for multi-selections ? */
    if (cb->cb_multiselect_fn && (!cb->cb_fcn ))
    {
        GList *entries = gnc_query_view_get_selected_entry_list (qview);
        // Call the callback
        (cb->cb_multiselect_fn)(GTK_WINDOW (sw->dialog), entries, sw->user_data);
        g_list_free (entries);
    }
    else
    {
        // No, stick to the single-item callback
        gpointer entry = gnc_query_view_get_selected_entry (qview);
        if (cb->cb_fcn)
            (cb->cb_fcn)(GTK_WINDOW (sw->dialog), &entry, sw->user_data);
    }
}
 
static void
gnc_search_dialog_result_clicked (GtkButton *button, GNCSearchWindow *sw)
{
    GNCSearchCallbackButton *cb;
 
    cb = g_object_get_data (G_OBJECT (button), "data");
    gnc_search_callback_button_execute (cb, sw);
}
 
static void
gnc_search_dialog_select_buttons_enable (GNCSearchWindow *sw, gint selected)
{
    gboolean enable, read_only;
    GList  *blist;
 
    read_only = qof_book_is_readonly (gnc_get_current_book ());
 
    for (blist = sw->button_list; blist; blist = blist->next)
    {
        GNCSearchCallbackButton  *button_spec = g_object_get_data (G_OBJECT(blist->data) , "data");
 
        if(selected == 0)
        {
            gtk_widget_set_sensitive (GTK_WIDGET(blist->data), FALSE);
            continue;
        }
 
        if(read_only == TRUE)
        {
            if((selected > 1) && (!(button_spec->cb_multiselect_fn == NULL)) && (button_spec->sensitive_if_readonly == TRUE))
                enable = TRUE;
            else
                enable = FALSE;
 
            if((selected == 1) && (button_spec->sensitive_if_readonly == TRUE))
                enable = TRUE;
        }
        else
        {
            if((selected > 1) && (!(button_spec->cb_multiselect_fn == NULL)))
                enable = TRUE;
            else
                enable = FALSE;
 
            if(selected == 1)
                enable = TRUE;
        }
        gtk_widget_set_sensitive (GTK_WIDGET(blist->data), enable);
    }
}
 
static void
gnc_search_dialog_select_cb (GtkButton *button, GNCSearchWindow *sw)
{
    gpointer entry;
    g_return_if_fail (sw->selected_cb);
 
    entry = gnc_query_view_get_selected_entry (GNC_QUERY_VIEW (sw->result_view));
    if (!entry && !sw->allow_clear)
    {
        char *msg = _("You must select an item from the list");
        gnc_error_dialog (GTK_WINDOW (sw->dialog), "%s", msg);
        return;
    }
 
    (sw->selected_cb)(GTK_WINDOW (sw->dialog), entry, sw->select_arg);
    gnc_search_dialog_destroy (sw);
}
 
static void
gnc_search_dialog_select_row_cb (GNCQueryView *qview,
                                 gpointer item,
                                 gpointer user_data)
{
    GNCSearchWindow  *sw = user_data;
    gint number_of_rows = GPOINTER_TO_INT(item);
    gnc_search_dialog_select_buttons_enable(sw, number_of_rows);
}
 
static void
gnc_search_dialog_double_click_cb (GNCQueryView *qview,
                                   gpointer item,
                                   gpointer user_data)
{
    GNCSearchWindow  *sw = user_data;
 
    if (sw->selected_cb)
        /* Select the item */
        gnc_search_dialog_select_cb (NULL, sw);
    else if (sw->buttons)
        /* Call the first button (usually view/edit) */
        gnc_search_callback_button_execute (sw->buttons, sw);
 
    /* If we get here, then nothing to do for a double-click */
}
 
static void
gnc_search_dialog_init_result_view (GNCSearchWindow *sw)
{
    GtkTreeSelection *selection;
 
    sw->result_view = gnc_query_view_new(sw->display_list, sw->q);
 
    // We want the multi-selection mode of the tree view.
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sw->result_view));
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 
    /* Set the sort order of the tree view */
    gnc_query_sort_order(GNC_QUERY_VIEW(sw->result_view), 1, GTK_SORT_ASCENDING);
 
    /* Setup the list callbacks */
    g_signal_connect (GNC_QUERY_VIEW(sw->result_view), "row_selected",
                      G_CALLBACK (gnc_search_dialog_select_row_cb), sw);
 
    g_signal_connect (GNC_QUERY_VIEW(sw->result_view), "double_click_entry",
                      G_CALLBACK(gnc_search_dialog_double_click_cb), sw);
}
 
static void
gnc_search_dialog_display_results (GNCSearchWindow *sw)
{
    gdouble max_count;
 
    /* Check if this is the first time this is called for this window.
     * If so, then build the results sub-window, the scrolled treeview,
     * and the active buttons.
     */
    if (sw->result_view == NULL)
    {
        GtkWidget *scroller, *frame, *button_box, *button;
 
        /* Create the view */
        gnc_search_dialog_init_result_view (sw);
 
        frame = gtk_frame_new(NULL);
 
        /* Create the scroller and add the view to the scroller */
        scroller = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
                                        GTK_POLICY_AUTOMATIC,
                                        GTK_POLICY_AUTOMATIC);
        gtk_widget_set_size_request(GTK_WIDGET(scroller), 300, 100);
        gtk_container_add (GTK_CONTAINER (scroller), sw->result_view);
        gtk_container_add(GTK_CONTAINER(frame), scroller);
 
        /* Create the button_box */
        button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
        gtk_box_set_homogeneous (GTK_BOX (button_box), FALSE);
 
        /* ... and add all the buttons */
        if (sw->buttons)
        {
            int i;
 
            button = gtk_button_new_with_label (_("Select"));
            g_signal_connect (G_OBJECT (button), "clicked",
                              G_CALLBACK (gnc_search_dialog_select_cb), sw);
            gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
            sw->select_button = button;
 
            for (i = 0; sw->buttons[i].label; i++)
            {
                GNCSearchCallbackButton* button_spec = sw->buttons + i;
                button = gtk_button_new_with_label (_(button_spec->label));
                g_object_set_data (G_OBJECT (button), "data", button_spec);
 
                if (qof_book_is_readonly (gnc_get_current_book ()))
                    gtk_widget_set_sensitive (GTK_WIDGET(button), button_spec->sensitive_if_readonly);
 
                /* Save the button pointer */
                sw->button_list = g_list_append(sw->button_list, button);
 
                g_signal_connect (G_OBJECT (button), "clicked",
                                  G_CALLBACK (gnc_search_dialog_result_clicked), sw);
                gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
            }
        }
 
        /* Add the scrolled-view and button-box to the results_box */
        gtk_box_pack_end (GTK_BOX (sw->result_hbox), button_box, FALSE, FALSE, 3);
        gtk_box_pack_end (GTK_BOX (sw->result_hbox), frame, TRUE, TRUE, 3);
 
        /* And show the results */
        gtk_widget_show_all (sw->result_hbox);
 
        /* But may be hide the select button */
        if (!sw->selected_cb)
            gtk_widget_hide (sw->select_button);
    }
    else
        /* Update the query in the view */
        gnc_query_view_reset_query (GNC_QUERY_VIEW(sw->result_view), sw->q);
 
    /* Deselect all the select buttons and any items */
    gnc_search_dialog_select_buttons_enable (sw, 0);
    gnc_query_view_unselect_all (GNC_QUERY_VIEW(sw->result_view));
 
    /* set 'new search' if fewer than max_count items is returned. */
    max_count = gnc_prefs_get_float(GNC_PREFS_GROUP_SEARCH_GENERAL, GNC_PREF_NEW_SEARCH_LIMIT);
    if (gnc_query_view_get_num_entries(GNC_QUERY_VIEW(sw->result_view)) < max_count)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (sw->new_rb), TRUE);
 
    /* If there are results then select the first, and grab focus */
    if (gnc_query_view_get_num_entries (GNC_QUERY_VIEW(sw->result_view)) > 0)
    {
        GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(sw->result_view));
        GtkTreePath *path = gtk_tree_path_new_first ();
        gtk_tree_selection_select_path (selection, path);
        gtk_tree_path_free (path);
        gtk_widget_grab_focus (sw->result_view);
    }
}
 
static void
match_combo_changed (GtkComboBoxText *combo_box, GNCSearchWindow *sw)
{
    sw->grouping = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_box));
}
 
static void
search_type_cb (GtkToggleButton *button, GNCSearchWindow *sw)
{
    GSList * buttongroup = gtk_radio_button_get_group (GTK_RADIO_BUTTON(button));
 
    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
    {
        sw->search_type =
            g_slist_length (buttongroup) - g_slist_index (buttongroup, button) - 1;
    }
}
 
static void
search_active_only_cb (GtkToggleButton *button, GNCSearchWindow *sw)
{
 
    gnc_prefs_set_bool(sw->prefs_group, GNC_PREF_ACTIVE_ONLY,
                       gtk_toggle_button_get_active (button));
}
 
static QofQuery *
create_query_fragment (QofIdTypeConst search_for, GNCSearchParam *param, QofQueryPredData *pdata)
{
    GNCSearchParamKind kind = gnc_search_param_get_kind (param);
    QofQuery *q = qof_query_create_for (search_for);
 
    if (kind == SEARCH_PARAM_ELEM)
    {
        /* The "op" parameter below will be ignored since q has no terms. */
        qof_query_add_term (q, gnc_search_param_get_param_path (GNC_SEARCH_PARAM_SIMPLE (param)),
                            pdata, QOF_QUERY_OR);
    }
    else
    {
        GList *plist = gnc_search_param_get_search (GNC_SEARCH_PARAM_COMPOUND (param));
 
        for ( ; plist; plist  = plist->next)
        {
            QofQuery *new_q;
            GNCSearchParam *param2 = plist->data;
            QofQuery *q2 = create_query_fragment (search_for, param2,
                                                  qof_query_core_predicate_copy (pdata));
            new_q = qof_query_merge (q, q2, kind == SEARCH_PARAM_ANY ?
                                                    QOF_QUERY_OR : QOF_QUERY_AND);
            qof_query_destroy (q);
            qof_query_destroy (q2);
            q = new_q;
        }
        qof_query_core_predicate_free (pdata);
    }
    return q;
}
 
static void
search_update_query (GNCSearchWindow *sw)
{
    static GSList *active_params = NULL;
    QofQuery *q, *q2, *new_q;
    GList *node;
    QofQueryOp op;
 
    if (sw->grouping == GNC_SEARCH_MATCH_ANY)
        op = QOF_QUERY_OR;
    else
        op = QOF_QUERY_AND;
 
    if (active_params == NULL)
        active_params = g_slist_prepend (NULL, QOF_PARAM_ACTIVE);
 
    /* Make sure we supply a book! */
    if (sw->start_q == NULL)
    {
        sw->start_q = qof_query_create_for (sw->search_for);
        qof_query_set_book (sw->start_q, gnc_get_current_book ());
    }
    else
    {
        /* We've got a query -- purge it of any "active" parameters */
        qof_query_purge_terms (sw->start_q, active_params);
    }
 
    /* Now create a new query to work from */
    q = qof_query_create_for (sw->search_for);
 
    /* Walk the list of criteria */
    for (node = sw->crit_list; node; node = node->next)
    {
        struct _crit_data *data = node->data;
        QofQueryPredData* pdata;
 
        pdata = gnc_search_core_type_get_predicate (data->element);
        if (pdata)
        {
            q2 = create_query_fragment(sw->search_for, GNC_SEARCH_PARAM (data->param), pdata);
            new_q = qof_query_merge (q, q2, op);
            qof_query_destroy (q);
            qof_query_destroy (q2);
            q = new_q;
        }
    }
 
    /* Now combine this query with the existing query, depending on
     * what we want to do...  We can assume that cases 1, 2, and 3
     * already have sw->q being valid!
     */
 
    switch (sw->search_type)
    {
    case 0:         /* New */
        new_q = qof_query_merge (sw->start_q, q, QOF_QUERY_AND);
        qof_query_destroy (q);
        break;
    case 1:         /* Refine */
        new_q = qof_query_merge (sw->q, q, QOF_QUERY_AND);
        qof_query_destroy (q);
        break;
    case 2:         /* Add */
        new_q = qof_query_merge (sw->q, q, QOF_QUERY_OR);
        qof_query_destroy (q);
        break;
    case 3:         /* Delete */
        q2 = qof_query_invert (q);
        new_q = qof_query_merge (sw->q, q2, QOF_QUERY_AND);
        qof_query_destroy (q2);
        qof_query_destroy (q);
        break;
    default:
        g_warning ("bad search type: %d", sw->search_type);
        new_q = q;
        break;
    }
 
    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (sw->active_only_check)))
    {
        qof_query_add_boolean_match (new_q, active_params, TRUE, QOF_QUERY_AND);
        active_params = NULL;
    }
 
    /* Destroy the old query */
    if (sw->q)
        qof_query_destroy (sw->q);
 
    /* And save the new one */
    sw->q = new_q;
}
 
static void
gnc_search_dialog_show_close_cancel (GNCSearchWindow *sw)
{
    if (sw->selected_cb)
    {
        gtk_widget_show (sw->cancel_button);
        gtk_widget_hide (sw->close_button);
    }
    else
    {
        gtk_widget_hide (sw->cancel_button);
        gtk_widget_show (sw->close_button);
    }
}
 
static void
gnc_search_dialog_reset_widgets (GNCSearchWindow *sw)
{
    gboolean sens = (sw->q != NULL);
    gboolean crit_list_vis = FALSE;
 
    gtk_widget_set_sensitive(GTK_WIDGET(sw->narrow_rb), sens);
    gtk_widget_set_sensitive(GTK_WIDGET(sw->add_rb), sens);
    gtk_widget_set_sensitive(GTK_WIDGET(sw->del_rb), sens);
 
    if (sw->q)
    {
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (sw->new_rb), FALSE);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (sw->narrow_rb), TRUE);
    }
 
    if (sw->crit_list)
        crit_list_vis = TRUE;
 
    gtk_widget_set_sensitive(sw->grouping_combo, crit_list_vis);
    gtk_widget_set_visible (sw->criteria_scroll_window, crit_list_vis);
    gtk_widget_set_visible (sw->match_all_label, !crit_list_vis);
}
 
static gboolean
gnc_search_dialog_crit_ok (GNCSearchWindow *sw)
{
    struct _crit_data *data;
    GList *l;
    gboolean ret;
 
    if (!sw->crit_list)
        return TRUE;
 
    l = g_list_last (sw->crit_list);
    data = l->data;
    ret = gnc_search_core_type_validate (data->element);
 
    if (ret)
        sw->last_param = data->param;
 
    return ret;
}
 
static void
search_find_cb (GtkButton *button, GNCSearchWindow *sw)
{
    if (!gnc_search_dialog_crit_ok (sw))
        return;
 
    search_update_query (sw);
    search_clear_criteria (sw);
    gnc_search_dialog_reset_widgets (sw);
 
    if (sw->result_cb)
    {
        gpointer entry = NULL;
        if (sw->result_view)
        {
            GNCQueryView *qview = GNC_QUERY_VIEW (sw->result_view);
            entry = gnc_query_view_get_selected_entry (qview);
        }
        (sw->result_cb)(sw->q, sw->user_data, &entry);
    }
    else
        gnc_search_dialog_display_results (sw);
}
 
static void
search_new_item_cb (GtkButton *button, GNCSearchWindow *sw)
{
    gpointer res;
 
    g_return_if_fail (sw->new_item_cb);
 
    res = (sw->new_item_cb)(GTK_WINDOW (sw->dialog), sw->user_data);
 
    if (res)
    {
        const GncGUID *guid = (const GncGUID *) ((sw->get_guid->param_getfcn)(res, sw->get_guid));
        QofQueryOp op = QOF_QUERY_OR;
 
        if (!sw->q)
        {
            if (!sw->start_q)
            {
                sw->start_q = qof_query_create_for (sw->search_for);
                qof_query_set_book (sw->start_q, gnc_get_current_book ());
            }
            sw->q = qof_query_copy (sw->start_q);
            op = QOF_QUERY_AND;
        }
 
        qof_query_add_guid_match (sw->q, g_slist_prepend (NULL, QOF_PARAM_GUID),
                                  guid, op);
 
        /* Watch this entity so we'll refresh once it's actually changed */
        gnc_gui_component_watch_entity (sw->component_id, guid, QOF_EVENT_MODIFY);
    }
}
 
static void
search_cancel_cb (GtkButton *button, GNCSearchWindow *sw)
{
    /* Don't select anything */
    gnc_search_dialog_destroy (sw);
}
 
static void
search_help_cb (GtkButton *button, GNCSearchWindow *sw)
{
    gnc_gnome_help (GTK_WINDOW(sw->dialog), DF_MANUAL, DL_FIND_TRANSACTIONS);
}
 
static void
remove_element (GtkWidget *button, GNCSearchWindow *sw)
{
    GtkWidget *element;
    struct _elem_data *data;
 
    if (!sw->crit_list)
        return;
 
    element = g_object_get_data (G_OBJECT (button), "element");
    data = g_object_get_data (G_OBJECT (element), "data");
 
    /* remove the element from the list */
    sw->crit_list = g_list_remove (sw->crit_list, data);
 
    /* and from the display */
    gtk_container_remove (GTK_CONTAINER (sw->criteria_table), element);
    gtk_container_remove (GTK_CONTAINER (sw->criteria_table), button);
 
    /* disable match-type menu when there is no criterion */
    if (!sw->crit_list)
    {
        gtk_widget_set_sensitive(sw->grouping_combo, FALSE);
        gtk_widget_show(sw->match_all_label);
        gtk_widget_hide(sw->criteria_scroll_window);
    }
}
 
static void
attach_element (GtkWidget *element, GNCSearchWindow *sw, int row)
{
    GtkWidget *remove;
    struct _crit_data *data;
 
    data = g_object_get_data (G_OBJECT (element), "data");
 
    gnc_search_core_type_pass_parent (data->element, GTK_WINDOW(sw->dialog));
 
    gtk_grid_attach (GTK_GRID (sw->criteria_table), element, 0, row, 1, 1);
    gtk_widget_set_hexpand (element, TRUE);
    gtk_widget_set_halign (element, GTK_ALIGN_FILL);
    g_object_set (element, "margin", 0, NULL);
 
    remove = gtk_button_new_with_mnemonic (_("_Remove"));
    g_object_set_data (G_OBJECT (remove), "element", element);
    g_signal_connect (G_OBJECT (remove), "clicked", G_CALLBACK (remove_element), sw);
 
    gtk_grid_attach (GTK_GRID (sw->criteria_table), remove, 1, row, 1, 1);
    gtk_widget_set_hexpand (remove, FALSE);
    gtk_widget_set_halign (remove, GTK_ALIGN_CENTER);
    g_object_set (remove, "margin", 0, NULL);
 
    gtk_widget_show (remove);
    data->button = remove;  /* Save the button for later */
}
 
static void
combo_box_changed (GtkComboBox *combo_box, struct _crit_data *data)
{
    GNCSearchParam *param;
    GNCSearchCoreType *newelem;
    GtkTreeModel *model;
    GtkTreeIter iter;
 
    if (!gtk_combo_box_get_active_iter(combo_box, &iter))
        return;
    model = gtk_combo_box_get_model(combo_box);
    gtk_tree_model_get(model, &iter, SEARCH_COL_POINTER, &param, -1);
 
    if (gnc_search_param_type_match (param, data->param))
    {
        /* The param type is the same, just save the new param */
        data->param = param;
        return;
    }
    data->param = param;
 
    /* OK, let's do a widget shuffle, throw away the old widget/element,
     * and create another one here.  No need to change the crit_list --
     * the pointer to data stays the same.
     */
    if (data->elemwidget)
        gtk_container_remove (GTK_CONTAINER (data->container), data->elemwidget);
    g_object_unref (G_OBJECT (data->element));
 
    newelem = gnc_search_core_type_new_type_name
              (gnc_search_param_get_param_type (param));
    data->element = newelem;
    data->elemwidget = gnc_search_core_type_get_widget (newelem);
    if (data->elemwidget)
    {
        gtk_box_pack_start (GTK_BOX (data->container), data->elemwidget,
                            FALSE, FALSE, 0);
    }
 
    gnc_search_core_type_pass_parent (data->element, GTK_WINDOW(data->dialog));
 
    /* Make sure it's visible */
    gtk_widget_show_all (data->container);
 
    /* Make sure we widen up if necessary */
    gtk_widget_queue_resize (GTK_WIDGET (data->dialog));
 
    /* And grab focus */
    gnc_search_core_type_grab_focus (newelem);
    gnc_search_core_type_editable_enters (newelem);
}
 
static void
search_clear_criteria (GNCSearchWindow *sw)
{
    GList *node;
 
    for (node = sw->crit_list; node; )
    {
        GList *tmp = node->next;
        struct _crit_data *data = node->data;
        g_object_ref (data->button);
        remove_element (data->button, sw);
        node = tmp;
    }
}
 
static GtkWidget *
get_comb_box_widget (GNCSearchWindow *sw, struct _crit_data *data)
{
    GtkWidget *combo_box;
    GtkListStore *store;
    GtkTreeIter iter;
    GtkCellRenderer *cell;
    GList *l;
    int index = 0, current = 0;
 
    store = gtk_list_store_new(NUM_SEARCH_COLS, G_TYPE_STRING, G_TYPE_POINTER);
    combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
    g_object_unref(store);
 
    cell = gtk_cell_renderer_text_new ();
    gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (combo_box), cell, TRUE);
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
                                    "text", SEARCH_COL_NAME,
                                    NULL);
 
    for (l = sw->params_list; l; l = l->next)
    {
        GNCSearchParam *param = l->data;
 
        gtk_list_store_append(store, &iter);
        gtk_list_store_set(store, &iter,
                           SEARCH_COL_NAME, _(gnc_search_param_get_title (param)),
                           SEARCH_COL_POINTER, param,
                           -1);
 
        if (param == sw->last_param) /* is this the right parameter to start? */
            current = index;
 
        index++;
    }
 
    gtk_combo_box_set_active (GTK_COMBO_BOX(combo_box), current);
    g_signal_connect (combo_box, "changed", G_CALLBACK (combo_box_changed), data);
 
    return combo_box;
}
 
static GtkWidget *
get_element_widget (GNCSearchWindow *sw, GNCSearchCoreType *element)
{
    GtkWidget *combo_box, *hbox, *p;
    struct _crit_data *data;
 
    data = g_new0 (struct _crit_data, 1);
    data->element = element;
    data->dialog = GTK_DIALOG (sw->dialog);
 
    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
    gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
 
    /* only set to automatically clean up the memory */
    g_object_set_data_full (G_OBJECT (hbox), "data", data, g_free);
 
    p = gnc_search_core_type_get_widget (element);
    data->elemwidget = p;
    data->container = hbox;
    data->param = sw->last_param;
 
    combo_box = get_comb_box_widget (sw, data);
    gtk_box_pack_start (GTK_BOX (hbox), combo_box, FALSE, FALSE, 0);
    if (p)
        gtk_box_pack_start (GTK_BOX (hbox), p, FALSE, FALSE, 0);
    gtk_widget_show_all (hbox);
 
    return hbox;
}
 
static void
gnc_search_dialog_book_option_changed (gpointer new_val, gpointer user_data)
{
    GList *l;
    GNCSearchWindow *sw = user_data;
    gboolean *new_data = (gboolean*)new_val;
    /* Save current dialog focus */
    GtkWidget *focused_widget = gtk_window_get_focus(GTK_WINDOW(sw->dialog));
 
    g_return_if_fail (sw);
    if (strcmp (sw->search_for, GNC_ID_SPLIT) != 0)
        return;
 
    /* Adjust labels for future added search criteria */
    for (l = sw->params_list; l; l = l->next)
    {
        GNCSearchParam *param = l->data;
 
        if (*new_data)
        {
            if (strcmp (gnc_search_param_get_title (param), N_("Action")) == 0)
                gnc_search_param_set_title (param, N_("Number/Action"));
            if (strcmp (gnc_search_param_get_title (param), N_("Number")) == 0)
                gnc_search_param_set_title (param, N_("Transaction Number"));
        }
        else
        {
            if (strcmp (gnc_search_param_get_title (param), N_("Number/Action")) == 0)
                gnc_search_param_set_title (param, N_("Action"));
            if (strcmp (gnc_search_param_get_title (param), N_("Transaction Number")) == 0)
                gnc_search_param_set_title (param, N_("Number"));
        }
    }
    /* Adjust labels for existing search criteria; walk the list of criteria */
    for (l = sw->crit_list; l; l = l->next)
    {
        struct _crit_data *data = l->data;
        GList *children = gtk_container_get_children (GTK_CONTAINER(data->container));
 
        /* For each, walk the list of container children to get combo_box */
        for (GList *child = children; child; child = g_list_next (child))
        {
            GtkWidget *combo_box = child->data;
 
            /* Get current active item if combo_box */
            if (GTK_IS_COMBO_BOX(combo_box))
            {
                GtkWidget *new_combo_box;
                gint index;
 
                /* Set index to current active item */
                index = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_box));
                /* Create new combo_box to replace existing one */
                new_combo_box = get_comb_box_widget (sw, data);
                /* If current combo_box has focus, point to new_combo-box */
                if (focused_widget == combo_box)
                    focused_widget = new_combo_box;
                gtk_widget_destroy(combo_box);
                /* Set new combo_box to current active item */
                gtk_combo_box_set_active(GTK_COMBO_BOX(new_combo_box), index);
                gtk_box_pack_start (GTK_BOX (data->container), new_combo_box,
                                                               FALSE, FALSE, 0);
                gtk_box_reorder_child(GTK_BOX (data->container), new_combo_box, 0);
                gtk_widget_show_all (data->container);
            }
        }
        g_list_free (children);
    }
    gtk_widget_grab_focus(focused_widget);
}
 
struct grid_size
{
    GtkGrid *grid;
    gint cols, rows;
};
 
static void
get_grid_size (GtkWidget *child, gpointer data)
{
    struct grid_size *gridsize = data;
    gint top, left, height, width;
 
    gtk_container_child_get(GTK_CONTAINER(gridsize->grid), child,
                            "left-attach", &left,
                            "top-attach", &top,
                            "height", &height,
                            "width", &width,
                            NULL);
 
    if (left + width >= gridsize->cols)
        gridsize->cols = left + width;
 
    if (top + height >= gridsize->rows)
        gridsize->rows = top + height;
}
 
static void
gnc_search_dialog_add_criterion (GNCSearchWindow *sw)
{
    GNCSearchCoreType *new_sct;
    struct grid_size gridsize;
 
    gridsize.cols = 0;
    gridsize.rows = 0;
 
    /* First, make sure that the last criterion is ok */
    if (sw->crit_list)
    {
        if (!gnc_search_dialog_crit_ok (sw))
            return;
    }
    else
    {
        sw->last_param = sw->params_list->data;
 
        /* no match-all situation anymore */
        gtk_widget_set_sensitive(sw->grouping_combo, TRUE);
        gtk_widget_hide(sw->match_all_label);
        gtk_widget_show(sw->criteria_scroll_window);
    }
    /* create a new criterion element */
    new_sct = gnc_search_core_type_new_type_name
          (gnc_search_param_get_param_type (sw->last_param));
 
    if (new_sct)
    {
        struct _crit_data *data;
        GtkWidget *w;
 
        w = get_element_widget (sw, new_sct);
        data = g_object_get_data (G_OBJECT (w), "data");
        sw->crit_list = g_list_append (sw->crit_list, data);
 
        gridsize.grid = GTK_GRID (sw->criteria_table);
        gtk_container_foreach(GTK_CONTAINER(sw->criteria_table), get_grid_size, &gridsize);
 
        attach_element (w, sw, gridsize.rows);
 
        gnc_search_core_type_grab_focus (new_sct);
        gnc_search_core_type_editable_enters (new_sct);
    }
}
 
static void
add_criterion (GtkWidget *button, GNCSearchWindow *sw)
{
    gint number_of_buttons = g_list_length (sw->crit_list) + 1;
    gint button_height = gtk_widget_get_allocated_height (button);
    gint min_height = MIN (number_of_buttons * button_height, 5 * button_height);
 
    // this sets the minimum content height for the criteria scroll
    // window, it is set to a max of 5 buttons visible without scrolling
    gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(
                                                sw->criteria_scroll_window),
                                                min_height + (button_height/2));
 
    gnc_search_dialog_add_criterion (sw);
}
 
static int
gnc_search_dialog_close_cb (GtkDialog *dialog, GNCSearchWindow *sw)
{
    g_return_val_if_fail (sw, TRUE);
 
    /* Unregister callback on book option changes originally registered
     * if searching for splits */
    if (strcmp (sw->search_for, GNC_ID_SPLIT) == 0)
        gnc_book_option_remove_cb(OPTION_NAME_NUM_FIELD_SOURCE,
                                    gnc_search_dialog_book_option_changed, sw);
 
    gnc_unregister_gui_component (sw->component_id);
 
    /* Clear the crit list */
    g_list_free (sw->crit_list);
 
    /* Clear the button list */
    g_list_free (sw->button_list);
 
    /* Destroy the queries */
    if (sw->q) qof_query_destroy (sw->q);
    if (sw->start_q) qof_query_destroy (sw->start_q);
 
    /* Destroy the user_data */
    if (sw->free_cb)
        (sw->free_cb)(sw->user_data);
 
    /* Destroy and exit */
    g_free (sw);
    return FALSE;
}
 
static void
refresh_handler (GHashTable *changes, gpointer data)
{
    GNCSearchWindow * sw = data;
 
    g_return_if_fail (sw);
    /* This assumes that results_cb will refresh itself which is the case with
     * registers. Also, only refresh if you are already displaying results */
    if (!sw->result_cb && (sw->result_view != NULL))
       gnc_search_dialog_display_results (sw);
}
 
static void
close_handler (gpointer data)
{
    GNCSearchWindow * sw = data;
 
    g_return_if_fail (sw);
    gtk_widget_destroy (sw->dialog);
    /* DRH: should sw be freed here? */
}
 
static const gchar *
type_label_to_new_button(const gchar* type_label)
{
    if (g_strcmp0(type_label, _("Bill")) == 0)
    {
        return _("New Bill");
    }
    else if (g_strcmp0(type_label, _("Customer")) == 0)
    {
        return _("New Customer");
    }
    else if (g_strcmp0(type_label, _("Employee")) == 0)
    {
        return _("New Employee");
    }
    else if (g_strcmp0(type_label, _("Expense Voucher")) == 0)
    {
        return _("New Expense Voucher");
    }
    else if (g_strcmp0(type_label, _("Invoice")) == 0)
    {
        return _("New Invoice");
    }
    else if (g_strcmp0(type_label, _("Job")) == 0)
    {
        return _("New Job");
    }
    else if (g_strcmp0(type_label, _("Order")) == 0)
    {
        return _("New Order");
    }
    else if (g_strcmp0(type_label, _("Transaction")) == 0)
    {
        return _("New Transaction");
    }
    else if (g_strcmp0(type_label, _("Split")) == 0)
    {
        return _("New Split");
    }
    else if (g_strcmp0(type_label, _("Vendor")) == 0)
    {
        return _("New Vendor");
    }
    else
    {
        PWARN("No translatable new-button label found for search type \"%s\", please add one into dialog-search.c!", type_label);
        return C_("Item represents an unknown object type (in the sense of bill, customer, invoice, transaction, split,…)!", "New item");
    }
}
 
static void
gnc_search_dialog_init_widgets (GNCSearchWindow *sw, const gchar *title)
{
    GtkBuilder        *builder;
    GtkWidget         *label, *add, *box;
    GtkComboBoxText   *combo_box;
    GtkWidget         *widget;
    GtkWidget         *new_item_button;
    const char        *type_label;
    gboolean           active;
 
    builder = gtk_builder_new();
    gnc_builder_add_from_file (builder, "dialog-search.glade", "search_dialog");
 
    /* Grab the dialog, save the dialog info */
    sw->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "search_dialog"));
    gtk_window_set_title(GTK_WINDOW(sw->dialog), title);
    g_object_set_data (G_OBJECT (sw->dialog), "dialog-info", sw);
 
    // Set the name for this dialog so it can be easily manipulated with css
    gtk_widget_set_name (GTK_WIDGET(sw->dialog), "gnc-id-search");
    gnc_widget_style_context_add_class (GTK_WIDGET(sw->dialog), "gnc-class-search");
 
    /* Grab the result hbox */
    sw->result_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "result_hbox"));
 
    /* Grab the search-table widget */
    sw->criteria_table = GTK_WIDGET(gtk_builder_get_object (builder, "criteria_table"));
    sw->criteria_scroll_window = GTK_WIDGET(gtk_builder_get_object (builder, "criteria_scroll_window"));
 
    /* Set the type label */
    label = GTK_WIDGET(gtk_builder_get_object (builder, "type_label"));
    if (sw->type_label)
        type_label = sw->type_label;
    else
        type_label = _(qof_object_get_type_label (sw->search_for));
    gtk_label_set_text (GTK_LABEL (label), type_label);
 
    /* Set the 'add criterion' button */
    add = gtk_button_new_with_mnemonic (_("_Add"));
 
    g_signal_connect (G_OBJECT (add), "clicked", G_CALLBACK (add_criterion), sw);
    box = GTK_WIDGET(gtk_builder_get_object (builder, "add_button_box"));
    gtk_box_pack_start (GTK_BOX (box), add, FALSE, FALSE, 3);
    gtk_widget_show (add);
 
    /* Set the match-type menu */
    sw->grouping_combo = gtk_combo_box_text_new();
    combo_box = GTK_COMBO_BOX_TEXT(sw->grouping_combo);
    gtk_combo_box_text_append_text(combo_box, _("all criteria are met"));
    gtk_combo_box_text_append_text(combo_box, _("any criteria are met"));
    gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), sw->grouping);
    g_signal_connect(combo_box, "changed", G_CALLBACK (match_combo_changed), sw);
 
    box = GTK_WIDGET(gtk_builder_get_object (builder, "type_menu_box"));
    gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET(combo_box), FALSE, FALSE, 3);
    gtk_widget_show(GTK_WIDGET(combo_box));
 
    /* Grab the 'all items match' label */
    sw->match_all_label = GTK_WIDGET(gtk_builder_get_object (builder, "match_all_label"));
 
    /* if there's no original query, make the narrow, add, delete buttons inaccessible */
    sw->new_rb = GTK_WIDGET(gtk_builder_get_object (builder, "new_search_radiobutton"));
    g_signal_connect (sw->new_rb, "toggled",
                      G_CALLBACK (search_type_cb), sw);
    sw->narrow_rb = GTK_WIDGET(gtk_builder_get_object (builder, "narrow_search_radiobutton"));
    g_signal_connect (sw->narrow_rb, "toggled",
                      G_CALLBACK (search_type_cb), sw);
    sw->add_rb = GTK_WIDGET(gtk_builder_get_object (builder, "add_search_radiobutton"));
    g_signal_connect (sw->add_rb, "toggled",
                      G_CALLBACK (search_type_cb), sw);
    sw->del_rb = GTK_WIDGET(gtk_builder_get_object (builder, "delete_search_radiobutton"));
    g_signal_connect (sw->del_rb, "toggled",
                      G_CALLBACK (search_type_cb), sw);
 
    active = gnc_prefs_get_bool(sw->prefs_group, GNC_PREF_ACTIVE_ONLY);
    sw->active_only_check = GTK_WIDGET(gtk_builder_get_object (builder, "active_only_check"));
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sw->active_only_check), active);
    g_signal_connect (sw->active_only_check, "toggled",
                      G_CALLBACK (search_active_only_cb), sw);
 
    /* Figure out if we this object-type has an "active" parameter, and
     * if not, then set the active-check button insensitive
     */
    if (qof_class_get_parameter (sw->search_for, QOF_PARAM_ACTIVE) == NULL)
        gtk_widget_set_sensitive (sw->active_only_check, FALSE);
 
    /* Deal with the find button */
    widget = GTK_WIDGET(gtk_builder_get_object (builder, "find_button"));
    g_signal_connect (widget, "clicked",
                      G_CALLBACK (search_find_cb), sw);
 
    /* Deal with the cancel button */
    sw->cancel_button = GTK_WIDGET(gtk_builder_get_object (builder, "cancel_button"));
    g_signal_connect (sw->cancel_button, "clicked",
                      G_CALLBACK (search_cancel_cb), sw);
 
    /* Deal with the close button */
    sw->close_button = GTK_WIDGET(gtk_builder_get_object (builder, "close_button"));
    g_signal_connect (sw->close_button, "clicked",
                      G_CALLBACK (search_cancel_cb), sw);
 
    /* Deal with the new_item button */
    new_item_button = GTK_WIDGET(gtk_builder_get_object (builder, "new_item_button"));
    gtk_button_set_label (GTK_BUTTON(new_item_button),
                          type_label_to_new_button(type_label));
    g_signal_connect (new_item_button, "clicked",
                      G_CALLBACK (search_new_item_cb), sw);
 
    /* Deal with the help button */
    widget = GTK_WIDGET(gtk_builder_get_object (builder, "help_button"));
    g_signal_connect (widget, "clicked",
                      G_CALLBACK (search_help_cb), sw);
 
    /* add the first criterion */
    gnc_search_dialog_add_criterion (sw);
 
    /* register to update criterion/criteria labels based on book option changes
     * if searching for splits */
    if (strcmp (sw->search_for, GNC_ID_SPLIT) == 0)
        gnc_book_option_register_cb(OPTION_NAME_NUM_FIELD_SOURCE,
                                    gnc_search_dialog_book_option_changed, sw);
 
    /* Hide the 'new' button if there is no new_item_cb */
    if (!sw->new_item_cb)
        gtk_widget_hide (new_item_button);
 
    /* Connect all the signals */
    gtk_builder_connect_signals (builder, sw);
 
    /* Register ourselves */
    sw->component_id = gnc_register_gui_component (DIALOG_SEARCH_CM_CLASS,
                       refresh_handler,
                       close_handler, sw);
    gnc_gui_component_set_session (sw->component_id,
                                   gnc_get_current_session());
 
    /* And setup the close callback */
    g_signal_connect (G_OBJECT (sw->dialog), "destroy",
                      G_CALLBACK (gnc_search_dialog_close_cb), sw);
 
    gnc_search_dialog_reset_widgets (sw);
    gnc_search_dialog_show_close_cancel (sw);
 
    g_object_unref(G_OBJECT(builder));
}
 
void
gnc_search_dialog_destroy (GNCSearchWindow *sw)
{
    if (!sw) return;
    if (sw->prefs_group)
        gnc_save_window_size(sw->prefs_group, GTK_WINDOW(sw->dialog));
    gnc_close_gui_component (sw->component_id);
}
 
void
gnc_search_dialog_raise (GNCSearchWindow *sw)
{
    if (!sw) return;
    gtk_window_present (GTK_WINDOW(sw->dialog));
}
 
GNCSearchWindow *
gnc_search_dialog_create (GtkWindow *parent,
                          QofIdTypeConst obj_type, const gchar *title,
                          GList *param_list,
                          GList *display_list,
                          QofQuery *start_query, QofQuery *show_start_query,
                          GNCSearchCallbackButton *callbacks,
                          GNCSearchResultCB result_callback,
                          GNCSearchNewItemCB new_item_cb,
                          gpointer user_data, GNCSearchFree free_cb,
                          const gchar *prefs_group,
                          const gchar *type_label,
                          const gchar *style_class)
{
    GNCSearchWindow *sw = g_new0 (GNCSearchWindow, 1);
 
    g_return_val_if_fail (obj_type, NULL);
    g_return_val_if_fail (*obj_type != '\0', NULL);
    g_return_val_if_fail (param_list, NULL);
 
    /* Make sure the caller supplies callbacks xor result_callback */
    g_return_val_if_fail ((callbacks && !result_callback) ||
                          (!callbacks && result_callback), NULL);
 
    if (callbacks)
        g_return_val_if_fail (display_list, NULL);
 
    sw->search_for = obj_type;
    sw->params_list = param_list;
    sw->display_list = display_list;
    sw->buttons = callbacks;
    sw->result_cb = result_callback;
    sw->new_item_cb = new_item_cb;
    sw->user_data = user_data;
    sw->free_cb = free_cb;
    sw->prefs_group = prefs_group;
    sw->type_label = type_label;
 
    /* Grab the get_guid function */
    sw->get_guid = qof_class_get_parameter (sw->search_for, QOF_PARAM_GUID);
    if (start_query)
        sw->start_q = qof_query_copy (start_query);
    sw->q = show_start_query;
 
    gnc_search_dialog_init_widgets (sw, title);
    if (sw->prefs_group)
        gnc_restore_window_size(sw->prefs_group, GTK_WINDOW(sw->dialog), parent);
    gtk_window_set_transient_for(GTK_WINDOW(sw->dialog), parent);
    gtk_widget_show(sw->dialog);
 
    /* For some reason on Ubuntu 18.04 that uses Gtk3.22.30 and maybe others we
     * have to set the scroll window content min height after the dialog has been
     * shown to get the correct scroll window height */
    gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(
                                                sw->criteria_scroll_window),
                                                gtk_widget_get_allocated_height (
                                                GTK_WIDGET(sw->grouping_combo)) * 1.5);
 
    // Add a style context for this dialog so it can be easily manipulated with css
    if (style_class != NULL)
        gnc_widget_style_context_add_class (GTK_WIDGET(sw->dialog), style_class);
 
    /* Maybe display the original query results? */
    if (callbacks && show_start_query)
    {
        gnc_search_dialog_reset_widgets (sw);
        gnc_search_dialog_display_results (sw);
    }
 
    return sw;
}
 
/* Register an on-close signal with the Search Dialog */
guint gnc_search_dialog_connect_on_close (GNCSearchWindow *sw,
        GCallback func,
        gpointer user_data)
{
    g_return_val_if_fail (sw, 0);
    g_return_val_if_fail (func, 0);
    g_return_val_if_fail (user_data, 0);
 
    return g_signal_connect (G_OBJECT (sw->dialog), "destroy",
                             func, user_data);
 
}
 
/* Un-register the signal handlers with the Search Dialog */
void gnc_search_dialog_disconnect (GNCSearchWindow *sw, gpointer user_data)
{
    g_return_if_fail (sw);
    g_return_if_fail (user_data);
 
    g_signal_handlers_disconnect_matched (sw->dialog, G_SIGNAL_MATCH_DATA,
                                          0, 0, NULL, NULL, user_data);
}
 
/* Clear all callbacks with this Search Window */
void gnc_search_dialog_set_select_cb (GNCSearchWindow *sw,
                                      GNCSearchSelectedCB selected_cb,
                                      gpointer user_data,
                                      gboolean allow_clear)
{
    g_return_if_fail (sw);
 
    sw->selected_cb = selected_cb;
    sw->select_arg = user_data;
    sw->allow_clear = allow_clear;
 
    /* Show or hide the select button */
    if (sw->select_button)
    {
        if (selected_cb)
            gtk_widget_show (sw->select_button);
        else
            gtk_widget_hide (sw->select_button);
    }
 
    /* Show the proper close/cancel button */
    gnc_search_dialog_show_close_cancel (sw);
}
 
 
/* TEST CODE BELOW HERE */
 
static GList *
get_params_list (QofIdTypeConst type)
{
    GList *list = NULL;
 
    list = gnc_search_param_prepend (list, "Txn: All Accounts",
                                     ACCOUNT_MATCH_ALL_TYPE,
                                     type, SPLIT_TRANS, TRANS_SPLITLIST,
                                     SPLIT_ACCOUNT_GUID, NULL);
    list = gnc_search_param_prepend (list, "Split Account", GNC_ID_ACCOUNT,
                                     type, SPLIT_ACCOUNT, QOF_PARAM_GUID,
                                     NULL);
    list = gnc_search_param_prepend (list, "Split->Txn->Void?", NULL, type,
                                     SPLIT_TRANS, TRANS_VOID_STATUS, NULL);
    list = gnc_search_param_prepend (list, "Split Int64", NULL, type,
                                     "d-share-int64", NULL);
    list = gnc_search_param_prepend (list, "Split Amount (double)", NULL, type,
                                     "d-share-amount", NULL);
    list = gnc_search_param_prepend (list, "Split Value (debcred)", NULL, type,
                                     SPLIT_VALUE, NULL);
    list = gnc_search_param_prepend (list, "Split Amount (numeric)", NULL, type,
                                     SPLIT_AMOUNT, NULL);
    list = gnc_search_param_prepend (list, "Date Reconciled (date)", NULL, type,
                                     SPLIT_DATE_RECONCILED, NULL);
    list = gnc_search_param_prepend (list, "Split Memo (string)", NULL, type,
                                     SPLIT_MEMO, NULL);
 
    return list;
}
 
static GList *
get_display_list (QofIdTypeConst type)
{
    GList *list = NULL;
 
    list = gnc_search_param_prepend (list, "Amount", NULL, type, SPLIT_AMOUNT,
                                     NULL);
    list = gnc_search_param_prepend (list, "Memo", NULL, type, SPLIT_MEMO, NULL);
    list = gnc_search_param_prepend (list, "Date", NULL, type, SPLIT_TRANS,
                                     TRANS_DATE_POSTED, NULL);
 
    return list;
}
 
 
static void
do_nothing (GtkWindow *dialog, gpointer *a, gpointer b)
{
    return;
}
 
void
gnc_search_dialog_test (void)
{
    static GList *params = NULL;
    static GList *display = NULL;
    static GNCSearchCallbackButton buttons[] =
    {
        /* Don't mark these as translatable since these are only test strings! */
        { ("View Split"), do_nothing, NULL, TRUE },
        { ("New Split"), do_nothing, NULL, TRUE },
        { ("Do Something"), do_nothing, NULL, TRUE },
        { ("Do Nothing"), do_nothing, NULL, TRUE },
        { ("Who Cares?"), do_nothing, NULL, FALSE },
        { NULL }
    };
 
    if (params == NULL)
        params = get_params_list (GNC_ID_SPLIT);
 
    if (display == NULL)
        display = get_display_list (GNC_ID_SPLIT);
 
/* FIXME: All this does is leak. */
    gnc_search_dialog_create (NULL, GNC_ID_SPLIT,
                  _("Find Transaction"),
                  params, display,
                  NULL, NULL, buttons, NULL, NULL, NULL, NULL,
                  NULL, NULL, NULL);
}