fe_gtk.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 <syslog.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <signal.h>
#include <string.h>
#include <errno.h>

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

#include "fe_gtk.h"
#include "fe_data.h"
#include "handlers.h"
#include "select_handlers.h"
#include "descriptions.h"
#include "progress.h"
#include "go.h"
#include "ui.h"
#ifdef DI_UDEB
# include "di.h"
#endif /* DI_UDEB */

char * fe_gtk_get_text(struct frontend * fe, const char * template,
                       const char * fallback)
{
    /* XXX: add macro? */
    struct question * question = fe->qdb->methods.get(fe->qdb, template);

    return question ? q_get_description(question) : g_strdup(fallback);
}

static void * handle_gtk_events(void * dummy)
{
    gdk_threads_enter();
    gtk_main();
    gdk_threads_leave();

    return NULL /* no one cares what value is returned */;
}

gboolean fe_gtk_is_first_question(struct question * question)
{
    struct question * crawl;

    crawl = question;

    while (NULL != crawl->prev) {
        if (0 != strcmp(crawl->prev->template->type, "note")) {
            return FALSE;
        }
        crawl = crawl->prev;
    }
    return TRUE;
}

/* documented in fe_gtk.h */
void fe_gtk_force_quit(struct frontend * fe)
{
    if (-1 == kill(0 /* myself */, SIGTERM)) {
        g_critical("kill failed: %s", strerror(errno));
    }
}

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

    if (NULL == fe_data) {
        return;
    }
    fe_gtk_progress_stop(fe);
    /* Exit any running GO in order to cleanup. */
    fe_gtk_set_answer_notok(fe);
    fe->data = NULL;
    if (NULL != fe_data->window) {
        g_object_unref(G_OBJECT(fe_data->window));
    }
    if (NULL != fe_data->title) {
        g_object_unref(G_OBJECT(fe_data->title));
    }
    if (NULL != fe_data->target_box) {
        g_object_unref(G_OBJECT(fe_data->target_box));
    }
    if (NULL != fe_data->action_box) {
        g_object_unref(G_OBJECT(fe_data->action_box));
    }
    /* There is no safe way to free the mutex: this function can be called
     * as part as a signal handler while the mutex is actually held in
     * go.c:wait_answer().
     */
    if (NULL == fe_data->plugins) {
        g_hash_table_destroy(fe_data->plugins);
    }
    g_free(fe_data);
}

static gboolean create_frontend_data(struct frontend * fe)
{
    struct frontend_data * fe_data;

    g_assert(NULL == fe->data);

    if (NULL == (fe->data = g_malloc0(sizeof (struct frontend_data)))) {
        g_critical("Unable to allocate frontend_data.");
        return FALSE;
    }

    fe_data = fe->data;

    if (NULL == (fe_data->answer_cond = g_cond_new())) {
        g_critical("g_cond_new failed.");
        goto failed;
    }
    if (NULL == (fe_data->answer_mutex = g_mutex_new())) {
        g_critical("g_mutex_new failed.");
        goto failed;
    }
    fe_data->plugins = g_hash_table_new_full(
        g_str_hash, g_str_equal, g_free /* key destroy function (strings) */,
        (GDestroyNotify) plugin_delete /* value destroy function (plugin) */);
    if (NULL == fe_data->plugins) {
        g_critical("g_hash_table_new_full failed.");
        goto failed;
    }

    fe->data = fe_data;

    return TRUE;

failed:
    destroy_frontend_data(fe);
    return FALSE;
}

static int fe_gtk_shutdown(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;

    if (NULL != fe_data->event_listener) {
        gtk_main_quit();
        if (g_thread_self() != fe_data->event_listener) {
            (void) g_thread_join(fe_data->event_listener);
        }
        fe_data->event_listener = NULL;
    }
    fe_gtk_destroy_main_window(fe);
#ifdef DI_UDEB
    fe_gtk_di_shutdown(fe);
#endif /* DI_UDEB */
    destroy_frontend_data(fe);

    return DC_OK;
}

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

    g_assert(NULL != fe_data->window);

    gtk_widget_show_all(fe_data->window);
}

/* documented in fe_gtk.h */
int fe_gtk_get_answer(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;
    int answer;

    g_mutex_lock(fe_data->answer_mutex); 
    answer = fe_data->answer;
    g_mutex_unlock(fe_data->answer_mutex);
    return answer;
}

/* documented in fe_gtk.h */
void fe_gtk_set_answer(struct frontend * fe, int answer)
{
    struct frontend_data * fe_data = fe->data;

    g_mutex_lock(fe_data->answer_mutex);
    fe_data->answer = answer;
    g_cond_broadcast(fe_data->answer_cond);
    g_mutex_unlock(fe_data->answer_mutex);
}

/* documented in fe_gtk.h */
void fe_gtk_set_answer_ok(struct frontend * fe)
{
    fe_gtk_set_answer(fe, DC_OK);
}

/* documented in fe_gtk.h */
void fe_gtk_set_answer_notok(struct frontend * fe)
{
    fe_gtk_set_answer(fe, DC_NOTOK);
}

/* documented in fe_gtk.h */
void fe_gtk_set_answer_goback(struct frontend * fe)
{
    fe_gtk_set_answer(fe, DC_GOBACK);
}

static gboolean create_event_listener_thread(struct frontend * fe)
{
    struct frontend_data * fe_data = fe->data;
    GError * error;

    g_assert(NULL == fe_data->event_listener);

    fe_data->event_listener = g_thread_create(
        (GThreadFunc) handle_gtk_events, NULL /* no data */,
        TRUE /* joinable thread */, &error);
    if (NULL == fe_data->event_listener) {
        g_critical("g_thread_create failed: %s", error->message);
        g_error_free(error);
        return FALSE;
    }
    return TRUE;
}

static int fe_gtk_initialize(struct frontend * fe, struct configuration * conf)
{
    /* INFO(INFO_DEBUG, "GTK_DI - gtk_initialize() called"); */
    if (!g_thread_supported()) {
       g_thread_init(NULL /* default thread functions */);
       gdk_threads_init();
    } else {
        g_critical("Threads not supported by th glib.");
        return DC_NOTOK;
    }
    gtk_init(NULL /* no argc */, NULL /* no argv */);

    if (!create_frontend_data(fe)) {
        g_critical("create_frontend_data failed.");
        goto failed;
    }
    if (!fe_gtk_create_main_window(fe)) {
        g_critical("fe_gtk_create_main_window failed.");
        goto failed;
    }
    fe->interactive = TRUE;

#ifdef DI_UDEB
    if (!fe_gtk_di_setup(fe)) {
        g_critical("fe_gtk_di_setup failed.");
        goto failed;
    }
#endif /* DI_UDEB */

    /* XXX: here? */
    show_main_window(fe);

    if (!create_event_listener_thread(fe)) {
        g_critical("create_event_listener_thread failed.");
        goto failed;
    }

    return DC_OK;

failed:
    fe_gtk_shutdown(fe);
    return DC_NOTOK;
}

static void fe_gtk_set_title(struct frontend * fe, const char * title)
{
    g_free(fe->title);
    fe->title = g_strdup(title);
#ifndef DI_UDEB /* Only for non d-i frontend */
    gdk_threads_enter();
    fe_gtk_update_frontend_title(fe);
    gdk_threads_leave();
#endif
}

static bool fe_gtk_can_go_back(struct frontend * fe,
                               struct question * question)
{
    return DCF_CAPB_BACKUP == (fe->capability & DCF_CAPB_BACKUP);
}

static unsigned long fe_gtk_query_capability(struct frontend * fe)
{
    return DCF_CAPB_BACKUP;
}

struct frontend_module debconf_frontend_module = {
    initialize: fe_gtk_initialize,
    shutdown: fe_gtk_shutdown,
    can_go_back: fe_gtk_can_go_back,
    query_capability: fe_gtk_query_capability,
    set_title: fe_gtk_set_title,
    /* see go.c */
    go: fe_gtk_go,
    /* see progress.c */
    can_cancel_progress: fe_gtk_can_cancel_progress,
    progress_start: fe_gtk_progress_start,
    progress_info: fe_gtk_progress_info,
    progress_set: fe_gtk_progress_set,
    progress_stop: fe_gtk_progress_stop,
};

/* vim: et sw=4 si
 */

---