root/trunk/src/tmut-shell-window.c

/* TMut
 * Copyright (C) 2006-2007 Philip Van Hoof <pvanhoof@gnome.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with self library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */


#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <glib/gi18n-lib.h>

#include "tmut-shell-window.h"

static GObjectClass *parent_class = NULL;

typedef struct _TMutShellWindowPriv TMutShellWindowPriv;

typedef struct {
        TMutShellChild *child;
        const gchar *instruction;
} ChildSet;

struct _TMutShellWindowPriv {
        GtkWidget *vbox; 
        GtkLabel *instruction_label;
        GtkProgressBar *progress_bar;
        GList *childs;
        ChildSet *current;
};

#define TMUT_SHELL_WINDOW_GET_PRIVATE(o) \
        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TMUT_TYPE_SHELL_WINDOW, TMutShellWindowPriv))


static void 
tmut_shell_window_set_child_default (TMutShellWindow *self, TMutShellChild *child, const gchar *instruction)
{
        TMutShellWindowPriv *priv = TMUT_SHELL_WINDOW_GET_PRIVATE (self);
        ChildSet *set = g_slice_new0 (ChildSet);

        if (priv->current && priv->current->child)
                gtk_container_remove (GTK_CONTAINER (priv->vbox), GTK_WIDGET (priv->current->child));

        set->child = g_object_ref (child);
        set->instruction = instruction;

        priv->childs = g_list_prepend (priv->childs, set); /* A */
        priv->current = set; 

        gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (set->child), 
                TRUE, TRUE, 0);

        if (set->instruction) {
                gtk_label_set_text (priv->instruction_label, set->instruction);
                gtk_widget_show (GTK_WIDGET (priv->instruction_label));
        } else
                gtk_widget_hide (GTK_WIDGET (priv->instruction_label));

        tmut_shell_child_set_window (set->child, self);

        return;
}


static void
tmut_shell_window_back_default (TMutShellWindow *self)
{
        TMutShellWindowPriv *priv = TMUT_SHELL_WINDOW_GET_PRIVATE (self);
        GList *first = NULL;
        gint cnt = g_list_length (priv->childs);

        if (cnt > 1) 
        {
                if (priv->current && priv->current->child) {
                        gtk_container_remove (GTK_CONTAINER (priv->vbox), GTK_WIDGET (priv->current->child));
                        if (G_IS_OBJECT (priv->current->child))
                                g_object_unref (priv->current->child); /* A */
                }
                priv->childs = g_list_remove (priv->childs, priv->current);

                first = g_list_first (priv->childs);
                
                g_slice_free (ChildSet, priv->current);
                priv->current = first->data;
                gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->current->child), 
                        TRUE, TRUE, 0);

                if (priv->current->instruction) {
                        gtk_label_set_text (priv->instruction_label, priv->current->instruction);
                        gtk_widget_show (GTK_WIDGET (priv->instruction_label));
                } else
                        gtk_widget_hide (GTK_WIDGET (priv->instruction_label));

                }
}

static void 
on_back_clicked (GtkButton *button, gpointer user_data)
{
        tmut_shell_window_back ((TMutShellWindow *) user_data);
        return;
}


/**
 * tmut_shell_window_new:
 * Create a GtkWindow that implements #TnyShellWindow
 *
 * Return value: a new #TnyShellWindow instance implemented for Gtk+
 **/
TMutShellWindow *
tmut_shell_window_new (void)
{
        TMutShellWindow *self = g_object_new (TMUT_TYPE_SHELL_WINDOW, NULL);

        return TMUT_SHELL_WINDOW (self);
}


static GtkProgress* 
tmut_shell_window_get_progress_default (TMutShellWindow *self)
{
        TMutShellWindowPriv *priv = TMUT_SHELL_WINDOW_GET_PRIVATE (self);

        return GTK_PROGRESS (priv->progress_bar);
}


static void 
tmut_shell_window_instantiate_default (TMutShellWindow *instance)
{
        TMutShellWindowPriv *priv = TMUT_SHELL_WINDOW_GET_PRIVATE (instance);

        GtkWidget *hbox, *vvbox, *back_button;

        priv->vbox = gtk_vbox_new (FALSE, 0);
        hbox = gtk_hbox_new (FALSE, 0);
        vvbox = gtk_vbox_new (FALSE, 0);
        back_button = gtk_button_new_with_label (_("<"));
        priv->progress_bar = GTK_PROGRESS_BAR (gtk_progress_bar_new ());
        priv->instruction_label = GTK_LABEL (gtk_label_new (""));

        gtk_widget_show (GTK_WIDGET (priv->progress_bar));
        gtk_widget_show (back_button);
        gtk_widget_hide (GTK_WIDGET (priv->instruction_label));
        gtk_widget_show (priv->vbox);
        gtk_widget_show (hbox);
        gtk_widget_show (vvbox);

        gtk_misc_set_alignment (GTK_MISC (priv->instruction_label), 0, 0);

        gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (hbox), 
                FALSE, FALSE, 0);
        gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (vvbox), 
                TRUE, TRUE, 0);
        gtk_box_pack_start (GTK_BOX (vvbox), GTK_WIDGET (priv->progress_bar), 
                TRUE, TRUE, 0);
        gtk_box_pack_start (GTK_BOX (vvbox), GTK_WIDGET (priv->instruction_label), 
                FALSE, FALSE, 0);
        gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (back_button), 
                FALSE, FALSE, 0);

        gtk_container_add (GTK_CONTAINER (instance), GTK_WIDGET (priv->vbox));

        g_signal_connect (G_OBJECT (back_button), "clicked", 
                G_CALLBACK (on_back_clicked), instance);
}

GtkProgress* 
tmut_shell_window_get_progress (TMutShellWindow *self)
{
        return TMUT_SHELL_WINDOW_GET_CLASS (self)->get_progress (self);
}

void 
tmut_shell_window_back (TMutShellWindow *self)
{
        TMUT_SHELL_WINDOW_GET_CLASS (self)->back (self);
        return;
}

void 
tmut_shell_window_set_child (TMutShellWindow *self, TMutShellChild *child, const gchar *instruction)
{
        TMUT_SHELL_WINDOW_GET_CLASS (self)->set_child (self, child, instruction);
        return;
}

static void
tmut_shell_window_instance_init (GTypeInstance *instance, gpointer g_class)
{
        if (TMUT_SHELL_WINDOW_GET_CLASS (instance)->instantiate)
                TMUT_SHELL_WINDOW_GET_CLASS (instance)->instantiate ((TMutShellWindow *) instance);

        return;
}

static void
foreach_childset (gpointer data, gpointer user_data)
{
        ChildSet *set = (ChildSet *) data;
        g_object_unref (set->child);
        g_slice_free (ChildSet, set);
        return;
}

static void
tmut_shell_window_finalize (GObject *object)
{
        TMutShellWindowPriv *priv = TMUT_SHELL_WINDOW_GET_PRIVATE (object);

        if (priv->childs) {
                g_list_foreach (priv->childs, foreach_childset, NULL);
                g_list_free (priv->childs);
                priv->childs = NULL;
        }

        (*parent_class->finalize) (object);

        return;
}


static void 
tmut_shell_window_class_init (TMutShellWindowClass *class)
{
        GObjectClass *object_class;

        parent_class = g_type_class_peek_parent (class);
        object_class = (GObjectClass*) class;

        class->back= tmut_shell_window_back_default;
        class->set_child= tmut_shell_window_set_child_default;
        class->get_progress= tmut_shell_window_get_progress_default;
        class->instantiate= tmut_shell_window_instantiate_default;

        object_class->finalize = tmut_shell_window_finalize;

        g_type_class_add_private (object_class, sizeof (TMutShellWindowPriv));

        return;
}

GType 
tmut_shell_window_get_type (void)
{
        static GType type = 0;

        if (G_UNLIKELY(type == 0))
        {
                static const GTypeInfo info = 
                {
                  sizeof (TMutShellWindowClass),
                  NULL,   /* base_init */
                  NULL,   /* base_finalize */
                  (GClassInitFunc) tmut_shell_window_class_init,   /* class_init */
                  NULL,   /* class_finalize */
                  NULL,   /* class_data */
                  sizeof (TMutShellWindow),
                  0,      /* n_preallocs */
                  tmut_shell_window_instance_init,    /* instance_init */
                  NULL
                };

                type = g_type_register_static (GTK_TYPE_WINDOW,
                        "TMutShellWindow",
                        &info, 0);
        }

        return type;
}