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-gtk.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     hildon_note_rename (HILDON_NOTE (note));
 556
 557     if (priv->note_n == HILDON_NOTE_TYPE_INFORMATION ||
 558         priv->note_n == HILDON_NOTE_TYPE_INFORMATION_THEME) {
 559         gint screen_width = gdk_screen_get_width (screen);
 560         gint text_width = screen_width - HILDON_INFORMATION_NOTE_MARGIN * 2;
 561         g_object_set (priv->label, "width-request", text_width, NULL);
 562
 563         return;
 564     } else if (priv->note_n == HILDON_NOTE_TYPE_CONFIRMATION) {
 565         hildon_note_orientation_update (HILDON_NOTE (note), screen);
 566     }
 567 }
 568
 569 static void
 570 hildon_note_realize                             (GtkWidget *widget)
 571 {
 572     GdkDisplay *display;
 573     gboolean is_info_note = FALSE;
 574     Atom atom;
 575     const gchar *notification_type;
 576     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (widget);
 577     g_assert (priv);
 578
 579     /* Make widget->window accessible */
 580     GTK_WIDGET_CLASS (parent_class)->realize (widget);
 581
 582     /* Border only, no titlebar */
 583     gdk_window_set_decorations (widget->window, GDK_DECOR_BORDER);
 584
 585     /* Set the _HILDON_NOTIFICATION_TYPE property so Matchbox places the window correctly */
 586     display = gdk_drawable_get_display (widget->window);
 587     atom = gdk_x11_get_xatom_by_name_for_display (display, "_HILDON_NOTIFICATION_TYPE");
 588
 589     if (priv->note_n == HILDON_NOTE_TYPE_INFORMATION ||
 590         priv->note_n == HILDON_NOTE_TYPE_INFORMATION_THEME) {
 591         notification_type = "_HILDON_NOTIFICATION_TYPE_INFO";
 592         is_info_note = TRUE;
 593     } else {
 594         notification_type = "_HILDON_NOTIFICATION_TYPE_CONFIRMATION";
 595     }
 596
 597     XChangeProperty (GDK_WINDOW_XDISPLAY (widget->window), GDK_WINDOW_XID (widget->window),
 598                      atom, XA_STRING, 8, PropModeReplace, (guchar *) notification_type,
 599                      strlen (notification_type));
 600
 601     if (is_info_note) {
 602         g_signal_connect (priv->label, "size-request", G_CALLBACK (label_size_request), widget);
 603     }
 604
 605     GdkScreen *screen = gtk_widget_get_screen (widget);
 606     g_signal_connect (screen, "size-changed", G_CALLBACK (screen_size_changed), widget);
 607     screen_size_changed (screen, widget);
 608
 609     hildon_gtk_window_set_portrait_flags (GTK_WINDOW (widget), HILDON_PORTRAIT_MODE_SUPPORT);
 610 }
 611
 612 static void
 613 hildon_note_unrealize                           (GtkWidget *widget)
 614 {
 615     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (widget);
 616     GdkScreen *screen = gtk_widget_get_screen (widget);
 617
 618     g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (screen_size_changed), widget);
 619     g_signal_handlers_disconnect_by_func (priv->label, G_CALLBACK (label_size_request), widget);
 620
 621     GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 622 }
 623
 624
 625 /* Helper function for removing a widget from it's container.
 626    we own a separate reference to each object we try to unpack,
 627    so extra referencing is not needed. */
 628 static void
 629 unpack_widget                                   (GtkWidget *widget)
 630 {
 631     g_assert (widget == NULL || GTK_IS_WIDGET (widget));
 632
 633     if (widget && widget->parent)
 634         gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
 635 }
 636
 637 /*
 638   Name the widget and text label based on the note type. This is used
 639   by the theme to give proper backgrounds depending on the note type.
 640 */
 641 static void
 642 hildon_note_rename                              (HildonNote *note)
 643 {
 644   GEnumValue *value;
 645   GEnumClass *enum_class;
 646   gchar *name;
 647   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (note));
 648   gboolean portrait = gdk_screen_get_width (screen) < gdk_screen_get_height (screen);
 649   const gchar *portrait_suffix = portrait ? "-portrait" : NULL;
 650
 651   HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (note);
 652
 653   enum_class = g_type_class_ref (HILDON_TYPE_NOTE_TYPE);
 654   value = g_enum_get_value (enum_class, priv->note_n);
 655
 656   name = g_strconcat ("HildonNote-", value->value_nick, portrait_suffix, NULL);
 657   gtk_widget_set_name (GTK_WIDGET (note), name);
 658   g_free (name);
 659
 660   name = g_strconcat ("HildonNoteLabel-", value->value_nick, NULL);
 661   gtk_widget_set_name (priv->label, name);
 662   g_free (name);
 663
 664   g_type_class_unref (enum_class);
 665 }
 666
 667 static void
 668 hildon_note_rebuild                             (HildonNote *note)
 669 {
 670     GtkDialog *dialog;
 671     HildonNotePrivate *priv;
 672     gboolean is_info_note = FALSE;
 673
 674     g_assert (HILDON_IS_NOTE (note));
 675
 676     priv = HILDON_NOTE_GET_PRIVATE (note);
 677     g_assert (priv);
 678
 679     dialog = GTK_DIALOG (note);
 680
 681     /* Reuse exiting content widgets for new layout */
 682     unpack_widget (priv->label);
 683     unpack_widget (priv->progressbar);
 684     unpack_widget (priv->event_box);
 685
 686     /* Destroy old layout and buttons */
 687     if (priv->box) {
 688         gtk_widget_destroy (priv->box);
 689         priv->box = NULL;
 690     }
 691     if (priv->okButton) {
 692         gtk_widget_destroy (priv->okButton);
 693         priv->okButton = NULL;
 694     }
 695     if (priv->cancelButton) {
 696         gtk_widget_destroy (priv->cancelButton);
 697         priv->cancelButton = NULL;
 698     }
 699
 700     /* Add needed buttons and images for each note type */
 701     switch (priv->note_n)
 702     {
 703         case HILDON_NOTE_TYPE_CONFIRMATION:
 704             priv->okButton = gtk_dialog_add_button (dialog,
 705                     _("wdgt_bd_yes"), GTK_RESPONSE_OK);
 706             priv->cancelButton = gtk_dialog_add_button (dialog,
 707                     _("wdgt_bd_no"), GTK_RESPONSE_CANCEL);
 708             gtk_widget_show (priv->cancelButton);
 709             g_object_get (priv->okButton, "width-request",
 710                           &priv->button_width, NULL);
 711             gtk_widget_set_no_show_all (priv->cancelButton, FALSE);
 712             break;
 713
 714         case HILDON_NOTE_TYPE_PROGRESSBAR:
 715             priv->cancelButton = gtk_dialog_add_button (dialog,
 716                     _("wdgt_bd_stop"), GTK_RESPONSE_CANCEL);
 717             gtk_widget_show (priv->cancelButton);
 718             gtk_widget_set_no_show_all (priv->cancelButton, FALSE);
 719             break;
 720
 721         case HILDON_NOTE_TYPE_INFORMATION_THEME:
 722         case HILDON_NOTE_TYPE_INFORMATION:
 723             is_info_note = TRUE;
 724             break;
 725
 726         case HILDON_NOTE_TYPE_CONFIRMATION_BUTTON:
 727         default:
 728             break;
 729     }
 730
 731     /* Don't display the action area if this is just an information
 732      * note. This prevents text from being slightly aligned to the
 733      * left
 734      */
 735     if (is_info_note) {
 736         gtk_widget_hide (dialog->action_area);
 737     } else {
 738         gtk_widget_show (dialog->action_area);
 739     }
 740     gtk_widget_set_no_show_all (dialog->action_area, is_info_note);
 741
 742     /* Pack label vertically. Spacing is only necessary for the progressbar note. */
 743     priv->box = gtk_vbox_new (FALSE, priv->progressbar ? HILDON_MARGIN_DOUBLE : 0);
 744     gtk_container_add (GTK_CONTAINER (priv->event_box), priv->box);
 745     gtk_box_pack_start (GTK_BOX (priv->box), priv->label, TRUE, TRUE, 0);
 746
 747     if (priv->progressbar)
 748         gtk_box_pack_start (GTK_BOX (priv->box), priv->progressbar, FALSE, FALSE, 0);
 749
 750     gtk_container_add (GTK_CONTAINER (dialog->vbox), priv->event_box);
 751
 752     gtk_widget_show_all (priv->event_box);
 753 }
 754
 755 /**
 756  * hildon_note_new_confirmation_add_buttons:
 757  * @parent: the parent window. The X window ID of the parent window
 758  *   has to be the same as the X window ID of the application. This is
 759  *   important so that the window manager could handle the windows
 760  *   correctly.
 761  *   In GTK the X window ID can be checked using
 762  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 763  * @description: the message to confirm
 764  * @Varargs: arguments pairs for new buttons(label and return value).
 765  *   Terminate the list with %NULL value.
 766  *
 767  * Create a new confirmation note with custom buttons. Confirmation
 768  * note has a text and any number of buttons. It's important to note
 769  * that even though the name of the function might suggest, the
 770  * default ok/cancel buttons are not appended but you have to provide
 771  * all of the buttons.
 772  *
 773  * FIXME: This doc seems to be wrong, the two buttons aren't added so
 774  * it would only contain the "additional" buttons? However, changing
 775  * this would break those applications that rely on current behaviour.
 776  *
 777  * Returns: A #GtkWidget pointer of the note
 778  */
 779 GtkWidget*
 780 hildon_note_new_confirmation_add_buttons        (GtkWindow *parent,
 781                                                  const gchar *description,
 782                                                  ...)
 783 {
 784     va_list args;
 785     char *message;
 786     int value;
 787     GtkWidget *button;
 788
 789     g_return_val_if_fail (description != NULL, NULL);
 790
 791     GtkWidget *conf_note =
 792         g_object_new (HILDON_TYPE_NOTE,
 793                 "note-type", HILDON_NOTE_TYPE_CONFIRMATION_BUTTON,
 794                 "description", description,
 795                 NULL);
 796
 797     if (parent != NULL)
 798         gtk_window_set_transient_for (GTK_WINDOW (conf_note), parent);
 799
 800     /* Add the buttons from varargs */
 801     va_start(args, description);
 802
 803     while (TRUE) {
 804         message = va_arg (args, char *);
 805
 806         if (! message) {
 807             break;
 808         }
 809         value = va_arg (args, int);
 810
 811         button = gtk_dialog_add_button (GTK_DIALOG (conf_note), message, value);
 812         /* maemo-gtk is going to set the "no-show-all" property all
 813            cancel/close-like buttons to TRUE, so that they are not shown. On
 814            the other hand, this confirmation note with custom buttons should
 815            not obey this rule, so we need to make sure they are shown. */
 816         gtk_widget_show (button);
 817         gtk_widget_set_no_show_all (button, FALSE);
 818     }
 819
 820     va_end (args);
 821
 822     return conf_note;
 823 }
 824
 825
 826 /**
 827  * hildon_note_new_confirmation:
 828  * @parent: the parent window. The X window ID of the parent window
 829  *   has to be the same as the X window ID of the application. This is
 830  *   important so that the window manager could handle the windows
 831  *   correctly. In GTK the X window ID can be checked using
 832  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 833  * @description: the message to confirm
 834  *
 835  * Create a new confirmation note. Confirmation note has a text (description)
 836  * that you specify and two buttons.
 837  *
 838  * Returns: a #GtkWidget pointer of the note
 839  */
 840 GtkWidget*
 841 hildon_note_new_confirmation                    (GtkWindow *parent,
 842                                                  const gchar *description)
 843 {
 844     GtkWidget *dialog = NULL;
 845
 846     g_return_val_if_fail (description != NULL, NULL);
 847
 848     dialog = g_object_new (HILDON_TYPE_NOTE,
 849             "note-type",
 850             HILDON_NOTE_TYPE_CONFIRMATION,
 851             "description", description, NULL);
 852
 853     if (parent != NULL)
 854         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 855
 856     return dialog;
 857 }
 858
 859 /**
 860  * hildon_note_new_confirmation_with_icon_name:
 861  * @parent: the parent window. The X window ID of the parent window
 862  *   has to be the same as the X window ID of the application. This is
 863  *   important so that the window manager could handle the windows
 864  *   correctly. In GTK the X window ID can be checked using
 865  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 866  * @description: the message to confirm
 867  * @icon_name: icon to be displayed. If NULL, default icon is used.
 868  *
 869  * Create a new confirmation note. Confirmation note has a text (description)
 870  * that you specify and two buttons.
 871  *
 872  * Deprecated: Since 2.2, icons are not shown in confirmation notes. Icons set
 873  * with this function will be ignored. Use hildon_note_new_confirmation() instead.
 874  *
 875  * Returns: a #GtkWidget pointer of the note
 876  */
 877 GtkWidget*
 878 hildon_note_new_confirmation_with_icon_name     (GtkWindow *parent,
 879                                                  const gchar *description,
 880                                                  const gchar *icon_name)
 881 {
 882     GtkWidget *dialog;
 883
 884     dialog = hildon_note_new_confirmation (parent, description);
 885     g_object_set (dialog, "icon", icon_name, NULL);
 886
 887     return dialog;
 888 }
 889
 890 /**
 891  * hildon_note_new_information:
 892  * @parent: the parent window. The X window ID of the parent window
 893  *   has to be the same as the X window ID of the application. This is
 894  *   important so that the window manager could handle the windows
 895  *   correctly. In GTK the X window ID can be checked using
 896  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 897  * @description: the message to confirm
 898  *
 899  * Create a new information note. Information note has a text (description)
 900  * that you specify and an OK button.
 901  *
 902  * Returns: a #GtkWidget pointer of the note
 903  */
 904 GtkWidget*
 905 hildon_note_new_information                     (GtkWindow *parent,
 906                                                  const gchar *description)
 907 {
 908     GtkWidget *dialog = NULL;
 909
 910     g_return_val_if_fail (description != NULL, NULL);
 911
 912     dialog = g_object_new (HILDON_TYPE_NOTE,
 913             "note-type",
 914             HILDON_NOTE_TYPE_INFORMATION_THEME,
 915             "description", description, NULL);
 916
 917     if (parent != NULL)
 918         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 919
 920     return dialog;
 921 }
 922
 923 /**
 924  * hildon_note_new_information_with_icon_name:
 925  * @parent: the parent window. The X window ID of the parent window
 926  *   has to be the same as the X window ID of the application. This is
 927  *   important so that the window manager could handle the windows
 928  *   correctly. In GTK the X window ID can be checked using
 929  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 930  * @description: the message to confirm
 931  * @icon_name: icon to be displayed. If NULL, default icon is used.
 932  *
 933  * Create a new information note. Information note has text(description)
 934  * that you specify, an OK button and an icon.
 935  *
 936  * Deprecated: Since 2.2, icons are not shown in confirmation notes. Icons set
 937  * with this function will be ignored. Use hildon_note_new_information() instead.
 938  *
 939  * Returns: a #GtkWidget pointer of the note
 940  */
 941 GtkWidget*
 942 hildon_note_new_information_with_icon_name      (GtkWindow * parent,
 943                                                  const gchar *description,
 944                                                  const gchar *icon_name)
 945 {
 946     GtkWidget *dialog;
 947
 948     dialog = hildon_note_new_information (parent, description);
 949     g_object_set (dialog, "icon", icon_name, NULL);
 950
 951     return dialog;
 952 }
 953
 954 /* FIXME This documentation string LIES! */
 955
 956 /**
 957  * hildon_note_new_cancel_with_progress_bar:
 958  * @parent: the parent window. The X window ID of the parent window
 959  *   has to be the same as the X window ID of the application. This is
 960  *   important so that the window manager could handle the windows
 961  *   correctly. In GTK the X window ID can be checked using
 962  *   GDK_WINDOW_XID(GTK_WIDGET(parent)->window).
 963  * @description: the action to cancel
 964  * @progressbar: a pointer to #GtkProgressBar to be filled with the
 965  *   progressbar assigned to this note. Use this to set the fraction of
 966  *   progressbar done. This parameter can be %NULL as well, in which
 967  *   case plain text cancel note appears.
 968  *
 969  * Create a new cancel note with a progress bar. Cancel note has
 970  * text(description) that you specify, a Cancel button and a progress bar.
 971  *
 972  * Returns: a #GtkDialog. Use this to get rid of this note when you
 973  *   no longer need it.
 974  */
 975 GtkWidget*
 976 hildon_note_new_cancel_with_progress_bar        (GtkWindow *parent,
 977                                                  const gchar *description,
 978                                                  GtkProgressBar *progressbar)
 979 {
 980     GtkWidget *dialog = NULL;
 981
 982     g_return_val_if_fail (description != NULL, NULL);
 983
 984     dialog = g_object_new (HILDON_TYPE_NOTE,
 985             "note-type",
 986             HILDON_NOTE_TYPE_PROGRESSBAR,
 987             "description", description,
 988             "progressbar",
 989             progressbar, NULL);
 990
 991     if (parent != NULL)
 992         gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 993
 994     return dialog;
 995 }
 996
 997
 998 /**
 999  * hildon_note_set_button_text:
1000  * @note: a #HildonNote
1001  * @text: sets the button text and if there is two buttons in dialog,
1002  *   the button texts will be &lt;text&gt;, "Cancel".
1003  *
1004  * Sets the text of the button in @note.
1005  */
1006 void
1007 hildon_note_set_button_text                     (HildonNote *note,
1008                                                  const gchar *text)
1009 {
1010     HildonNotePrivate *priv;
1011
1012     g_return_if_fail (HILDON_IS_NOTE (note));
1013
1014     priv = HILDON_NOTE_GET_PRIVATE (HILDON_NOTE (note));
1015     g_assert (priv);
1016
1017     if (priv->okButton) {
1018         gtk_button_set_label (GTK_BUTTON (priv->okButton), text);
1019         gtk_button_set_label (GTK_BUTTON (priv->cancelButton),
1020                 _("wdgt_bd_no"));
1021     } else {
1022         gtk_button_set_label (GTK_BUTTON (priv->cancelButton), text);
1023     }
1024 }
1025
1026 /**
1027  * hildon_note_set_button_texts:
1028  * @note: a #HildonNote
1029  * @text_ok: the new text of the default OK button
1030  * @text_cancel: the new text of the default cancel button
1031  *
1032  * Sets the text for the buttons in @note.
1033  */
1034 void
1035 hildon_note_set_button_texts                    (HildonNote *note,
1036                                                  const gchar *text_ok,
1037                                                  const gchar *text_cancel)
1038 {
1039     HildonNotePrivate *priv;
1040
1041     g_return_if_fail (HILDON_IS_NOTE (note));
1042
1043     priv = HILDON_NOTE_GET_PRIVATE (HILDON_NOTE (note));
1044     g_assert (priv);
1045
1046     if (priv->okButton) {
1047         gtk_button_set_label (GTK_BUTTON (priv->okButton), text_ok);
1048         gtk_button_set_label (GTK_BUTTON (priv->cancelButton), text_cancel);
1049     } else {
1050         gtk_button_set_label (GTK_BUTTON (priv->cancelButton), text_cancel);
1051     }
1052 }
1053
1054 static void
1055 on_show_cb                                      (GtkWidget *widget,
1056                                                  gpointer data)
1057 {
1058     HildonNotePrivate *priv;
1059
1060     priv = HILDON_NOTE_GET_PRIVATE (widget);
1061     priv->idle_handler = g_idle_add (sound_handling, widget);
1062 }
1063
1064 /* We play a system sound when the note comes visible */
1065 static gboolean
1066 sound_handling                                  (gpointer data)
1067 {
1068     HildonNotePrivate *priv = HILDON_NOTE_GET_PRIVATE (data);
1069     g_assert (priv);
1070
1071     switch (priv->note_n)
1072     {
1073         case HILDON_NOTE_TYPE_INFORMATION:
1074         case HILDON_NOTE_TYPE_INFORMATION_THEME:
1075             hildon_play_system_sound (INFORMATION_SOUND_PATH);
1076             break;
1077
1078         case HILDON_NOTE_TYPE_CONFIRMATION:
1079         case HILDON_NOTE_TYPE_CONFIRMATION_BUTTON:
1080             hildon_play_system_sound (CONFIRMATION_SOUND_PATH);
1081             break;
1082
1083         default:
1084             break;
1085     };
1086
1087     priv->idle_handler = 0;
1088
1089     return FALSE;
1090 }