select_handlers.c

Go to the documentation of this file.

/*****************************************************************************
 *
 * cdebconf - An implementation of the Debian Configuration Management
 *            System
 *
 * $Id$
 *
 * cdebconf is (c) 2000-2007 Randolph Chung and others under the following
 * license.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *****************************************************************************/

#include "select_handlers.h"

#include <string.h>
#include <gtk/gtk.h>

#include "frontend.h"
#include "question.h"

#include "fe_gtk.h"
#include "fe_data.h"
#include "descriptions.h"
#include "choice_model.h"
#include "ui.h"

static void set_value_from_combo(struct question * question,
                                 GtkComboBox * combo_box)
{
    GtkTreeModel * model;
    GtkTreeIter iter;
    char * value;

    if (gtk_combo_box_get_active_iter(combo_box, &iter)) {
        model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo_box));
        gtk_tree_model_get(model, &iter,
                           /* column: */ CHOICE_MODEL_VALUE, &value,
                           -1 /* end of list */);
        question_setvalue(question, value);
        g_free(value);
    } else {
        question_setvalue(question, "");
    }
}

static void set_value_from_select(struct question * question,
                                  GtkTreeView * view)
{
    GtkTreeSelection * selection;
    GtkTreeModel * model;
    GtkTreeIter iter;
    char * value;
    
    selection = gtk_tree_view_get_selection(view);
    if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
        gtk_tree_model_get(model, &iter,
                           /* column: */ CHOICE_MODEL_VALUE, &value,
                           -1 /* end of list */);
        question_setvalue(question, value);
        g_free(value);
    } else {
        question_setvalue(question, "");
    }
}

static gboolean is_country(int index, const char * choice,
                           const char * choice_translated)
{
    return '-' == choice_translated[0] && '-' == choice_translated[1];
}

static gboolean is_disk(int index, const char * choice,
                        const char * choice_translated)
{
    return NULL == strstr(choice_translated, "    ");
}

static const struct {
    const char * tag;
    parent_predicate parent_predicate;
} special_questions[] = {
    { "countrychooser/country-name", is_country },
    { "partman/choose_partition", is_disk },
    { NULL, NULL }
};

static parent_predicate get_special_predicate(const char * tag) {
    int i;

    for (i = 0; NULL != special_questions[i].tag; i++) {
        if (0 == strcmp(tag, special_questions[i].tag)) {
            return special_questions[i].parent_predicate;
        }
    }
    return NULL;
}

static int create_select_list(struct frontend * fe, struct question * question,
                              GtkWidget * question_box, GtkTreeModel * model)
{
    GtkTreePath * path = NULL;
    GtkWidget * view;
    GtkWidget * scroll;
    GtkWidget * frame;
    GtkCellRenderer * text_renderer;
    char * description;

    model = fe_gtk_choice_model_create_full(
        fe, question, get_special_predicate(question->tag));
    if (NULL == model) {
        g_warning("create_model_from_choices failed.");
        return DC_NOTOK;
    }

    /* INFO(INFO_DEBUG, "GTK_DI - gtkhandler_select_single_list() called"); */

    /* check NULL! */
    view = gtk_tree_view_new_with_model(model);

    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view),
                                      FALSE /* no headers */);
    gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view),
                                    TRUE /* enable typeahead */);
    gtk_tree_selection_set_mode(
        gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
        GTK_SELECTION_BROWSE);

    description = q_get_description(question);
    text_renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_insert_column_with_attributes(
        GTK_TREE_VIEW(view), -1 /* insert at the end */,
        description /* title */, text_renderer,
        "text", CHOICE_MODEL_TRANSLATED_VALUE,
        NULL /* end of attribute list */);
    g_free(description);

    g_signal_connect_swapped(G_OBJECT(view), "row-activated",
                             G_CALLBACK(fe_gtk_set_answer_ok), fe);

    path = fe_gtk_choice_model_get_first_selected(model);
    /* Select first row if there is no other default */
    if (NULL == path) {
        path = gtk_tree_path_new_first();
    } else {
        /* Only expand path when there was a previous selection. */
        gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), path);
    } 
    /* XXX: test if we really need to scroll if we set cursor */
    gtk_tree_view_scroll_to_cell(
        GTK_TREE_VIEW(view), path,
        NULL /* don't scroll to a particular column */,
        TRUE /* please align */,
        0.5 /* center row */,
        0 /* left column */);
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path,
                             NULL /* don't focus a particular column */,
                             FALSE /* don't start editing */);
    gtk_tree_path_free(path);

    scroll = gtk_scrolled_window_new(NULL /* create horizontal adjustement */,
                                     NULL /* create vertical adjustement */);
    gtk_container_add(GTK_CONTAINER(scroll), view);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    frame = gtk_frame_new(NULL);
    gtk_container_add(GTK_CONTAINER(frame), scroll);

    fe_gtk_add_common_layout(fe, question, question_box, frame);

    gtk_widget_grab_focus(view);

    fe_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_select),
                           question, view);

    return DC_OK;
}

static void update_selection_for_toggle(GtkCellRendererToggle * cell,
                                        const gchar * path_string,
                                        GtkTreeModel * model)
{
    GtkTreeIter iter;
    gboolean value;

    if (gtk_tree_model_get_iter_from_string(model, &iter, path_string)) {
        gtk_tree_model_get(model, &iter,
                           /* column: */ CHOICE_MODEL_SELECTED, &value,
                           -1 /* end of list */);
        value ^= TRUE;
        fe_gtk_choice_model_set(model, &iter,
                                /* column: */ CHOICE_MODEL_SELECTED, value,
                                -1 /* end of list */);
    }
}

static void set_value_from_multiselect(struct question * question,
                                       GtkTreeModel * model)
{
    GtkTreeIter iter;
    gboolean valid;
    gboolean selected;
    gchar ** selected_values;
    guint selected_index;
    gchar * result;

    /* check NULL! */
    selected_values = g_malloc0(
        sizeof (char *) * (1 /* terminating NULL */ +
                           fe_gtk_choice_model_get_length(model)));
    selected_index = 0;
    valid = gtk_tree_model_get_iter_first(model, &iter);
    while (valid) {
        gtk_tree_model_get(model, &iter,
                           /* column: */ CHOICE_MODEL_SELECTED, &selected,
                           -1 /* end of list */);
        if (selected) {
            gtk_tree_model_get(model, &iter,
                               /* column: */ CHOICE_MODEL_VALUE,
                                             &selected_values[selected_index],
                               -1 /* end of list */);
            selected_index++;
        }
        valid = gtk_tree_model_iter_next(model, &iter);
    }
    if (0 < selected_index) {
        result = g_strjoinv(", ", selected_values);
    } else {
        /* no selections */
        result = g_strdup("");
    }
    question_setvalue(question, result);
    g_free(result);

    for (selected_index = 0; NULL != selected_values[selected_index];
         selected_index++) {
        g_free(selected_values[selected_index]);
    }
    g_free(selected_values);
}

static void update_model_from_toggle_button(
    GtkToggleButton * toggle_button, GtkTreeRowReference * row_reference)
{
    GtkTreeModel * model = gtk_tree_row_reference_get_model(row_reference);
    GtkTreePath * path = gtk_tree_row_reference_get_path(row_reference);
    GtkTreeIter iter;

    g_assert(NULL != model);
    g_assert(NULL != path);

    if (gtk_tree_model_get_iter(model, &iter, path)) {
        gtk_list_store_set(
            GTK_LIST_STORE(model), &iter,
            /* column: */ CHOICE_MODEL_SELECTED,
                          gtk_toggle_button_get_active(toggle_button),
            -1 /* end of list */);
    }
}

static gulong connect_signal_to_row(GObject * object, const gchar * signal,
                                    GtkTreeModel * model, GtkTreeIter * iter,
                                    GCallback handler)
{
    GtkTreePath * path;
    GtkTreeRowReference * row_reference;

    path = gtk_tree_model_get_path(model, iter);
    row_reference = gtk_tree_row_reference_new(model, path);
    gtk_tree_path_free(path);
    return g_signal_connect_data(object, "toggled", handler, row_reference,
                                 (GClosureNotify) gtk_tree_row_reference_free,
                                 0 /* no connect options */);
}

static int create_multiselect_list(struct frontend * fe,
                                   struct question * question,
                                   GtkWidget * question_box,
                                   GtkTreeModel * model) 
{
    GtkTreeIter iter;
    GtkWidget * view;
    GtkWidget * scroll;
    GtkWidget * frame;
    GtkCellRenderer * toggle_renderer;
    GtkCellRenderer * text_renderer;
    GtkTreePath * path;

    view = gtk_tree_view_new_with_model(model);

    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);

    toggle_renderer = gtk_cell_renderer_toggle_new();
    g_signal_connect(G_OBJECT(toggle_renderer), "toggled",
                     G_CALLBACK(update_selection_for_toggle), model);
    gtk_tree_view_insert_column_with_attributes(
        GTK_TREE_VIEW(view), -1 /* insert at the end */,
        NULL /* no title */, toggle_renderer,
        "active", CHOICE_MODEL_SELECTED,
        NULL /* end of attribute list */);

    text_renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_insert_column_with_attributes(
        GTK_TREE_VIEW(view), -1 /* insert at the end */,
        NULL /* no title */, text_renderer,
        /* column: */ "text", CHOICE_MODEL_TRANSLATED_VALUE,
        NULL /* end of list */);

    /* select the first row */
    gtk_tree_model_get_iter_first(model, &iter);
    path = gtk_tree_model_get_path(model, &iter);
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path,
                             NULL /* don't focus on a particular column */,
                             FALSE /* do not start editing */);
    gtk_tree_path_free(path);

    scroll = gtk_scrolled_window_new(NULL /* create horizontal adjustement */,
                                     NULL /* create vertical adjustement */);
    gtk_container_add(GTK_CONTAINER(scroll), view);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    frame = gtk_frame_new(NULL /* no label */);
    gtk_container_add(GTK_CONTAINER(frame), scroll);

    fe_gtk_add_common_layout(fe, question, question_box, frame);
    gtk_widget_grab_focus(view);

    fe_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_multiselect),
                           question, model);
    return DC_OK;
}

static void focus_first_child(GtkContainer * container)
{
    GList * children;

    children = gtk_container_get_children(container);
    gtk_widget_grab_focus(GTK_WIDGET(children->data));
    g_list_free(children);
}

static int create_multiselect_checkboxes(struct frontend * fe,
                                         struct question * question,
                                         GtkWidget * question_box,
                                         GtkTreeModel * model)
{
    GtkWidget * check_container;
    GtkWidget * check;
    GtkTreeIter iter;
    gboolean valid;
    gchar * label;
    gboolean selected;
    
    /* XXX: should we return DC_OK? */
    g_assert(0 < fe_gtk_choice_model_get_length(model));

    check_container = gtk_vbox_new(FALSE /* don't make children equal */,
                                   0 /* padding */);

    valid = gtk_tree_model_get_iter_first(model, &iter);
    while (valid) {
        gtk_tree_model_get(model, &iter,
                           /* column: */ CHOICE_MODEL_TRANSLATED_VALUE, &label,
                           /* column: */ CHOICE_MODEL_SELECTED, &selected,
                           -1 /* end of list */);

        check = gtk_check_button_new_with_label(label);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), selected);

        connect_signal_to_row(G_OBJECT(check), "toggled", model, &iter,
                              G_CALLBACK(update_model_from_toggle_button));

        gtk_box_pack_start(GTK_BOX(check_container), check,
                           FALSE /* don't expand */, FALSE /* don't fill */,
                           0 /* padding */);

        g_free(label);
        valid = gtk_tree_model_iter_next(model, &iter);
    }
    
    fe_gtk_add_common_layout(fe, question, question_box, check_container);

    if (fe_gtk_is_first_question(question)) {
        focus_first_child(GTK_CONTAINER(check_container));
    }

    fe_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_multiselect),
                           question, model);

    return DC_OK;
}

static void set_selected_active(GtkWidget * combo_box, GtkTreeModel * model)
{
    GtkTreePath * path;
    GtkTreeIter iter;
    gboolean valid;

    path = fe_gtk_choice_model_get_first_selected(model);
    if (NULL != path) {
        valid = gtk_tree_model_get_iter(model, &iter, path);
        if (valid) {
            gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo_box), &iter);
        }
        gtk_tree_path_free(path);
    }
}

static int create_select_combo(struct frontend * fe,
                               struct question * question,
                               GtkWidget * question_box,
                               GtkTreeModel * model)
{
    GtkWidget * combo_box;
    GtkCellRenderer * text_renderer;

    /* XXX: check NULL! */
    combo_box = gtk_combo_box_new_with_model(model);
    /* XXX: check NULL! */
    text_renderer = gtk_cell_renderer_text_new();
    gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), text_renderer,
                               TRUE /* expand */);
    gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), text_renderer,
                                   "text", CHOICE_MODEL_TRANSLATED_VALUE,
                                   NULL /* end of list */);
    set_selected_active(combo_box, model);

    fe_gtk_add_common_layout(fe, question, question_box, combo_box);

    if (fe_gtk_is_first_question(question)) {
        gtk_widget_grab_focus(combo_box);
    }

    fe_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_combo),
                           question, combo_box);

    return DC_OK;
}

static int handle_all(struct frontend * fe, struct question * question,
                      GtkWidget * question_box, gboolean multiselect)
{
    GtkTreeModel * model;

    if (NULL == (model = fe_gtk_choice_model_create(fe, question))) {
        g_warning("create_model_from_choices failed.");
        return DC_NOTOK;
    }

    if (multiselect && IS_QUESTION_SINGLE(question)) {
        return create_multiselect_list(fe, question, question_box, model);
    }
    if (multiselect) {
        return create_multiselect_checkboxes(fe, question, question_box,
                                             model);
    }
    if (IS_QUESTION_SINGLE(question)) {
        return create_select_list(fe, question, question_box, model);
    }
    return create_select_combo(fe, question, question_box, model);
}

int fe_gtk_handle_select(struct frontend * fe, struct question * question,
                         GtkWidget * question_box)
{
    return handle_all(fe, question, question_box, FALSE /* simple select */);
}

int fe_gtk_handle_multiselect(struct frontend * fe, struct question * question,
                              GtkWidget * question_box)
{
    return handle_all(fe, question, question_box, TRUE /* multiselect */);
}

/* vim: et sw=4 si
 */ 

---