choice_model.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 "choice_model.h"

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

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

struct search_result {
    const char * searched_value;

    GtkTreePath * path;
};

static gboolean is_searched_value(GtkTreeModel * model, GtkTreePath * path,
                                  GtkTreeIter * iter,
                                  struct search_result * result)
{
    char * value;

    gtk_tree_model_get(model, iter,
                       /* column: */ CHOICE_MODEL_VALUE, &value,
                       -1 /* end of list */);
    if (0 == strcmp(value, result->searched_value)) {
        result->path = gtk_tree_path_copy(path);
    }
    g_free(value);
    return NULL != result->path;
}

GtkTreePath * fe_gtk_choice_model_find_value(GtkTreeModel * model,
                                             const char * searched_value)
{
    struct search_result result;

    result.searched_value = searched_value;
    result.path = NULL;

    gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc) is_searched_value,
                           &result);
    return result.path;
}

GtkTreeModel * fe_gtk_choice_model_create_full(struct frontend * fe,
                                               struct question * question,
                                               parent_predicate is_parent)
{
    GtkTreeStore * store;
    int count;
    int sorted_count;
    char * raw_indices;
    char * raw_choices;
    char * raw_translated_choices;
    int * sorted_indices;
    char ** choice_values;
    char ** choice_translated_values;
    char ** default_values;
    int default_count;
    int i;
    GtkTreeIter iter;
    GtkTreeIter child;
    GtkTreePath * path;

    store = gtk_tree_store_new(CHOICE_MODEL_COLUMN_COUNT,
                               G_TYPE_BOOLEAN /* selected */,
                               G_TYPE_INT /* index */,
                               G_TYPE_STRING /* value */,
                               G_TYPE_STRING /* translated value */);
    if (NULL == store) {
        g_warning("gtk_tree_store_new failed.");
        return NULL;
    };
   
    raw_indices = q_get_indices(question);
    raw_choices = q_get_choices_vals(question);
    raw_translated_choices = q_get_choices(question);
    count = strgetargc(raw_choices);
    g_assert(0 < count);
    /* check NULLs! */
    sorted_indices = g_malloc0(count * sizeof (int));
    choice_values = g_malloc0(count * sizeof (char *));
    choice_translated_values = g_malloc0(count * sizeof (char *));
    default_values = g_malloc0(count * sizeof (char *));

    /* XXX: strchoicesplitsort interface is really nasty... :(
     *      Maybe it would be better to re-implement something with the nifty
     *      glib functions... */
    sorted_count = strchoicesplitsort(raw_choices, raw_translated_choices,
                                      raw_indices, choice_values,
                                      choice_translated_values,
                                      sorted_indices, count);
    g_assert(sorted_count == count);

    default_count = strchoicesplit(question_getvalue(question, ""),
                                   default_values, count);
    g_assert(0 <= default_count);

    /* Populate model */
    for (i = 0; i < count; i++) {
        if (NULL == is_parent ||
            is_parent(sorted_indices[i], choice_values[i],
                      choice_translated_values[i])) {
            gtk_tree_store_append(store, &iter, NULL /* no parent */);
            gtk_tree_store_set(
                store, &iter,
                /* column: */ CHOICE_MODEL_SELECTED, FALSE,
                /* column: */ CHOICE_MODEL_INDEX, sorted_indices[i],
                /* column: */ CHOICE_MODEL_VALUE, choice_values[i],
                /* column: */ CHOICE_MODEL_TRANSLATED_VALUE,
                              choice_translated_values[i],
                -1 /* end of list */);
        } else {
            gtk_tree_store_append(store, &child, &iter);
            gtk_tree_store_set(
                store, &child,
                /* column: */ CHOICE_MODEL_SELECTED, FALSE,
                /* column: */ CHOICE_MODEL_INDEX, sorted_indices[i],
                /* column: */ CHOICE_MODEL_VALUE, choice_values[i],
                /* column: */ CHOICE_MODEL_TRANSLATED_VALUE,
                              choice_translated_values[i],
                -1 /* end of list */);
        }
    }

    /* Mark defaults as selected */
    for (i = 0; i < default_count; i++) {
        if (NULL != (path = fe_gtk_choice_model_find_value(
                                GTK_TREE_MODEL(store), default_values[i]))) {
            if (gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path)) {
                gtk_tree_store_set(store, &iter,
                                   /* column: */ CHOICE_MODEL_SELECTED, TRUE,
                                   -1 /* end of list */);
            }
            gtk_tree_path_free(path);
        }
    }

    g_free(sorted_indices);
    g_free(choice_values);
    g_free(choice_translated_values);
    g_free(raw_translated_choices);
    g_free(raw_choices);
    g_free(raw_indices);
    return GTK_TREE_MODEL(store);
}

GtkTreeModel * fe_gtk_choice_model_create(struct frontend * fe,
                                          struct question * question)
{
    return fe_gtk_choice_model_create_full(
        fe, question, NULL /* no parent predicate */);
}

static gboolean increment_model_length(GtkTreeModel * model,
                                       GtkTreePath * path,
                                       GtkTreeIter * iter, guint * length)
{
    *length = *length + 1;
    return FALSE; /* foreach should go on */
}

guint fe_gtk_choice_model_get_length(GtkTreeModel * model)
{
    guint length = 0;

    g_assert(NULL != model);

    gtk_tree_model_foreach(
        model, (GtkTreeModelForeachFunc) increment_model_length, &length);
    return length;
}

static gboolean is_selected(GtkTreeModel * model, GtkTreePath * path,
                            GtkTreeIter * iter, GtkTreePath ** result)
{
    gboolean selected;

    gtk_tree_model_get(model, iter,
                       /* column: */ CHOICE_MODEL_SELECTED, &selected,
                       -1 /* end of list */);
    if (selected) {
        *result = gtk_tree_path_copy(path);
        return TRUE /* stop here */;
    }
    return FALSE;
}

GtkTreePath * fe_gtk_choice_model_get_first_selected(GtkTreeModel * model)
{
    GtkTreePath * result = NULL;
  
    gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc) is_selected,
                           &result);
    return result;
}

void fe_gtk_choice_model_set(GtkTreeModel * model, GtkTreeIter * iter, ...)
{
    va_list var_args;

    va_start(var_args, iter);
    gtk_tree_store_set_valist(GTK_TREE_STORE(model), iter, var_args);
    va_end(var_args);
}

/* vim: et sw=4 si
 */

---