git.maemo.org Git - hildon/blob - hildon-widgets/hildon-wizard-dialog.c

   1 /*
   2  * This file is part of hildon-libs
   3  *
   4  * Copyright (C) 2005 Nokia Corporation.
   5  *
   6  * Contact: Luc Pionchon <luc.pionchon@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 #include <gtk/gtkdialog.h>
  26 #include <gtk/gtknotebook.h>
  27 #include <gtk/gtkimage.h>
  28 #include <gtk/gtkbox.h>
  29 #include <gtk/gtkhbox.h>
  30 #include <gtk/gtkvbox.h>
  31 #include <gtk/gtkbutton.h>
  32 #include <hildon-widgets/hildon-defines.h>
  33
  34 #include "hildon-wizard-dialog.h"
  35
  36 #include <libintl.h>
  37
  38 #ifdef HAVE_CONFIG_H
  39 #include <config.h>
  40 #endif
  41
  42 #define _(String) dgettext(PACKAGE, String)
  43
  44 static GtkDialogClass *parent_class;
  45
  46 static void hildon_wizard_dialog_class_init(HildonWizardDialogClass *
  47                                             wizard_dialog_class);
  48 static void hildon_wizard_dialog_init(HildonWizardDialog * wizard_dialog);
  49 static void
  50 hildon_wizard_dialog_create_title(HildonWizardDialog * wizard_dialog);
  51 static void direction_button_clicked(GtkWidget *widget,
  52                                      HildonWizardDialog *wizard_dialog);
  53 static void hildon_wizard_dialog_set_property(GObject * object,
  54                                               guint property_id,
  55                                               const GValue * value,
  56                                               GParamSpec * pspec);
  57 static void hildon_wizard_dialog_get_property(GObject * object,
  58                                               guint property_id,
  59                                               GValue * value,
  60                                               GParamSpec * pspec);
  61 static void hildon_wizard_dialog_finalize(GObject * object);
  62
  63
  64 enum {
  65     PROP_WIZARD_NAME = 1,
  66     PROP_WIZARD_NOTEBOOK
  67 };
  68
  69 struct _HildonWizardDialogPrivate {
  70     gchar *wizard_name;
  71     GtkNotebook *notebook;
  72     GtkBox *box;
  73     GtkWidget *image;
  74     GtkWidget *previous_button;
  75     GtkWidget *next_button;
  76 };
  77
  78
  79 GType hildon_wizard_dialog_get_type(void)
  80 {
  81     static GType wizard_dialog_type = 0;
  82
  83     if (!wizard_dialog_type) {
  84         static const GTypeInfo wizard_dialog_info = {
  85             sizeof(HildonWizardDialogClass),
  86             NULL,       /* base_init */
  87             NULL,       /* base_finalize */
  88             (GClassInitFunc) hildon_wizard_dialog_class_init,
  89             NULL,       /* class_finalize */
  90             NULL,       /* class_data */
  91             sizeof(HildonWizardDialog),
  92             0,  /* n_preallocs */
  93             (GInstanceInitFunc) hildon_wizard_dialog_init,
  94         };
  95         wizard_dialog_type = g_type_register_static(GTK_TYPE_DIALOG,
  96                                                     "HildonWizardDialog",
  97                                                     &wizard_dialog_info,
  98                                                     0);
  99     }
 100     return wizard_dialog_type;
 101 }
 102
 103
 104 static void
 105 hildon_wizard_dialog_class_init(HildonWizardDialogClass *
 106                                 wizard_dialog_class)
 107 {
 108     GObjectClass *object_class = G_OBJECT_CLASS(wizard_dialog_class);
 109
 110     parent_class = g_type_class_peek_parent(wizard_dialog_class);
 111
 112     g_type_class_add_private(wizard_dialog_class,
 113                              sizeof(HildonWizardDialogPrivate));
 114
 115     object_class->set_property = hildon_wizard_dialog_set_property;
 116     object_class->get_property = hildon_wizard_dialog_get_property;
 117     object_class->finalize = hildon_wizard_dialog_finalize;
 118
 119     g_object_class_install_property(object_class, PROP_WIZARD_NAME,
 120         g_param_spec_string("wizard-name",
 121                             "Wizard Name",
 122                             "Set the HildonWizardDialog name",
 123                             NULL,
 124                             G_PARAM_READWRITE));
 125
 126     g_object_class_install_property(object_class, PROP_WIZARD_NOTEBOOK,
 127         g_param_spec_object("wizard-notebook",
 128                             "Wizard Notebook",
 129                             "Set the GtkNotebook to be used in the "
 130                               "HildonWizardDialog",
 131                             GTK_TYPE_NOTEBOOK, G_PARAM_READWRITE));
 132 }
 133
 134 static void hildon_wizard_dialog_finalize(GObject * object)
 135 {
 136     g_free(HILDON_WIZARD_DIALOG(object)->priv->wizard_name);
 137     if (G_OBJECT_CLASS(parent_class)->finalize)
 138         G_OBJECT_CLASS(parent_class)->finalize(object);
 139 }
 140
 141 static void hildon_wizard_dialog_init(HildonWizardDialog * wizard_dialog)
 142 {
 143     HildonWizardDialogPrivate *priv =
 144         G_TYPE_INSTANCE_GET_PRIVATE(wizard_dialog,
 145                                     HILDON_TYPE_WIZARD_DIALOG,
 146                                     HildonWizardDialogPrivate);
 147     GtkDialog *dialog = GTK_DIALOG(wizard_dialog);
 148     GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
 149
 150     gtk_dialog_set_has_separator(dialog, FALSE);
 151
 152     wizard_dialog->priv = priv;
 153     priv->box = GTK_BOX(gtk_hbox_new(FALSE, 0));
 154     priv->image = gtk_image_new_from_icon_name("qgn_widg_wizard",
 155                                                HILDON_ICON_SIZE_WIDG_WIZARD);
 156     priv->notebook = NULL;
 157     priv->wizard_name = NULL;
 158
 159     gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox),
 160                                 GTK_WIDGET(priv->box));
 161     gtk_box_pack_start_defaults(GTK_BOX(priv->box), GTK_WIDGET(vbox));
 162     gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(priv->image), FALSE, FALSE, 0);
 163
 164     gtk_dialog_add_button(dialog, _("Ecdg_bd_wizard_cancel"),
 165                           HILDON_WIZARD_DIALOG_CANCEL);
 166
 167     priv->previous_button =
 168         gtk_button_new_with_label(_("Ecdg_bd_wizard_previous"));
 169     gtk_box_pack_start(GTK_BOX(dialog->action_area),
 170                        priv->previous_button, FALSE, TRUE, 0);
 171
 172     g_signal_connect(priv->previous_button, "clicked",
 173                      G_CALLBACK(direction_button_clicked), wizard_dialog);
 174
 175     priv->next_button =
 176         gtk_button_new_with_label(_("Ecdg_bd_wizard_next"));
 177     gtk_box_pack_start(GTK_BOX(dialog->action_area),
 178                        priv->next_button, FALSE, TRUE, 0);
 179
 180     g_signal_connect(priv->next_button, "clicked",
 181                      G_CALLBACK(direction_button_clicked), wizard_dialog);
 182
 183     gtk_dialog_add_button(dialog, _("Ecdg_bd_wizard_finish"),
 184                           HILDON_WIZARD_DIALOG_FINISH);
 185
 186     gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard_dialog),
 187                                       HILDON_WIZARD_DIALOG_FINISH,
 188                                       FALSE);
 189     gtk_widget_set_sensitive(priv->previous_button, FALSE);
 190
 191     hildon_wizard_dialog_create_title(wizard_dialog);
 192 }
 193
 194
 195 static void
 196 hildon_wizard_dialog_set_property(GObject * object, guint property_id,
 197                                   const GValue * value, GParamSpec * pspec)
 198 {
 199     HildonWizardDialogPrivate *priv = HILDON_WIZARD_DIALOG(object)->priv;
 200
 201     switch (property_id) {
 202     case PROP_WIZARD_NAME:
 203         if (priv->wizard_name)
 204             g_free(priv->wizard_name);
 205         priv->wizard_name = g_strdup((gchar *) g_value_get_string(value));
 206         if (priv->notebook)
 207             hildon_wizard_dialog_create_title(HILDON_WIZARD_DIALOG
 208                                               (object));
 209         break;
 210     case PROP_WIZARD_NOTEBOOK:
 211         priv->notebook = GTK_NOTEBOOK(g_value_get_object(value));
 212         gtk_notebook_set_show_tabs(priv->notebook, FALSE);
 213         gtk_notebook_set_show_border(priv->notebook, FALSE);
 214         gtk_box_pack_start_defaults(GTK_BOX(priv->box),
 215                                     GTK_WIDGET(priv->notebook));
 216
 217         if (priv->wizard_name)
 218             hildon_wizard_dialog_create_title(HILDON_WIZARD_DIALOG
 219                                               (object));
 220         break;
 221     default:
 222         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 223         break;
 224     }
 225 }
 226
 227
 228 static void
 229 hildon_wizard_dialog_get_property(GObject * object, guint property_id,
 230                                   GValue * value, GParamSpec * pspec)
 231 {
 232     HildonWizardDialogPrivate *priv = HILDON_WIZARD_DIALOG(object)->priv;
 233
 234     switch (property_id) {
 235     case PROP_WIZARD_NAME:
 236         g_value_set_string(value, priv->wizard_name);
 237         break;
 238     case PROP_WIZARD_NOTEBOOK:
 239         g_value_set_object(value, priv->notebook);
 240         break;
 241     default:
 242         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 243         break;
 244     }
 245 }
 246
 247
 248 static void
 249 hildon_wizard_dialog_create_title(HildonWizardDialog * wizard_dialog)
 250 {
 251     gint pages, current;
 252     gchar *str = NULL;
 253     HildonWizardDialogPrivate *priv = wizard_dialog->priv;
 254     GtkNotebook *notebook = priv->notebook;
 255     /*
 256     const gchar *step = _("step");
 257     const gchar *welcome = _("Welcome");
 258     const gchar *wizard_completed = _("Wizard completed");
 259     */
 260     if (!notebook)
 261         return;
 262     pages = gtk_notebook_get_n_pages(notebook);
 263     current = gtk_notebook_get_current_page(priv->notebook);
 264     if (current < 0)
 265         current = 0;
 266
 267     if (current == 0) {
 268         str = g_strdup_printf(_("Ecdg_ti_wizard_welcome"),
 269                               priv->wizard_name, pages);
 270     } else if (current + 1 == pages) {
 271         gchar *steps = (gchar *) gtk_notebook_get_tab_label_text(notebook,
 272             gtk_notebook_get_nth_page(notebook, current));
 273         str = g_strdup_printf(_("Ecdg_ti_wizard_step"),
 274                               priv->wizard_name, current + 1, pages, steps);
 275     } else {
 276         gchar *steps = (gchar *) gtk_notebook_get_tab_label_text(notebook,
 277             gtk_notebook_get_nth_page(notebook, current));
 278         str = g_strdup_printf(_("Ecdg_ti_wizard_step"),
 279                               priv->wizard_name, current + 1, pages, steps);
 280     }
 281     /*
 282     if (current == 0)
 283         str = g_strdup_printf("%s %s %d/%d %s", priv->wizard_name, step,
 284                               current + 1, pages, welcome);
 285     else if (current + 1 == pages)
 286         str = g_strdup_printf("%s %s %d/%d %s",
 287                               priv->wizard_name, step, current + 1, pages,
 288                               wizard_completed);
 289     else {
 290         gchar *steps = (gchar *) gtk_notebook_get_tab_label_text(notebook,
 291             gtk_notebook_get_nth_page(notebook, current));
 292         str = g_strdup_printf("%s %s %d/%d: %s", priv->wizard_name, step,
 293                               current + 1, pages, steps);
 294     }
 295     */
 296     gtk_window_set_title(GTK_WINDOW(wizard_dialog), str);
 297     g_free(str);
 298 }
 299
 300 static void direction_button_clicked(GtkWidget *widget,
 301                                      HildonWizardDialog *wizard_dialog)
 302 {
 303     HildonWizardDialogPrivate *priv = wizard_dialog->priv;
 304     GtkNotebook *notebook = priv->notebook;
 305     gint current = 0;
 306     gint last = gtk_notebook_get_n_pages(notebook) - 1;
 307
 308     if (widget == priv->previous_button)
 309     {
 310         gtk_notebook_prev_page(notebook);
 311         current = gtk_notebook_get_current_page(notebook);
 312         if (current == 0)
 313         {
 314             gtk_widget_set_sensitive(priv->previous_button, FALSE);
 315             gtk_dialog_set_response_sensitive
 316                 (GTK_DIALOG(wizard_dialog),
 317                  HILDON_WIZARD_DIALOG_FINISH,
 318                  FALSE);
 319         }
 320         if (current != last)
 321             gtk_widget_set_sensitive(priv->next_button, TRUE);
 322     }
 323     else /* Next button */
 324     {
 325         gtk_notebook_next_page(notebook);
 326         current = gtk_notebook_get_current_page(notebook);
 327         if (gtk_notebook_get_current_page(notebook) != 0)
 328         {
 329             gtk_widget_set_sensitive(priv->previous_button, TRUE);
 330             gtk_dialog_set_response_sensitive
 331                 (GTK_DIALOG(wizard_dialog),
 332                  HILDON_WIZARD_DIALOG_FINISH,
 333                  TRUE);
 334         }
 335         if (current == last)
 336             gtk_widget_set_sensitive(priv->next_button, FALSE);
 337     }
 338
 339     if (current == last || current == 0)
 340         gtk_widget_show(GTK_WIDGET(priv->image));
 341     else
 342         gtk_widget_hide(GTK_WIDGET(priv->image));
 343     hildon_wizard_dialog_create_title(wizard_dialog);
 344 }
 345
 346
 347 /**
 348  * hildon_wizard_dialog_new:
 349  * @parent: A #GtkWindow
 350  * @wizard_name: The name of dialog
 351  * @notebook: The notebook to be shown on the dialog
 352  *
 353  * Creates a new #HildonWizardDialog
 354  *
 355  * Return value: A new HildonWizardDialog
 356  */
 357 GtkWidget *hildon_wizard_dialog_new(GtkWindow * parent,
 358                                     const char *wizard_name,
 359                                     GtkNotebook * notebook)
 360 {
 361     GtkWidget *widget;
 362
 363     g_return_val_if_fail(GTK_IS_NOTEBOOK(notebook), NULL);
 364     widget = GTK_WIDGET(g_object_new(HILDON_TYPE_WIZARD_DIALOG,
 365                                      "wizard-name", wizard_name,
 366                                      "wizard-notebook", notebook, NULL));
 367     if (parent)
 368         gtk_window_set_transient_for(GTK_WINDOW(widget), parent);
 369
 370     return widget;
 371 }