git.maemo.org Git - hildon/blob - hildon/hildon-note.c

   1 /*
   2  * This file is a part of hildon
   3  *
   4  * Copyright (C) 2005, 2006 Nokia Corporation, all rights reserved.
   5  *
   6  * Contact: Rodrigo Novo <rodrigo.novo@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; 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 /**
  26  * SECTION:hildon-note
  27  * @short_description: A widget to ask confirmation from the user.
  28  *
  29  * #HildonNote is a convenient way to prompt users for a small amount of
  30  * input. A simple note contains an information text and, in case of
  31  * confirmation notes, it shows buttons to confirm or cancel. It can also
  32  * include a #GtkProgressBar.
  33  *
  34  * This widget provides convenient functions to create either
  35  * information notes, confirmation notes or cancel notes, which are
  36  * useful to show the progress of a requested task allowing the user
  37  * to cancel it.
  38  *
  39  * To create information notes you can use
  40  * hildon_note_new_information(). hildon_note_new_confirmation()
  41  * creates a note with a text and two buttons to confirm or
  42  * cancel. Note that it is possible to create a confirmation note with
  43  * customized buttons by using
  44  * hildon_note_new_confirmation_add_buttons().
  45  *
  46  * To create a note with a text, a progress bar and cancel button,
  47  * hildon_note_new_cancel_with_progress_bar() can be used.
  48  *
  49  * <example>
  50  * <title>HildonNote example</title>
  51  * <programlisting>
  52  * <!-- -->
  53  * gboolean
  54  * show_confirmation_note (GtkWindow *parent)
  55  * {
  56  *   gint retcode;
  57  *   GtkWidget *note;
  58  *   note = hildon_note_new_confirmation (parent, "Confirmation message...");
  59  * <!-- -->
  60  *   retcode = gtk_dialog_run (GTK_DIALOG (note));
  61  *   gtk_widget_destroy (note);
  62  * <!-- -->
  63  *   if (retcode == GTK_RESPONSE_OK) {
  64  *        g_debug ("User pressed 'OK' button'");
  65  *        return TRUE;
  66  *   } else {
  67  *        g_debug ("User pressed 'Cancel' button");
  68  *        return FALSE;
  69  *   }
  70  * }
  71  * </programlisting>
  72  * </example>
  73  */
  74
  75 #ifdef                                          HAVE_CONFIG_H
  76 #include                                        <config.h>
  77 #endif
  78
  79 #include                                        <stdio.h>
  80 #include                                        <string.h>
  81 #include                                        <libintl.h>
  82 #include                                        <X11/X.h>
  83 #include                                        <X11/Xatom.h>
  84 #include                                        <gdk/gdkx.h>
  85
  86 #undef HILDON_DISABLE_DEPRECATED
  87
  88 #include                                        "hildon-note.h"
  89 #include                                        "hildon-defines.h"
  90 #include                                        "hildon-sound.h"
  91 #include                                        "hildon-banner.h"
  92 #include                                        "hildon-enum-types.h"
  93 #include                                        "hildon-note-private.h"
  94
  95 #define                                         HILDON_INFORMATION_NOTE_MIN_HEIGHT 140
  96
  97 #define                                         HILDON_INFORMATION_NOTE_MARGIN 100
  98
  99 #define                                         CONFIRMATION_SOUND_PATH \
 100                                                 "/usr/share/sounds/ui-confirmation_note.wav"
 101
 102 #define                                         INFORMATION_SOUND_PATH \
 103                                                 "/usr/share/sounds/ui-information_note.wav"
 104
 105 #define                                         _(String) dgettext("hildon-libs", String)
 106
 107 static void
 108 hildon_note_class_init                          (HildonNoteClass *class);
 109
 110 static void
 111 hildon_note_init                                (HildonNote *dialog);
 112
 113 static void
 114 hildon_note_rebuild                             (HildonNote *note);
 115
 116 static void
 117 hildon_note_rename                              (HildonNote *note);
 118
 119 static void
 120 hildon_note_finalize                            (GObject *obj_self);
 121
 122 static void
 123 hildon_note_realize                             (GtkWidget *widget);
 124
 125 static void
 126 hildon_note_unrealize                           (GtkWidget *widget);
 127
 128 static void
 129 hildon_note_size_request                        (GtkWidget      *note,
 130                                                  GtkRequisition *req);
 131
 132 static void
 133 label_size_request                              (GtkWidget      *label,
 134                                                  GtkRequisition *req,
 135                                                  GtkWidget      *note);
 136
 137 static void
 138 hildon_note_set_property                        (GObject *object,
 139                                                  guint prop_id,
 140                                                  const GValue *value,
 141                                                  GParamSpec *pspec);
 142
 143 static void
 144 hildon_note_get_property                        (GObject *object,
 145                                                  guint prop_id,
 146                                                  GValue *value,
 147                                                  GParamSpec *pspec);
 148
 149 static void
 150 on_show_cb                                      (GtkWidget *widget,
 151                                                  gpointer data);
 152 static gboolean
 153 sound_handling                                  (gpointer data);
 154
 155 static void
 156 unpack_widget                                   (GtkWidget *widget);
 157
 158 enum
 159 {
 160     PROP_0,
 161     PROP_HILDON_NOTE_TYPE,
 162     PROP_HILDON_NOTE_DESCRIPTION,
 163     PROP_HILDON_NOTE_ICON,
 164     PROP_HILDON_NOTE_PROGRESSBAR,
 165     PROP_HILDON_NOTE_STOCK_ICON
 166 };
 167
 168 static GtkDialogClass*                          parent_class;
 169
 170 static gboolean
 171 event_box_press_event                           (GtkEventBox    *event_box,
 172                                                  GdkEventButton *event,
 173                                                  GtkDialog      *note)
 174 {
 175     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (note);
 176
 177     if (priv->note_n == HILDON_NOTE_TYPE_INFORMATION ||
 178         priv->note_n == HILDON_NOTE_TYPE_INFORMATION_THEME) {
 179             gtk_dialog_response (note, GTK_RESPONSE_DELETE_EVENT);
 180             return TRUE;
 181     } else {
 182             return FALSE;
 183     }
 184 }
 185
 186 static void
 187 hildon_note_set_property                        (GObject *object,
 188                                                  guint prop_id,
 189                                                  const GValue *value,
 190                                                  GParamSpec * pspec)
 191 {
 192     HildonNote *note = HILDON_NOTE (object);
 193     HildonNotePrivate *priv;
 194     GtkWidget *widget;
 195
 196     priv = HILDON_NOTE_GET_PRIVATE (note);
 197     g_assert (priv);
 198
 199     switch (prop_id) {
 200
 201         case PROP_HILDON_NOTE_TYPE:
 202             priv->note_n = g_value_get_enum (value);
 203             hildon_note_rename (note);
 204             hildon_note_rebuild (note);
 205             break;
 206
 207         case PROP_HILDON_NOTE_DESCRIPTION:
 208             if (priv->original_description)
 209                     g_free (priv->original_description);
 210             priv->original_description = g_value_dup_string (value);
 211
 212             gtk_label_set_text (GTK_LABEL (priv->label), priv->original_description);
 213             /* FIXME Is the "original_description" used anywhere? */
 214
 215             break;
 216
 217         case PROP_HILDON_NOTE_ICON:
 218             if (priv->icon) {
 219               g_free (priv->icon);
 220             }
 221             priv->icon = g_value_dup_string (value);
 222             break;
 223
 224         case PROP_HILDON_NOTE_STOCK_ICON:
 225             if (priv->stock_icon) {
 226               g_free (priv->stock_icon);
 227             }
 228             priv->stock_icon = g_value_dup_string (value);
 229             break;
 230
 231         case PROP_HILDON_NOTE_PROGRESSBAR:
 232             widget = g_value_get_object (value);
 233             if (widget != priv->progressbar)
 234             {
 235                 if (priv->progressbar)
 236                     g_object_unref (priv->progressbar);
 237
 238                 priv->progressbar = widget;
 239
 240                 if (widget)
 241                 {
 242                     g_object_ref (widget);
 243                     gtk_object_sink (GTK_OBJECT (widget));
 244                 }
 245
 246                 hildon_note_rebuild (note);
 247             }
 248             break;
 249
 250         default:
 251             G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 252             break;
 253     }
 254 }
 255
 256 static void
 257 hildon_note_get_property                        (GObject *object,
 258                                                  guint prop_id,
 259                                                  GValue *value,
 260                                                  GParamSpec *pspec)
 261 {
 262     HildonNote *note = HILDON_NOTE (object);
 263     HildonNotePrivate *priv;
 264
 265     priv = HILDON_NOTE_GET_PRIVATE (note);
 266
 267     switch (prop_id) {
 268
 269         case PROP_HILDON_NOTE_TYPE:
 270             g_value_set_enum (value, priv->note_n);
 271             break;
 272
 273         case PROP_HILDON_NOTE_DESCRIPTION:
 274             g_value_set_string (value, priv->original_description);
 275             break;
 276
 277         case PROP_HILDON_NOTE_ICON:
 278             g_value_set_string (value, priv->icon);
 279             break;
 280
 281         case PROP_HILDON_NOTE_STOCK_ICON:
 282             g_value_set_string (value, priv->stock_icon);
 283             break;
 284
 285         case PROP_HILDON_NOTE_PROGRESSBAR:
 286             g_value_set_object (value, priv->progressbar);
 287             break;
 288
 289         default:
 290             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 291             break;
 292     }
 293 }
 294
 295 /**
 296  * hildon_note_get_type:
 297  *
 298  * Returns GType for HildonNote.
 299  *
 300  * Returns: HildonNote type
 301  */
 302 GType G_GNUC_CONST
 303 hildon_note_get_type                            (void)
 304 {
 305     static GType dialog_type = 0;
 306
 307     if (! dialog_type) {
 308         static const GTypeInfo dialog_info = {
 309             sizeof(HildonNoteClass),
 310             NULL,       /* base_init */
 311             NULL,       /* base_finalize */
 312             (GClassInitFunc) hildon_note_class_init,
 313             NULL,       /* class_finalize */
 314             NULL,       /* class_data */
 315             sizeof(HildonNote),
 316             0,  /* n_preallocs */
 317             (GInstanceInitFunc) hildon_note_init
 318         };
 319         dialog_type = g_type_register_static (GTK_TYPE_DIALOG,
 320                 "HildonNote",
 321                 &dialog_info, 0);
 322     }
 323     return dialog_type;
 324 }
 325
 326 static void
 327 hildon_note_class_init                          (HildonNoteClass *class)
 328 {
 329     GObjectClass *object_class = G_OBJECT_CLASS (class);
 330     GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 331
 332     /* set the global parent_class */
 333     parent_class = g_type_class_peek_parent (class);
 334
 335     g_type_class_add_private (class, sizeof (HildonNotePrivate));
 336
 337     object_class->finalize      = hildon_note_finalize;
 338     object_class->set_property  = hildon_note_set_property;
 339     object_class->get_property  = hildon_note_get_property;
 340     widget_class->realize       = hildon_note_realize;
 341     widget_class->unrealize     = hildon_note_unrealize;
 342     widget_class->size_request  = hildon_note_size_request;
 343
 344     /**
 345      * HildonNote:type:
 346      *
 347      * The type of the #HildonNote, defining its contents, behavior, and
 348      * theming.
 349      */
 350     g_object_class_install_property (object_class,
 351             PROP_HILDON_NOTE_TYPE,
 352             g_param_spec_enum ("note-type",
 353                 "note type",
 354                 "The type of the note dialog",
 355                 hildon_note_type_get_type (),
 356                 HILDON_NOTE_TYPE_CONFIRMATION,
 357                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 358
 359     /**
 360      * HildonNote:description:
 361      *
 362      * The text that appears in the #HildonNote.
 363      */
 364     g_object_class_install_property (object_class,
 365             PROP_HILDON_NOTE_DESCRIPTION,
 366             g_param_spec_string ("description",
 367                 "note description",
 368                 "The text that appears in the note dialog",
 369                 "",
 370                 G_PARAM_READWRITE));
 371
 372     /**
 373      * HildonNote:icon:
 374      *
 375      * Icon for the note.
 376      *
 377      * Deprecated: Since 2.2
 378      */
 379     g_object_class_install_property (object_class,
 380             PROP_HILDON_NOTE_ICON,
 381             g_param_spec_string ("icon",
 382                 "note icon",
 383                 "The name of the icon that appears in the note dialog",
 384                 "",
 385                 G_PARAM_READWRITE));
 386
 387     /**
 388      * HildonNote:stock-icon:
 389      *
 390      * Stock icon name for the note.
 391      *
 392      * Deprecated: Since 2.2
 393      */
 394     g_object_class_install_property (object_class,
 395             PROP_HILDON_NOTE_STOCK_ICON,
 396             g_param_spec_string ("stock-icon",
 397                 "Stock note icon",
 398                 "The stock name of the icon that appears in the note dialog",
 399                 "",
 400                 G_PARAM_READWRITE));
 401
 402     /**
 403      * HildonNote:progressbar:
 404      *
 405      * If set, a #GtkProgressBar visible in the note.
 406      */
 407     g_object_class_install_property (object_class,
 408             PROP_HILDON_NOTE_PROGRESSBAR,
 409             g_param_spec_object ("progressbar",
 410                 "Progressbar widget",
 411                 "The progressbar that appears in the note dialog",
 412                 GTK_TYPE_PROGRESS_BAR,
 413                 G_PARAM_READWRITE));
 414 }
 415
 416 static void
 417 hildon_note_init                                (HildonNote *dialog)
 418 {
 419     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (dialog);
 420     g_assert (priv);
 421
 422     priv->label = gtk_label_new (NULL);
 423     gtk_label_set_line_wrap (GTK_LABEL (priv->label), TRUE);
 424     gtk_label_set_justify (GTK_LABEL (priv->label), GTK_JUSTIFY_LEFT);
 425
 426     priv->event_box = gtk_event_box_new ();
 427     priv->icon = NULL;
 428     priv->stock_icon = NULL;
 429     priv->idle_handler = 0;
 430
 431     gtk_event_box_set_visible_window (GTK_EVENT_BOX (priv->event_box), FALSE);
 432     gtk_event_box_set_above_child (GTK_EVENT_BOX (priv->event_box), TRUE);
 433     g_signal_connect (priv->event_box, "button-press-event",
 434                       G_CALLBACK (event_box_press_event), dialog);
 435
 436     /* Because ESD is synchronous, we wish to play sound after the
 437        note is already on screen to avoid blocking its appearance */
 438     g_signal_connect (GTK_WIDGET (dialog), "show",
 439                       G_CALLBACK (on_show_cb), NULL);
 440
 441     /* Acquire real references to our internal children, since
 442        they are not nessecarily packed into container in each
 443        layout */
 444     g_object_ref_sink (priv->event_box);
 445     g_object_ref_sink (priv->label);
 446
 447     gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
 448     gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 449
 450     /* We use special hint to turn the note into information notification. */
 451     gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
 452 }
 453
 454
 455 static void
 456 hildon_note_finalize                            (GObject *obj_self)
 457 {
 458     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (obj_self);
 459     g_assert (priv);
 460
 461     /* FIXME Some of this stuff should be moved to dispose */
 462
 463     /* Free internal data */
 464     if (priv->event_box)
 465         g_object_unref (priv->event_box);
 466
 467     if (priv->label)
 468         g_object_unref (priv->label);
 469
 470     if (priv->icon) {
 471         g_free (priv->icon);
 472         priv->icon = NULL;
 473     }
 474     if (priv->stock_icon) {
 475         g_free (priv->stock_icon);
 476         priv->stock_icon = NULL;
 477     }
 478     if (priv->idle_handler) {
 479         g_source_remove (priv->idle_handler);
 480         priv->idle_handler = 0;
 481     }
 482
 483     if (priv->progressbar)
 484         g_object_unref (priv->progressbar);
 485
 486     if (priv->original_description)
 487         g_free (priv->original_description);
 488
 489     G_OBJECT_CLASS (parent_class)->finalize (obj_self);
 490 }
 491
 492 static void
 493 label_size_request                              (GtkWidget      *label,
 494                                                  GtkRequisition *req,
 495                                                  GtkWidget      *note)
 496 {
 497     gint note_height = MAX (HILDON_INFORMATION_NOTE_MIN_HEIGHT, req->height);
 498     g_object_set (note, "height-request", note_height, NULL);
 499 }
 500
 501 static void
 502 resize_button (GtkWidget *button, gpointer *data)
 503 {
 504     gint width = GPOINTER_TO_INT (data);
 505     g_object_set (button, "width-request", width, NULL);
 506 }
 507
 508 static void
 509 hildon_note_orientation_update (HildonNote *note, GdkScreen *screen)
 510 {
 511     GtkDialog *dialog = GTK_DIALOG (note);
 512     HildonNotePrivate* priv = HILDON_NOTE_GET_PRIVATE (note);
 513     GtkWidget *parent;
 514     gint button_width, padding;
 515     gboolean portrait = gdk_screen_get_width (screen) < gdk_screen_get_height (screen);
 516
 517     g_object_ref (dialog->action_area);
 518     unpack_widget (dialog->action_area);
 519
 520     if (portrait) {
 521         parent = dialog->vbox;
 522         button_width = gdk_screen_get_width (screen) - HILDON_MARGIN_DOUBLE * 2;
 523         padding = HILDON_MARGIN_DOUBLE;
 524     } else {
 525         parent = gtk_widget_get_parent (dialog->vbox);
 526         button_width = priv->button_width;
 527         padding = 0;
 528     }
 529
 530     gtk_box_pack_end (GTK_BOX (parent), dialog->action_area,
 531                       portrait, TRUE, 0);
 532     gtk_box_reorder_child (GTK_BOX (parent), dialog->action_area, 0);
 533     gtk_container_foreach (GTK_CONTAINER (dialog->action_area),
 534                            (GtkCallback) resize_button,
 535                            GINT_TO_POINTER (button_width));
 536     g_object_unref (dialog->action_area);
 537     gtk_container_child_set (GTK_CONTAINER (priv->box), priv->label,
 538                              "padding", padding, NULL);
 539 }
 540
 541 static void
 542 hildon_note_size_request                        (GtkWidget      *note,
 543                                                  GtkRequisition *req)
 544 {
 545     GTK_WIDGET_CLASS (parent_class)->size_request (note, req);
 546     req->width = gdk_screen_get_width (gtk_widget_get_screen (note));
 547 }
 548
 549 static void
 550 screen_size_changed                            (GdkScreen *screen,
 551                                                 GtkWidget *note)
 552 {
 553     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (note);
 554
 555     if (priv->note_n == HILDON_NOTE_TYPE_INFORMATION ||
 556         priv->note_n == HILDON_NOTE_TYPE_INFORMATION_THEME) {
 557         gint screen_width = gdk_screen_get_width (screen);
 558         gint text_width = screen_width - HILDON_INFORMATION_NOTE_MARGIN * 2;
 559         g_object_set (priv->label, "width-request", text_width, NULL);
 560
 561         return;
 562     } else if (priv->note_n == HILDON_NOTE_TYPE_CONFIRMATION) {
 563         hildon_note_orientation_update (HILDON_NOTE (note), screen);
 564     }
 565 }
 566
 567 static void
 568 hildon_note_realize                             (GtkWidget *widget)
 569 {
 570     GdkDisplay *display;
 571     gboolean is_info_note = FALSE;
 572     Atom atom;
 573     const gchar *notification_type;
 574     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (widget);
 575     g_assert (priv);
 576
 577     /* Make widget->window accessible */
 578     GTK_WIDGET_CLASS (parent_class)->realize (widget);
 579
 580     /* Border only, no titlebar */
 581     gdk_window_set_decorations (widget->window, GDK_DECOR_BORDER);
 582
 583     /* Set the _HILDON_NOTIFICATION_TYPE property so Matchbox places the window correctly */
 584     display = gdk_drawable_get_display (widget->window);
 585     atom = gdk_x11_get_xatom_by_name_for_display (display, "_HILDON_NOTIFICATION_TYPE");
 586
 587     if (priv->note_n == HILDON_NOTE_TYPE_INFORMATION ||
 588         priv->note_n == HILDON_NOTE_TYPE_INFORMATION_THEME) {
 589         notification_type = "_HILDON_NOTIFICATION_TYPE_INFO";
 590         is_info_note = TRUE;
 591     } else {
 592         notification_type = "_HILDON_NOTIFICATION_TYPE_CONFIRMATION";
 593     }
 594
 595     XChangeProperty (GDK_WINDOW_XDISPLAY (widget->window), GDK_WINDOW_XID (widget->window),
 596                      atom, XA_STRING, 8, PropModeReplace, (guchar *) notification_type,
 597                      strlen (notification_type));
 598
 599     if (is_info_note) {
 600         g_signal_connect (priv->label, "size-request", G_CALLBACK (label_size_request), widget);
 601     }
 602
 603     GdkScreen *screen = gtk_widget_get_screen (widget);
 604     g_signal_connect (screen, "size-changed", G_CALLBACK (screen_size_changed), widget);
 605     screen_size_changed (screen, widget);
 606 }
 607
 608 static void
 609 hildon_note_unrealize                           (GtkWidget *widget)
 610 {
 611     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (widget);
 612     GdkScreen *screen = gtk_widget_get_screen (widget);
 613
 614     g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (screen_size_changed), widget);
 615     g_signal_handlers_disconnect_by_func (priv->label, G_CALLBACK (label_size_request), widget);
 616
 617     GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 618 }
 619
 620
 621 /* Helper function for removing a widget from it's container.
 622    we own a separate reference to each object we try to unpack,
 623    so extra referencing is not needed. */
 624 static void
 625 unpack_widget                                   (GtkWidget *widget)
 626 {
 627     g_assert (widget == NULL || GTK_IS_WIDGET (widget));
 628
 629     if (widget && widget->parent)
 630         gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
 631 }
 632
 633 /*
 634   Name the widget and text label based on the note type. This is used
 635   by the theme to give proper backgrounds depending on the note type.
 636 */
 637 static void
 638 hildon_note_rename                              (HildonNote *note)
 639 {
 640   GEnumValue *value;
 641   GEnumClass *enum_class;
 642   gchar *name;
 643
 644   HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (note);
 645
 646   enum_class = g_type_class_ref (HILDON_TYPE_NOTE_TYPE);
 647   value = g_enum_get_value (enum_class, priv->note_n);
 648
 649   name = g_strconcat ("HildonNote-", value->value_nick, NULL);
 650   gtk_widget_set_name (GTK_WIDGET (note), name);
 651   g_free (name);
 652
 653   name = g_strconcat ("HildonNoteLabel-", value->value_nick, NULL);
 654   gtk_widget_set_name (priv->label, name);
 655   g_free (name);
 656
 657   g_type_class_unref (enum_class);
 658 }
 659
 660 static void
 661 hildon_note_rebuild                             (HildonNote *note)
 662 {
 663     GtkDialog *dialog;
 664     HildonNotePrivate *priv;
 665     gboolean is_info_note = FALSE;
 666
 667     g_assert (HILDON_IS_NOTE (note));
 668
 669     priv = HILDON_NOTE_GET_PRIVATE (note);
 670     g_assert (priv);
 671
 672     dialog = GTK_DIALOG (note);
 673
 674     /* Reuse exiting content widgets for new layout */
 675     unpack_widget (priv->label);
 676     unpack_widget (priv->progressbar);
 677     unpack_widget (priv->event_box);
 678
 679     /* Destroy old layout and buttons */
 680     if (priv->box) {
 681         gtk_widget_destroy (priv->box);
 682         priv->box = NULL;
 683     }
 684     if (priv->okButton) {
 685         gtk_widget_destroy (priv->okButton);
 686         priv->okButton = NULL;
 687     }
 688     if (priv->cancelButton) {
 689         gtk_widget_destroy (priv->cancelButton);
 690         priv->cancelButton = NULL;
 691     }
 692
 693     /* Add needed buttons and images for each note type */
 694     switch (priv->note_n)
 695     {
 696         case HILDON_NOTE_TYPE_CONFIRMATION:
 697             priv->okButton = gtk_dialog_add_button (dialog,
 698                     _("wdgt_bd_yes"), GTK_RESPONSE_OK);
 699             priv->cancelButton = gtk_dialog_add_button (dialog,
 700                     _("wdgt_bd_no"), GTK_RESPONSE_CANCEL);
 701             gtk_widget_show (priv->cancelButton);
 702             g_object_get (priv->okButton, "width-request",
 703                           &priv->button_width, NULL);
 704             gtk_widget_set_no_show_all (priv->cancelButton, FALSE);
 705             break;
 706
 707         case HILDON_NOTE_TYPE_PROGRESSBAR:
 708             priv->cancelButton = gtk_dialog_add_button (dialog,
 709                     _("wdgt_bd_stop"), GTK_RESPONSE_CANCEL);
 710             gtk_widget_show (priv->cancelButton);
 711             gtk_widget_set_no_show_all (priv->cancelButton, FALSE);
 712             break;
 713
 714         case HILDON_NOTE_TYPE_INFORMATION_THEME:
 715         case HILDON_NOTE_TYPE_INFORMATION:
 716             is_info_note = TRUE;
 717             break;
 718
 719         case HILDON_NOTE_TYPE_CONFIRMATION_BUTTON:
 720         default:
 721             break;
 722     }
 723
 724     /* Don't display the action area if this is just an information
 725      * note. This prevents text from being slightly aligned to the
 726      * left
 727      */
 728     if (is_info_note) {
 729         gtk_widget_hide (dialog->action_area);
 730     } else {
 731         gtk_widget_show (dialog->action_area);
 732     }
 733     gtk_widget_set_no_show_all (dialog->action_area, is_info_note);
 734
 735     /* Pack label vertically. Spacing is only necessary for the progressbar note. */
 736     priv->box = gtk_vbox_new (FALSE, priv->progressbar ? HILDON_MARGIN_DOUBLE : 0);
 737     gtk_container_add (GTK_CONTAINER (priv->event_box), priv->box);
 738     gtk_box_pack_start (GTK_BOX (priv->box), priv->label, TRUE, TRUE, 0);
 739
 740     if (priv->progressbar)
 741         gtk_box_pack_start (GTK_BOX (priv->box), priv->progressbar, FALSE, FALSE, 0);
 742
 743     gtk_container_add (GTK_CONTAINER (dialog->vbox), priv->event_box);
 744
 745     gtk_widget_show_all (priv->event_box);
 746 }
 747
 748 /**
 749  * hildon_note_new_confirmation_add_buttons:
 750  * @parent: the parent window. The X window ID of the parent window
 751  *   has to be the same as the X window ID of the application. This is
 752  *   important so that the window manager could handle the windows
 753  *   correctly.
 754  *   In GTK the X window ID can be checked using
 755  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 756  * @description: the message to confirm
 757  * @Varargs: arguments pairs for new buttons(label and return value).
 758  *   Terminate the list with %NULL value.
 759  *
 760  * Create a new confirmation note with custom buttons. Confirmation
 761  * note has a text and any number of buttons. It's important to note
 762  * that even though the name of the function might suggest, the
 763  * default ok/cancel buttons are not appended but you have to provide
 764  * all of the buttons.
 765  *
 766  * FIXME: This doc seems to be wrong, the two buttons aren't added so
 767  * it would only contain the "additional" buttons? However, changing
 768  * this would break those applications that rely on current behaviour.
 769  *
 770  * Returns: A #GtkWidget pointer of the note
 771  */
 772 GtkWidget*
 773 hildon_note_new_confirmation_add_buttons        (GtkWindow *parent,
 774                                                  const gchar *description,
 775                                                  ...)
 776 {
 777     va_list args;
 778     char *message;
 779     int value;
 780     GtkWidget *button;
 781
 782     g_return_val_if_fail (description != NULL, NULL);
 783
 784     GtkWidget *conf_note =
 785         g_object_new (HILDON_TYPE_NOTE,
 786                 "note-type", HILDON_NOTE_TYPE_CONFIRMATION_BUTTON,
 787                 "description", description,
 788                 NULL);
 789
 790     if (parent != NULL)
 791         gtk_window_set_transient_for (GTK_WINDOW (conf_note), parent);
 792
 793     /* Add the buttons from varargs */
 794     va_start(args, description);
 795
 796     while (TRUE) {
 797         message = va_arg (args, char *);
 798
 799         if (! message) {
 800             break;
 801         }
 802         value = va_arg (args, int);
 803
 804         button = gtk_dialog_add_button (GTK_DIALOG (conf_note), message, value);
 805         /* maemo-gtk is going to set the "no-show-all" property all
 806            cancel/close-like buttons to TRUE, so that they are not shown. On
 807            the other hand, this confirmation note with custom buttons should
 808            not obey this rule, so we need to make sure they are shown. */
 809         gtk_widget_show (button);
 810         gtk_widget_set_no_show_all (button, FALSE);
 811     }
 812
 813     va_end (args);
 814
 815     return conf_note;
 816 }
 817
 818
 819 /**
 820  * hildon_note_new_confirmation:
 821  * @parent: the parent window. The X window ID of the parent window
 822  *   has to be the same as the X window ID of the application. This is
 823  *   important so that the window manager could handle the windows
 824  *   correctly. In GTK the X window ID can be checked using
 825  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 826  * @description: the message to confirm
 827  *
 828  * Create a new confirmation note. Confirmation note has a text (description)
 829  * that you specify and two buttons.
 830  *
 831  * Returns: a #GtkWidget pointer of the note
 832  */
 833 GtkWidget*
 834 hildon_note_new_confirmation                    (GtkWindow *parent,
 835                                                  const gchar *description)
 836 {
 837     GtkWidget *dialog = NULL;
 838
 839     g_return_val_if_fail (description != NULL, NULL);
 840
 841     dialog = g_object_new (HILDON_TYPE_NOTE,
 842             "note-type",
 843             HILDON_NOTE_TYPE_CONFIRMATION,
 844             "description", description, NULL);
 845
 846     if (parent != NULL)
 847         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 848
 849     return dialog;
 850 }
 851
 852 /**
 853  * hildon_note_new_confirmation_with_icon_name:
 854  * @parent: the parent window. The X window ID of the parent window
 855  *   has to be the same as the X window ID of the application. This is
 856  *   important so that the window manager could handle the windows
 857  *   correctly. In GTK the X window ID can be checked using
 858  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 859  * @description: the message to confirm
 860  * @icon_name: icon to be displayed. If NULL, default icon is used.
 861  *
 862  * Create a new confirmation note. Confirmation note has a text (description)
 863  * that you specify and two buttons.
 864  *
 865  * Deprecated: Since 2.2, icons are not shown in confirmation notes. Icons set
 866  * with this function will be ignored. Use hildon_note_new_confirmation() instead.
 867  *
 868  * Returns: a #GtkWidget pointer of the note
 869  */
 870 GtkWidget*
 871 hildon_note_new_confirmation_with_icon_name     (GtkWindow *parent,
 872                                                  const gchar *description,
 873                                                  const gchar *icon_name)
 874 {
 875     GtkWidget *dialog;
 876
 877     dialog = hildon_note_new_confirmation (parent, description);
 878     g_object_set (dialog, "icon", icon_name, NULL);
 879
 880     return dialog;
 881 }
 882
 883 /**
 884  * hildon_note_new_information:
 885  * @parent: the parent window. The X window ID of the parent window
 886  *   has to be the same as the X window ID of the application. This is
 887  *   important so that the window manager could handle the windows
 888  *   correctly. In GTK the X window ID can be checked using
 889  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 890  * @description: the message to confirm
 891  *
 892  * Create a new information note. Information note has a text (description)
 893  * that you specify and an OK button.
 894  *
 895  * Returns: a #GtkWidget pointer of the note
 896  */
 897 GtkWidget*
 898 hildon_note_new_information                     (GtkWindow *parent,
 899                                                  const gchar *description)
 900 {
 901     GtkWidget *dialog = NULL;
 902
 903     g_return_val_if_fail (description != NULL, NULL);
 904
 905     dialog = g_object_new (HILDON_TYPE_NOTE,
 906             "note-type",
 907             HILDON_NOTE_TYPE_INFORMATION_THEME,
 908             "description", description, NULL);
 909
 910     if (parent != NULL)
 911         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 912
 913     return dialog;
 914 }
 915
 916 /**
 917  * hildon_note_new_information_with_icon_name:
 918  * @parent: the parent window. The X window ID of the parent window
 919  *   has to be the same as the X window ID of the application. This is
 920  *   important so that the window manager could handle the windows
 921  *   correctly. In GTK the X window ID can be checked using
 922  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 923  * @description: the message to confirm
 924  * @icon_name: icon to be displayed. If NULL, default icon is used.
 925  *
 926  * Create a new information note. Information note has text(description)
 927  * that you specify, an OK button and an icon.
 928  *
 929  * Deprecated: Since 2.2, icons are not shown in confirmation notes. Icons set
 930  * with this function will be ignored. Use hildon_note_new_information() instead.
 931  *
 932  * Returns: a #GtkWidget pointer of the note
 933  */
 934 GtkWidget*
 935 hildon_note_new_information_with_icon_name      (GtkWindow * parent,
 936                                                  const gchar *description,
 937                                                  const gchar *icon_name)
 938 {
 939     GtkWidget *dialog;
 940
 941     dialog = hildon_note_new_information (parent, description);
 942     g_object_set (dialog, "icon", icon_name, NULL);
 943
 944     return dialog;
 945 }
 946
 947 /* FIXME This documentation string LIES! */
 948
 949 /**
 950  * hildon_note_new_cancel_with_progress_bar:
 951  * @parent: the parent window. The X window ID of the parent window
 952  *   has to be the same as the X window ID of the application. This is
 953  *   important so that the window manager could handle the windows
 954  *   correctly. In GTK the X window ID can be checked using
 955  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 956  * @description: the action to cancel
 957  * @progressbar: a pointer to #GtkProgressBar to be filled with the
 958  *   progressbar assigned to this note. Use this to set the fraction of
 959  *   progressbar done. This parameter can be %NULL as well, in which
 960  *   case plain text cancel note appears.
 961  *
 962  * Create a new cancel note with a progress bar. Cancel note has
 963  * text(description) that you specify, a Cancel button and a progress bar.
 964  *
 965  * Returns: a #GtkDialog. Use this to get rid of this note when you
 966  *   no longer need it.
 967  */
 968 GtkWidget*
 969 hildon_note_new_cancel_with_progress_bar        (GtkWindow *parent,
 970                                                  const gchar *description,
 971                                                  GtkProgressBar *progressbar)
 972 {
 973     GtkWidget *dialog = NULL;
 974
 975     g_return_val_if_fail (description != NULL, NULL);
 976
 977     dialog = g_object_new (HILDON_TYPE_NOTE,
 978             "note-type",
 979             HILDON_NOTE_TYPE_PROGRESSBAR,
 980             "description", description,
 981             "progressbar",
 982             progressbar, NULL);
 983
 984     if (parent != NULL)
 985         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 986
 987     return dialog;
 988 }
 989
 990
 991 /**
 992  * hildon_note_set_button_text:
 993  * @note: a #HildonNote
 994  * @text: sets the button text and if there is two buttons in dialog,
 995  *   the button texts will be &lt;text&gt;, "Cancel".
 996  *
 997  * Sets the text of the button in @note.
 998  */
 999 void
1000 hildon_note_set_button_text                     (HildonNote *note,
1001                                                  const gchar *text)
1002 {
1003     HildonNotePrivate *priv;
1004
1005     g_return_if_fail (HILDON_IS_NOTE (note));
1006
1007     priv = HILDON_NOTE_GET_PRIVATE (HILDON_NOTE (note));
1008     g_assert (priv);
1009
1010     if (priv->okButton) {
1011         gtk_button_set_label (GTK_BUTTON (priv->okButton), text);
1012         gtk_button_set_label (GTK_BUTTON (priv->cancelButton),
1013                 _("wdgt_bd_no"));
1014     } else {
1015         gtk_button_set_label (GTK_BUTTON (priv->cancelButton), text);
1016     }
1017 }
1018
1019 /**
1020  * hildon_note_set_button_texts:
1021  * @note: a #HildonNote
1022  * @text_ok: the new text of the default OK button
1023  * @text_cancel: the new text of the default cancel button
1024  *
1025  * Sets the text for the buttons in @note.
1026  */
1027 void
1028 hildon_note_set_button_texts                    (HildonNote *note,
1029                                                  const gchar *text_ok,
1030                                                  const gchar *text_cancel)
1031 {
1032     HildonNotePrivate *priv;
1033
1034     g_return_if_fail (HILDON_IS_NOTE (note));
1035
1036     priv = HILDON_NOTE_GET_PRIVATE (HILDON_NOTE (note));
1037     g_assert (priv);
1038
1039     if (priv->okButton) {
1040         gtk_button_set_label (GTK_BUTTON (priv->okButton), text_ok);
1041         gtk_button_set_label (GTK_BUTTON (priv->cancelButton), text_cancel);
1042     } else {
1043         gtk_button_set_label (GTK_BUTTON (priv->cancelButton), text_cancel);
1044     }
1045 }
1046
1047 static void
1048 on_show_cb                                      (GtkWidget *widget,
1049                                                  gpointer data)
1050 {
1051     HildonNotePrivate *priv;
1052
1053     priv = HILDON_NOTE_GET_PRIVATE (widget);
1054     priv->idle_handler = g_idle_add (sound_handling, widget);
1055 }
1056
1057 /* We play a system sound when the note comes visible */
1058 static gboolean
1059 sound_handling                                  (gpointer data)
1060 {
1061     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (data);
1062     g_assert (priv);
1063
1064     switch (priv->note_n)
1065     {
1066         case HILDON_NOTE_TYPE_INFORMATION:
1067         case HILDON_NOTE_TYPE_INFORMATION_THEME:
1068             hildon_play_system_sound (INFORMATION_SOUND_PATH);
1069             break;
1070
1071         case HILDON_NOTE_TYPE_CONFIRMATION:
1072         case HILDON_NOTE_TYPE_CONFIRMATION_BUTTON:
1073             hildon_play_system_sound (CONFIRMATION_SOUND_PATH);
1074             break;
1075
1076         default:
1077             break;
1078     };
1079
1080     priv->idle_handler = 0;
1081
1082     return FALSE;
1083 }