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

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

#include "frontend.h"
#include "question.h"
#include "template.h"
#include "plugin.h"
#include "database.h"

#include "fe_gtk.h"
#include "fe_data.h"
#include "ui.h"
#include "handlers.h"
#include "select_handlers.h"
#include "progress.h"
#ifdef DI_UDEB
# include "di.h"
#endif

struct setter {
    setter_function func;

    struct question * question;

    void * user_data;

    struct setter * next;
};

void fe_gtk_register_setter(struct frontend * fe, setter_function func,
                            struct question * question, void * user_data)
{
    struct frontend_data * fe_data = fe->data;
    struct setter * setter;

    /* check NULL! */
    setter = g_malloc0(sizeof (struct setter));
    setter->func = func;
    setter->question = question;
    setter->user_data = user_data;
    setter->next = fe_data->setters;
    fe_data->setters = setter;
}

static void call_setters(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;
    struct setter * setter;

    setter = fe_data->setters;
    while (NULL != setter) {
        (*setter->func)(setter->question, setter->user_data);
        setter = setter->next;
    }
}

static void free_setters(struct frontend_data * fe_data)
{
    struct setter * setter;
    struct setter * previous;

    setter = fe_data->setters;
    while (NULL != setter) {
        previous = setter;
        setter = setter->next;
        g_free(previous);
    }
    fe_data->setters = NULL;
}

static gboolean handle_goback_key(GtkWidget * widget, GdkEventKey * key,
                                  struct frontend * fe)
{
    if (GDK_Escape == key->keyval) {
        fe_gtk_set_answer_goback(fe);
        return TRUE;
    }
    return FALSE;
}

static void create_goback_button(struct frontend * fe)
{
    GtkWidget * button;
    char * label;

    label = fe_gtk_get_text(fe, "debconf/button-goback", "Go Back");
    /* XXX: check NULL! */
    button = gtk_button_new_with_label(label);
    g_free(label);

    g_signal_connect_swapped(G_OBJECT(button), "clicked",
                             G_CALLBACK(fe_gtk_set_answer_goback), fe);

    fe_gtk_add_button(fe, button);
    fe_gtk_set_button_secondary(fe, button, TRUE);
    fe_gtk_add_global_key_handler(fe, button, G_CALLBACK(handle_goback_key));
}

/* documented in fe_gtk.h */
GtkWidget * fe_gtk_create_continue_button(struct frontend * fe)
{
    GtkWidget * button;
    char * label;

    /* XXX: check NULL! */
    label = fe_gtk_get_text(fe, "debconf/button-continue", "Continue");
    button = gtk_button_new_with_label(label);
    g_free(label);

    g_signal_connect_swapped(G_OBJECT(button), "clicked",
                             G_CALLBACK(fe_gtk_set_answer_ok), fe);
    fe_gtk_add_button(fe, button);
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_widget_grab_default(GTK_WIDGET(button));

    return button;
}

static void create_default_buttons_if_needed(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;
    GtkContainer * action_box = GTK_CONTAINER(fe_data->action_box);

    if (NULL == gtk_container_get_children(action_box)) {
        (void) fe_gtk_create_continue_button(fe);
    }
}

static void destroy_buttons(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;
    GtkContainer * action_box = GTK_CONTAINER(fe_data->action_box);

    gtk_container_foreach(action_box, (GtkCallback) gtk_widget_destroy,
                          NULL /* no user_data */);
}

static const struct {
    const char * type;
    fe_gtk_handler handler;
} question_handlers[] = {
    { "boolean",        fe_gtk_handle_boolean },
    { "multiselect",    fe_gtk_handle_multiselect },
    { "note",           fe_gtk_handle_note },
    { "password",       fe_gtk_handle_password },
    { "select",         fe_gtk_handle_select },
    { "string",         fe_gtk_handle_string },
    { "error",          fe_gtk_handle_note },
    { "text",           fe_gtk_handle_text },
    { "",               NULL },
};

static fe_gtk_handler find_internal_handler(const char * type)
{
    int i;

    for (i = 0; NULL != question_handlers[i].handler; i++) {
        if (0 == strcmp(type, question_handlers[i].type)) {
            return question_handlers[i].handler;
        }
    }
    return NULL;
}

static fe_gtk_handler find_external_handler(struct frontend * fe,
                                            const char * type)
{
    struct frontend_data * fe_data = fe->data;
    struct plugin * plugin;

    /* Look in already loaded plugins first. */
    plugin = g_hash_table_lookup(fe_data->plugins, type);
    if (NULL == plugin) {
        /* Load if available */
        if (NULL == (plugin = plugin_find(fe, type))) {
            g_warning("No plugin for %s", type);
            return NULL;
        }
        /* Save for later use */
        g_hash_table_insert(fe_data->plugins, g_strdup(type), plugin);
    }
    return (fe_gtk_handler) plugin->handler;
}

static void update_question_database(struct frontend * fe)
{
    struct question * question;

    question = fe->questions;
    while (NULL != question) {
        fe->qdb->methods.set(fe->qdb, question);
        question = question->next;
    }
}

static gboolean call_question_handlers(struct frontend * fe,
                                       GtkWidget * question_box)
{
    struct question * question;
    fe_gtk_handler handler;

    question = fe->questions;
    while (NULL != question) {
        handler = find_internal_handler(question->template->type);
        if (NULL == handler) {
            handler = find_external_handler(fe, question->template->type);
        }
        if (NULL == handler) {
            return FALSE;
        }
        if (DC_OK != handler(fe, question, question_box)) {
            g_warning("tag \"%s\" failed to display!", question->tag);
            /* XXX: return FALSE? */
        }
        question = question->next;
    }
    return TRUE;
}

static GtkWidget * create_question_box(struct frontend * fe,
                                       GtkWidget * container)
{
    GtkWidget * question_box;
    GtkWidget * question_box_scroll = NULL;

    /* check NULL! */
    question_box = gtk_vbox_new(FALSE /* don't make children equal */,
                                0 /* padding */);

    if (IS_QUESTION_SINGLE(fe->questions)) {
        gtk_box_pack_start(GTK_BOX(container), question_box,
                           TRUE /* expand */, TRUE /* fill */,
                           0 /* padding */);
    } else {
        question_box_scroll = gtk_scrolled_window_new(
            NULL /* create horizontal adjustement */,
            NULL /* create vertical adjustement */);
        gtk_scrolled_window_add_with_viewport(
            GTK_SCROLLED_WINDOW(question_box_scroll), question_box);
        gtk_scrolled_window_set_policy(
            GTK_SCROLLED_WINDOW(question_box_scroll),
            GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_set_shadow_type(
            GTK_SCROLLED_WINDOW(question_box_scroll), GTK_SHADOW_NONE);
        gtk_box_pack_start(GTK_BOX(container), question_box_scroll,
                           TRUE /* expand */, TRUE /* fill */,
                           DEFAULT_PADDING);
    }
    return question_box;
}

static void wait_answer(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;

    g_mutex_lock(fe_data->answer_mutex);
    while (DC_NO_ANSWER == fe_data->answer) {
        g_cond_wait(fe_data->answer_cond, fe_data->answer_mutex);
    }
    g_mutex_unlock(fe_data->answer_mutex);
}

int fe_gtk_go(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;
    GtkWidget * question_box;

    if (NULL == fe->questions) {
        return DC_OK;
    }

    fe_gtk_set_answer(fe, DC_NO_ANSWER);

    gdk_threads_enter();
#ifdef DI_UDEB
    /* XXX: rename */
    fe_gtk_di_run_dialog(fe);
#endif /* DI_UDEB */
    if (NULL != fe_data->progress_data) {
        fe_gtk_hide_progress(fe);
    }
    question_box = create_question_box(fe, fe_data->target_box);
    if (!call_question_handlers(fe, question_box)) {
        /* an handler was missing */
        fe_gtk_set_answer(fe, DC_NOTIMPL);
        goto end;
    }
    create_default_buttons_if_needed(fe);
    if (CAN_GO_BACK(fe)) {
        create_goback_button(fe);
    }
    fe_gtk_show_target_box(fe);
    fe_gtk_show_buttons(fe);
    gdk_threads_leave();

    /* frontend blocked here until a button has been pressed */
    wait_answer(fe);

    if (DC_NOTOK == fe_data->answer) {
        goto end;
    }

    gdk_threads_enter();
    fe_gtk_set_buttons_sensitive(fe, FALSE);
    if (DC_OK == fe_data->answer) {
        call_setters(fe);
        update_question_database(fe);
    }
    fe_gtk_empty_target_box(fe);
    destroy_buttons(fe);
    gdk_threads_leave();

end:
    free_setters(fe_data);
    return fe_data->answer;
}


/* vim: et sw=4 si
 */

---