composer/e-composer-header.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
   2
   3 /*
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) version 3.
   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 GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with the program; if not, see <http://www.gnu.org/licenses/>
  17  *
  18  *
  19  * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include "e-composer-header.h"
  28
  29 #include <glib/gi18n.h>
  30
  31 enum {
  32         PROP_0,
  33         PROP_BUTTON,
  34         PROP_LABEL,
  35         PROP_SENSITIVE,
  36         PROP_VISIBLE
  37 };
  38
  39 enum {
  40         CHANGED,
  41         CLICKED,
  42         LAST_SIGNAL
  43 };
  44
  45 struct _EComposerHeaderPrivate {
  46         gchar *label;
  47         gboolean button;
  48         GtkWidget *action_label;
  49
  50         GtkWidget *add_icon;
  51         GtkWidget *remove_icon;
  52         GtkWidget *show_label;
  53         GtkWidget *hide_label;
  54
  55         guint sensitive : 1;
  56         guint visible   : 1;
  57 };
  58
  59 static guint signal_ids[LAST_SIGNAL];
  60
  61 G_DEFINE_ABSTRACT_TYPE (
  62         EComposerHeader,
  63         e_composer_header,
  64         G_TYPE_OBJECT)
  65
  66 static void
  67 composer_header_button_clicked_cb (GtkButton *button,
  68                                    EComposerHeader *header)
  69 {
  70         gtk_widget_grab_focus (header->input_widget);
  71         g_signal_emit (header, signal_ids[CLICKED], 0);
  72 }
  73
  74 static GObject *
  75 composer_header_constructor (GType type,
  76                              guint n_construct_properties,
  77                              GObjectConstructParam *construct_properties)
  78 {
  79         GObject *object;
  80         GtkWidget *widget;
  81         EComposerHeader *header;
  82         GtkWidget *label;
  83
  84         /* Chain up to parent's constructor() method. */
  85         object = G_OBJECT_CLASS (
  86                 e_composer_header_parent_class)->constructor (
  87                 type, n_construct_properties, construct_properties);
  88
  89         header = E_COMPOSER_HEADER (object);
  90
  91         if (header->priv->button) {
  92                 widget = gtk_button_new_with_mnemonic (header->priv->label);
  93                 gtk_widget_set_can_focus (widget, FALSE);
  94                 g_signal_connect (
  95                         widget, "clicked",
  96                         G_CALLBACK (composer_header_button_clicked_cb),
  97                         header);
  98                 label = gtk_bin_get_child (GTK_BIN (widget));
  99         } else {
 100                 widget = gtk_label_new_with_mnemonic (header->priv->label);
 101                 gtk_label_set_mnemonic_widget (GTK_LABEL (widget), header->input_widget);
 102                 label = widget;
 103         }
 104
 105         gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
 106
 107         header->priv->action_label = NULL;
 108
 109         header->title_widget = g_object_ref_sink (widget);
 110
 111         g_free (header->priv->label);
 112         header->priv->label = NULL;
 113
 114         return object;
 115 }
 116
 117 static void
 118 composer_header_set_property (GObject *object,
 119                               guint property_id,
 120                               const GValue *value,
 121                               GParamSpec *pspec)
 122 {
 123         EComposerHeaderPrivate *priv;
 124
 125         priv = E_COMPOSER_HEADER (object)->priv;
 126
 127         switch (property_id) {
 128                 case PROP_BUTTON:       /* construct only */
 129                         priv->button = g_value_get_boolean (value);
 130                         return;
 131
 132                 case PROP_LABEL:        /* construct only */
 133                         priv->label = g_value_dup_string (value);
 134                         return;
 135
 136                 case PROP_SENSITIVE:
 137                         e_composer_header_set_sensitive (
 138                                 E_COMPOSER_HEADER (object),
 139                                 g_value_get_boolean (value));
 140                         return;
 141
 142                 case PROP_VISIBLE:
 143                         e_composer_header_set_visible (
 144                                 E_COMPOSER_HEADER (object),
 145                                 g_value_get_boolean (value));
 146                         return;
 147         }
 148
 149         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 150 }
 151
 152 static void
 153 composer_header_get_property (GObject *object,
 154                               guint property_id,
 155                               GValue *value,
 156                               GParamSpec *pspec)
 157 {
 158         EComposerHeaderPrivate *priv;
 159
 160         priv = E_COMPOSER_HEADER (object)->priv;
 161
 162         switch (property_id) {
 163                 case PROP_BUTTON:       /* construct only */
 164                         g_value_set_boolean (value, priv->button);
 165                         return;
 166
 167                 case PROP_LABEL:        /* construct only */
 168                         g_value_take_string (
 169                                 value, e_composer_header_get_label (
 170                                 E_COMPOSER_HEADER (object)));
 171                         return;
 172
 173                 case PROP_SENSITIVE:
 174                         g_value_set_boolean (
 175                                 value, e_composer_header_get_sensitive (
 176                                 E_COMPOSER_HEADER (object)));
 177                         return;
 178
 179                 case PROP_VISIBLE:
 180                         g_value_set_boolean (
 181                                 value, e_composer_header_get_visible (
 182                                 E_COMPOSER_HEADER (object)));
 183                         return;
 184         }
 185
 186         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 187 }
 188
 189 static void
 190 composer_header_dispose (GObject *object)
 191 {
 192         EComposerHeader *header = E_COMPOSER_HEADER (object);
 193
 194         if (header->title_widget != NULL) {
 195                 g_object_unref (header->title_widget);
 196                 header->title_widget = NULL;
 197         }
 198
 199         if (header->input_widget != NULL) {
 200                 g_object_unref (header->input_widget);
 201                 header->input_widget = NULL;
 202         }
 203
 204         /* Chain up to parent's dispose() method. */
 205         G_OBJECT_CLASS (e_composer_header_parent_class)->dispose (object);
 206 }
 207
 208 static void
 209 e_composer_header_class_init (EComposerHeaderClass *class)
 210 {
 211         GObjectClass *object_class;
 212
 213         g_type_class_add_private (class, sizeof (EComposerHeaderPrivate));
 214
 215         object_class = G_OBJECT_CLASS (class);
 216         object_class->constructor = composer_header_constructor;
 217         object_class->set_property = composer_header_set_property;
 218         object_class->get_property = composer_header_get_property;
 219         object_class->dispose = composer_header_dispose;
 220
 221         g_object_class_install_property (
 222                 object_class,
 223                 PROP_BUTTON,
 224                 g_param_spec_boolean (
 225                         "button",
 226                         NULL,
 227                         NULL,
 228                         FALSE,
 229                         G_PARAM_READWRITE |
 230                         G_PARAM_CONSTRUCT_ONLY));
 231
 232         g_object_class_install_property (
 233                 object_class,
 234                 PROP_LABEL,
 235                 g_param_spec_string (
 236                         "label",
 237                         NULL,
 238                         NULL,
 239                         NULL,
 240                         G_PARAM_READWRITE |
 241                         G_PARAM_CONSTRUCT_ONLY));
 242
 243         g_object_class_install_property (
 244                 object_class,
 245                 PROP_SENSITIVE,
 246                 g_param_spec_boolean (
 247                         "sensitive",
 248                         NULL,
 249                         NULL,
 250                         FALSE,
 251                         G_PARAM_READWRITE));
 252
 253         g_object_class_install_property (
 254                 object_class,
 255                 PROP_VISIBLE,
 256                 g_param_spec_boolean (
 257                         "visible",
 258                         NULL,
 259                         NULL,
 260                         FALSE,
 261                         G_PARAM_READWRITE));
 262
 263         signal_ids[CHANGED] = g_signal_new (
 264                 "changed",
 265                 G_TYPE_FROM_CLASS (class),
 266                 G_SIGNAL_RUN_LAST,
 267                 G_STRUCT_OFFSET (EComposerHeaderClass, changed),
 268                 NULL, NULL,
 269                 g_cclosure_marshal_VOID__VOID,
 270                 G_TYPE_NONE, 0);
 271
 272         signal_ids[CLICKED] = g_signal_new (
 273                 "clicked",
 274                 G_TYPE_FROM_CLASS (class),
 275                 G_SIGNAL_RUN_LAST,
 276                 G_STRUCT_OFFSET (EComposerHeaderClass, clicked),
 277                 NULL, NULL,
 278                 g_cclosure_marshal_VOID__VOID,
 279                 G_TYPE_NONE, 0);
 280 }
 281
 282 static void
 283 e_composer_header_init (EComposerHeader *header)
 284 {
 285         header->priv = G_TYPE_INSTANCE_GET_PRIVATE (
 286                 header, E_TYPE_COMPOSER_HEADER, EComposerHeaderPrivate);
 287 }
 288
 289 gchar *
 290 e_composer_header_get_label (EComposerHeader *header)
 291 {
 292         gchar *label;
 293
 294         g_return_val_if_fail (E_IS_COMPOSER_HEADER (header), NULL);
 295
 296         /* GtkButton and GtkLabel both have a "label" property. */
 297         g_object_get (header->title_widget, "label", &label, NULL);
 298
 299         return label;
 300 }
 301
 302 gboolean
 303 e_composer_header_get_sensitive (EComposerHeader *header)
 304 {
 305         g_return_val_if_fail (E_IS_COMPOSER_HEADER (header), FALSE);
 306
 307         return header->priv->sensitive;
 308 }
 309
 310 void
 311 e_composer_header_set_sensitive (EComposerHeader *header,
 312                                  gboolean sensitive)
 313 {
 314         g_return_if_fail (E_IS_COMPOSER_HEADER (header));
 315
 316         header->priv->sensitive = sensitive;
 317
 318         g_object_notify (G_OBJECT (header), "sensitive");
 319 }
 320
 321 gboolean
 322 e_composer_header_get_visible (EComposerHeader *header)
 323 {
 324         g_return_val_if_fail (E_IS_COMPOSER_HEADER (header), FALSE);
 325
 326         return header->priv->visible;
 327 }
 328
 329 void
 330 e_composer_header_set_visible (EComposerHeader *header,
 331                                gboolean visible)
 332 {
 333         g_return_if_fail (E_IS_COMPOSER_HEADER (header));
 334
 335         header->priv->visible = visible;
 336
 337         if (header->priv->action_label) {
 338                 if (!visible) {
 339                         gtk_widget_show (header->priv->add_icon);
 340                         gtk_widget_show (header->priv->show_label);
 341                         gtk_widget_hide (header->priv->remove_icon);
 342                         gtk_widget_hide (header->priv->hide_label);
 343                 } else {
 344                         gtk_widget_hide (header->priv->add_icon);
 345                         gtk_widget_hide (header->priv->show_label);
 346                         gtk_widget_show (header->priv->remove_icon);
 347                         gtk_widget_show (header->priv->hide_label);
 348                 }
 349         }
 350
 351         g_object_notify (G_OBJECT (header), "visible");
 352 }
 353
 354 void
 355 e_composer_header_set_title_tooltip (EComposerHeader *header,
 356                                      const gchar *tooltip)
 357 {
 358         g_return_if_fail (E_IS_COMPOSER_HEADER (header));
 359
 360         gtk_widget_set_tooltip_text (header->title_widget, tooltip);
 361 }
 362
 363 void
 364 e_composer_header_set_input_tooltip (EComposerHeader *header,
 365                                      const gchar *tooltip)
 366 {
 367         g_return_if_fail (E_IS_COMPOSER_HEADER (header));
 368
 369         gtk_widget_set_tooltip_text (header->input_widget, tooltip);
 370 }