vcs.maemo.org Git - hildon/blob - src/hildon-picker-button.c

   1 /*
   2  * This file is a part of hildon
   3  *
   4  * Copyright (C) 2008 Nokia Corporation, all rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser Public License as published by
   8  * the Free Software Foundation; version 2 of the license.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Lesser Public License for more details.
  14  *
  15  */
  16
  17 /**
  18  * SECTION:hildon-picker-button
  19  * @short_description: A button that launches a #HildonPickerDialog and displays the
  20  * selected item
  21  * @see_also: #HildonTouchSelector, #HildonPickerDialog
  22  *
  23  * #HildonPickerButton is a widget that lets the user select a particular item from
  24  * a list. Visually, it's a button with title and value labels that brings up a
  25  * #HildonPickerDialog. The user can then use this dialog to choose an item, which
  26  * will be displayed in the value label of the button.
  27  *
  28  * You should create your own #HildonTouchSelector at convenience and set it
  29  * to the #HildonPickerButton with hildon_picker_button_set_selector(). For
  30  * the common use cases of buttons to select date and time, you can use #HildonDateButton
  31  * and #HildonTimeButton.
  32  *
  33  * <example>
  34  * <programlisting>
  35  * GtkWidget *
  36  * create_selector (void)
  37  * {
  38  *   GtkWidget *selector;
  39  * <!-- -->
  40  *   selector = hildon_touch_selector_new_text ();
  41  * <!-- -->
  42  *   hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector), "America");
  43  *   hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector), "Europe");
  44  *   hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector), "Asia");
  45  *   hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector), "Africa");
  46  *   hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector), "Australia");
  47  * <!-- -->
  48  *   hildon_touch_selector_set_active (HILDON_TOUCH_SELECTOR (selector), 0, 2);
  49  * <!-- -->
  50  *   return selector;
  51  * }
  52  * <!-- -->
  53  * GtkWidget *
  54  * create_button (HildonTouchSelector *selector)
  55  * {
  56  *   GtkWidget *button;
  57  * <!-- -->
  58  *   button = hildon_picker_button_new (HILDON_SIZE_AUTO, HILDON_BUTTON_ARRANGEMENT_VERTICAL);
  59  *   hildon_button_set_title (HILDON_BUTTON (button), "Continent");
  60  * <!-- -->
  61  *   hildon_picker_button_set_selector (HILDON_PICKER_BUTTON (button),
  62  *                                      HILDON_TOUCH_SELECTOR (selector));
  63  * <!-- -->
  64  *   return button;
  65  * }
  66  * </programlisting>
  67  * </example>
  68  */
  69
  70 #include "hildon-picker-button.h"
  71 #include "hildon-picker-button-private.h"
  72 #include "hildon-picker-dialog.h"
  73
  74 G_DEFINE_TYPE (HildonPickerButton, hildon_picker_button, HILDON_TYPE_BUTTON)
  75
  76 #define GET_PRIVATE(o)                                                  \
  77   (G_TYPE_INSTANCE_GET_PRIVATE ((o), HILDON_TYPE_PICKER_BUTTON, HildonPickerButtonPrivate))
  78
  79 typedef struct _HildonPickerButtonPrivate HildonPickerButtonPrivate;
  80
  81 struct _HildonPickerButtonPrivate
  82 {
  83   GtkWidget *selector;
  84   GtkWidget *dialog;
  85   gchar *done_button_text;
  86   guint disable_value_changed : 1;
  87 };
  88
  89 /* Signals */
  90 enum
  91 {
  92   VALUE_CHANGED,
  93   LAST_SIGNAL
  94 };
  95
  96 enum
  97 {
  98   PROP_SELECTOR = 1,
  99   PROP_DONE_BUTTON_TEXT
 100 };
 101
 102 static guint picker_button_signals[LAST_SIGNAL] = { 0 };
 103
 104 static gboolean
 105 _current_selector_empty                         (HildonPickerButton *button);
 106
 107 static void
 108 hildon_picker_button_selector_selection_changed (HildonTouchSelector * selector,
 109                                                  gint column,
 110                                                  gpointer user_data);
 111
 112 static void
 113 hildon_picker_button_selector_columns_changed   (HildonTouchSelector * selector,
 114                                                  gpointer user_data);
 115
 116
 117 static void
 118 hildon_picker_button_get_property (GObject * object, guint property_id,
 119                                    GValue * value, GParamSpec * pspec)
 120 {
 121   switch (property_id) {
 122   case PROP_SELECTOR:
 123     g_value_set_object (value,
 124                         hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (object)));
 125     break;
 126   case PROP_DONE_BUTTON_TEXT:
 127     g_value_set_string (value,
 128                         hildon_picker_button_get_done_button_text (HILDON_PICKER_BUTTON (object)));
 129     break;
 130   default:
 131     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 132   }
 133 }
 134
 135 static void
 136 hildon_picker_button_set_property (GObject * object, guint property_id,
 137                                    const GValue * value, GParamSpec * pspec)
 138 {
 139   switch (property_id) {
 140   case PROP_SELECTOR:
 141     hildon_picker_button_set_selector (HILDON_PICKER_BUTTON (object),
 142                                        g_value_get_object (value));
 143     break;
 144   case PROP_DONE_BUTTON_TEXT:
 145     hildon_picker_button_set_done_button_text (HILDON_PICKER_BUTTON (object),
 146                                                g_value_get_string (value));
 147     break;
 148   default:
 149     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 150   }
 151 }
 152
 153 static void
 154 hildon_picker_button_finalize (GObject * object)
 155 {
 156   HildonPickerButtonPrivate *priv;
 157
 158   priv = GET_PRIVATE (object);
 159
 160   if (priv->selector) {
 161     g_signal_handlers_disconnect_by_func (priv->selector,
 162                                           hildon_picker_button_selector_selection_changed,
 163                                           object);
 164     g_signal_handlers_disconnect_by_func (priv->selector,
 165                                           hildon_picker_button_selector_columns_changed,
 166                                           object);
 167     g_object_unref (priv->selector);
 168     priv->selector = NULL;
 169   }
 170   if (priv->dialog) {
 171     gtk_widget_destroy (priv->dialog);
 172     priv->dialog = NULL;
 173   }
 174
 175   if (priv->done_button_text) {
 176     g_free (priv->done_button_text);
 177     priv->done_button_text = NULL;
 178   }
 179
 180   G_OBJECT_CLASS (hildon_picker_button_parent_class)->finalize (object);
 181 }
 182
 183 /**
 184  * hildon_picker_button_value_changed:
 185  * @button: a #HildonPickerButton
 186  *
 187  * Emits a "#HildonPickerButton::value-changed" signal to the given
 188  * #HildonPickerButton
 189  **/
 190 void
 191 hildon_picker_button_value_changed              (HildonPickerButton *button)
 192 {
 193   HildonPickerButtonPrivate *priv;
 194   g_return_if_fail (HILDON_IS_PICKER_BUTTON (button));
 195   priv = GET_PRIVATE (button);
 196
 197   if (!priv->disable_value_changed)
 198     g_signal_emit (button, picker_button_signals[VALUE_CHANGED], 0);
 199 }
 200
 201 G_GNUC_INTERNAL void
 202 hildon_picker_button_disable_value_changed      (HildonPickerButton *button,
 203                                                  gboolean            disable)
 204 {
 205   HildonPickerButtonPrivate *priv;
 206   g_return_if_fail (HILDON_IS_PICKER_BUTTON (button));
 207   priv = GET_PRIVATE (button);
 208
 209   priv->disable_value_changed = disable;
 210 }
 211
 212 static void
 213 _selection_changed (HildonPickerButton *button)
 214 {
 215   HildonPickerButtonPrivate *priv = GET_PRIVATE (button);
 216
 217   if (!GTK_IS_WINDOW (priv->dialog) ||
 218       !GTK_WIDGET_VISIBLE (GTK_WINDOW (priv->dialog))) {
 219     gchar *value = hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (priv->selector));
 220     if (value) {
 221       hildon_button_set_value (HILDON_BUTTON (button), value);
 222       g_free (value);
 223       hildon_picker_button_value_changed (button);
 224     }
 225   }
 226 }
 227
 228 static void
 229 hildon_picker_button_on_dialog_response (GtkDialog *dialog,
 230                                          gint       response,
 231                                          gpointer   user_data)
 232 {
 233   HildonPickerButton *button;
 234   HildonPickerButtonPrivate *priv;
 235   gchar *value;
 236
 237   button = HILDON_PICKER_BUTTON (user_data);
 238   priv = GET_PRIVATE (button);
 239
 240   if (response == GTK_RESPONSE_OK) {
 241     value = hildon_touch_selector_get_current_text
 242             (HILDON_TOUCH_SELECTOR (priv->selector));
 243     hildon_button_set_value (HILDON_BUTTON (button), value);
 244     g_free (value);
 245     hildon_picker_button_value_changed (button);
 246   }
 247
 248   gtk_widget_hide (GTK_WIDGET (dialog));
 249 }
 250
 251 static void
 252 hildon_picker_button_clicked (GtkButton * button)
 253 {
 254   GtkWidget *parent;
 255   HildonPickerButtonPrivate *priv;
 256
 257   priv = GET_PRIVATE (HILDON_PICKER_BUTTON (button));
 258
 259   g_return_if_fail (HILDON_IS_TOUCH_SELECTOR (priv->selector));
 260
 261   /* Create the dialog if it doesn't exist already.  */
 262   if (!priv->dialog) {
 263     parent = gtk_widget_get_toplevel (GTK_WIDGET (button));
 264     if (GTK_WIDGET_TOPLEVEL (parent)) {
 265       priv->dialog = hildon_picker_dialog_new (GTK_WINDOW (parent));
 266     } else {
 267       priv->dialog = hildon_picker_dialog_new (NULL);
 268     }
 269
 270     hildon_picker_dialog_set_selector (HILDON_PICKER_DIALOG (priv->dialog),
 271                                        HILDON_TOUCH_SELECTOR (priv->selector));
 272     if (priv->done_button_text) {
 273       hildon_picker_dialog_set_done_label (HILDON_PICKER_DIALOG (priv->dialog),
 274                                            priv->done_button_text);
 275     }
 276
 277     gtk_window_set_modal (GTK_WINDOW (priv->dialog),
 278                           gtk_window_get_modal (GTK_WINDOW (parent)));
 279     gtk_window_set_title (GTK_WINDOW (priv->dialog),
 280                           hildon_button_get_title (HILDON_BUTTON (button)));
 281     g_signal_connect (priv->dialog, "response",
 282                       G_CALLBACK (hildon_picker_button_on_dialog_response),
 283                       button);
 284     g_signal_connect (priv->dialog, "delete-event",
 285                       G_CALLBACK (gtk_widget_hide_on_delete),
 286                       NULL);
 287   }
 288
 289   if (_current_selector_empty (HILDON_PICKER_BUTTON (button))) {
 290     g_warning ("There are no elements in the selector. Nothing to show.");
 291   } {
 292     gtk_window_present (GTK_WINDOW (priv->dialog));
 293   }
 294 }
 295
 296 static void
 297 hildon_picker_button_selector_selection_changed (HildonTouchSelector * selector,
 298                                                  gint column,
 299                                                  gpointer user_data)
 300
 301 {
 302   _selection_changed (HILDON_PICKER_BUTTON (user_data));
 303 }
 304
 305 static void
 306 hildon_picker_button_selector_columns_changed (HildonTouchSelector * selector,
 307                                                gpointer user_data)
 308
 309 {
 310   _selection_changed (HILDON_PICKER_BUTTON (user_data));
 311 }
 312
 313 static void
 314 hildon_picker_button_class_init (HildonPickerButtonClass * klass)
 315 {
 316   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 317   GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass);
 318
 319   g_type_class_add_private (klass, sizeof (HildonPickerButtonPrivate));
 320
 321   object_class->get_property = hildon_picker_button_get_property;
 322   object_class->set_property = hildon_picker_button_set_property;
 323   object_class->finalize = hildon_picker_button_finalize;
 324
 325   button_class->clicked = hildon_picker_button_clicked;
 326
 327   g_object_class_install_property (object_class,
 328                                    PROP_SELECTOR,
 329                                    g_param_spec_object ("touch-selector",
 330                                                         "HildonTouchSelector widget",
 331                                                         "HildonTouchSelector widget to be launched on button clicked",
 332                                                         HILDON_TYPE_TOUCH_SELECTOR,
 333                                                         G_PARAM_READWRITE));
 334   g_object_class_install_property (object_class,
 335                                    PROP_DONE_BUTTON_TEXT,
 336                                    g_param_spec_string ("done-button-text",
 337                                                         "HildonPickerDialog \"done\" button text",
 338                                                         "The text for the \"done\" button in the dialog launched",
 339                                                         NULL,
 340                                                         G_PARAM_READWRITE));
 341
 342   /**
 343    * HildonPickerButton::value-changed:
 344    * @widget: the widget that received the signal
 345    *
 346    * The ::value-changed signal is emitted each time the user chooses a different
 347    * item from the #HildonTouchSelector related, and the value label gets updated.
 348    *
 349    * Since: 2.2
 350    */
 351   picker_button_signals[VALUE_CHANGED] =
 352     g_signal_new ("value-changed",
 353                   G_TYPE_FROM_CLASS (klass),
 354                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 355                   0,
 356                   NULL, NULL,
 357                   g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, NULL);
 358 }
 359
 360 static void
 361 hildon_picker_button_init (HildonPickerButton * self)
 362 {
 363   HildonPickerButtonPrivate *priv;
 364
 365   priv = GET_PRIVATE (self);
 366
 367   priv->dialog = NULL;
 368   priv->selector = NULL;
 369   priv->done_button_text = NULL;
 370   priv->disable_value_changed = FALSE;
 371
 372   hildon_button_set_style (HILDON_BUTTON (self),
 373                            HILDON_BUTTON_STYLE_PICKER);
 374 }
 375
 376 static gboolean
 377 _current_selector_empty (HildonPickerButton *button)
 378 {
 379   HildonPickerButtonPrivate *priv;
 380   HildonTouchSelector *selector = NULL;
 381   GtkTreeModel *model = NULL;
 382   GtkTreeIter iter;
 383   gint i = 0;
 384
 385   priv = GET_PRIVATE (button);
 386   selector = HILDON_TOUCH_SELECTOR (priv->selector);
 387
 388   g_return_val_if_fail (HILDON_IS_TOUCH_SELECTOR (selector), TRUE);
 389
 390   if (hildon_touch_selector_has_multiple_selection (selector)) {
 391     return FALSE;
 392   } else {
 393     for (i=0; i < hildon_touch_selector_get_num_columns (selector); i++) {
 394       model = hildon_touch_selector_get_model (selector, i);
 395
 396       if (gtk_tree_model_get_iter_first (model, &iter)) {
 397         return FALSE;
 398       }
 399     }
 400     return TRUE;
 401   }
 402 }
 403
 404 /**
 405  * hildon_picker_button_new:
 406  * @size: One of #HildonSizeType, specifying the size of the new button.
 407  * @arrangement: one of #HildonButtonArrangement, specifying the placement of the
 408  * labels.
 409  *
 410  * Creates a new #HildonPickerButton. See hildon_button_new() for details on the
 411  * parameters.
 412  *
 413  * Returns: a newly created #HildonPickerButton
 414  *
 415  * Since: 2.2
 416  **/
 417 GtkWidget *
 418 hildon_picker_button_new (HildonSizeType          size,
 419                           HildonButtonArrangement arrangement)
 420 {
 421   GtkWidget *button;
 422
 423   button = g_object_new (HILDON_TYPE_PICKER_BUTTON,
 424                          "arrangement", arrangement, "size", size,
 425                          NULL);
 426
 427   return button;
 428 }
 429
 430 /**
 431  * hildon_picker_button_set_selector:
 432  * @button: a #HildonPickerButton
 433  * @selector: a #HildonTouchSelector
 434  *
 435  * Sets @selector as the #HildonTouchSelector to be shown in the
 436  * #HildonPickerDialog that @button brings up.
 437  *
 438  * Since: 2.2
 439  **/
 440 void
 441 hildon_picker_button_set_selector (HildonPickerButton * button,
 442                                    HildonTouchSelector * selector)
 443 {
 444   HildonPickerButtonPrivate *priv;
 445   gchar *value = NULL;
 446
 447   g_return_if_fail (HILDON_IS_PICKER_BUTTON (button));
 448   g_return_if_fail (!selector || HILDON_IS_TOUCH_SELECTOR (selector));
 449
 450   priv = GET_PRIVATE (button);
 451
 452   if (priv->selector) {
 453     g_signal_handlers_disconnect_by_func (priv->selector,
 454                                           hildon_picker_button_selector_selection_changed,
 455                                           button);
 456     g_signal_handlers_disconnect_by_func (priv->selector,
 457                                           hildon_picker_button_selector_columns_changed,
 458                                           button);
 459     g_object_unref (priv->selector);
 460   }
 461
 462   priv->selector = GTK_WIDGET (selector);
 463
 464   if (selector) {
 465     g_object_ref (selector);
 466
 467     g_signal_connect (G_OBJECT (selector), "changed",
 468                       G_CALLBACK (hildon_picker_button_selector_selection_changed),
 469                       button);
 470
 471     g_signal_connect (G_OBJECT (selector), "columns-changed",
 472                       G_CALLBACK (hildon_picker_button_selector_columns_changed),
 473                       button);
 474
 475     value = hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (priv->selector));
 476   }
 477
 478   if (!value)
 479     value = g_strdup ("");
 480
 481   hildon_button_set_value (HILDON_BUTTON (button), value);
 482   hildon_picker_button_value_changed (button);
 483
 484   g_free (value);
 485 }
 486
 487 /**
 488  * hildon_picker_button_get_selector:
 489  * @button: a #HildonPickerButton
 490  *
 491  * Retrieves the #HildonTouchSelector associated to @button.
 492  *
 493  * Returns: a #HildonTouchSelector
 494  *
 495  * Since: 2.2
 496  **/
 497 HildonTouchSelector *
 498 hildon_picker_button_get_selector (HildonPickerButton * button)
 499 {
 500   HildonPickerButtonPrivate *priv;
 501
 502   g_return_val_if_fail (HILDON_IS_PICKER_BUTTON (button), NULL);
 503
 504   priv = GET_PRIVATE (button);
 505
 506   return HILDON_TOUCH_SELECTOR (priv->selector);
 507 }
 508
 509 /**
 510  * hildon_picker_button_get_active:
 511  * @button: a #HildonPickerButton
 512  *
 513  * Returns the index of the currently active item, or -1 if there's no
 514  * active item. If the selector has several columns, only the first
 515  * one is used.
 516  *
 517  * Returns: an integer which is the index of the currently active item, or -1 if there's no active item.
 518  *
 519  * Since: 2.2
 520  **/
 521 gint
 522 hildon_picker_button_get_active                 (HildonPickerButton * button)
 523 {
 524   HildonTouchSelector *sel;
 525   g_return_val_if_fail (HILDON_IS_PICKER_BUTTON (button), -1);
 526
 527   sel = hildon_picker_button_get_selector (button);
 528
 529   return hildon_touch_selector_get_active (sel, 0);
 530 }
 531
 532 /**
 533  * hildon_picker_button_set_active:
 534  * @button: a #HildonPickerButton
 535  * @index: the index of the item to select, or -1 to have no active item
 536  *
 537  * Sets the active item of the #HildonTouchSelector associated to
 538  * @button to @index. If the selector has several columns, only the
 539  * first one is used.
 540  *
 541  * Since: 2.2
 542  **/
 543 void
 544 hildon_picker_button_set_active                 (HildonPickerButton * button,
 545                                                  gint index)
 546 {
 547   HildonTouchSelector *sel;
 548   gchar *text;
 549   g_return_if_fail (HILDON_IS_PICKER_BUTTON (button));
 550
 551   sel = hildon_picker_button_get_selector (button);
 552   hildon_touch_selector_set_active (sel, 0, index);
 553
 554   text = hildon_touch_selector_get_current_text (sel);
 555   hildon_button_set_value (HILDON_BUTTON (button), text);
 556   g_free (text);
 557 }
 558
 559 /**
 560  * hildon_picker_button_get_done_button_text:
 561  * @button: a #HildonPickerButton
 562  *
 563  * Gets the text used in the #HildonPickerDialog that is launched by
 564  * @button. If no custom text is set, then %NULL is returned.
 565  *
 566  * Returns: the custom string to be used, or %NULL if the default
 567  * #HildonPickerDialog::done-button-text is to be used.
 568  *
 569  * Since: 2.2
 570  **/
 571 const gchar *
 572 hildon_picker_button_get_done_button_text (HildonPickerButton *button)
 573 {
 574   HildonPickerButtonPrivate *priv;
 575
 576   g_return_val_if_fail (HILDON_IS_PICKER_BUTTON (button), NULL);
 577
 578   priv = GET_PRIVATE (button);
 579
 580   return priv->done_button_text;
 581 }
 582
 583 /**
 584  * hildon_picker_button_set_done_button_text:
 585  * @button: a #HildonPickerButton
 586  * @done_button_text: a string
 587  *
 588  * Sets a custom string to be used in the "done" button in #HildonPickerDialog.
 589  * If unset, the default HildonPickerButton::done-button-text property
 590  * value will be used.
 591  *
 592  * Since: 2.2
 593  **/
 594 void
 595 hildon_picker_button_set_done_button_text (HildonPickerButton *button,
 596                                            const gchar *done_button_text)
 597 {
 598   HildonPickerButtonPrivate *priv;
 599
 600   g_return_if_fail (HILDON_IS_PICKER_BUTTON (button));
 601   g_return_if_fail (done_button_text != NULL);
 602
 603   priv = GET_PRIVATE (button);
 604
 605   g_free (priv->done_button_text);
 606   priv->done_button_text = g_strdup (done_button_text);
 607
 608   if (priv->dialog) {
 609     hildon_picker_dialog_set_done_label (HILDON_PICKER_DIALOG (priv->dialog),
 610                                          priv->done_button_text);
 611   }
 612 }