pidgin/minidialog.c

   1 /**
   2  * @file minidialog.c Implementation of the #PidginMiniDialog Gtk widget.
   3  * @ingroup pidgin
   4  */
   5
   6 /* pidgin
   7  *
   8  * Pidgin is the legal property of its developers, whose names are too numerous
   9  * to list here.  Please refer to the COPYRIGHT file distributed with this
  10  * source distribution.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  */
  26
  27 #include "internal.h"
  28
  29 #include <gtk/gtk.h>
  30
  31 #include "libpurple/prefs.h"
  32
  33 #include "pidgin/minidialog.h"
  34 #include "pidgin/pidgin.h"
  35 #include "pidgin/pidginstock.h"
  36
  37 static void     pidgin_mini_dialog_init       (PidginMiniDialog      *self);
  38 static void     pidgin_mini_dialog_class_init (PidginMiniDialogClass *klass);
  39
  40 static gpointer pidgin_mini_dialog_parent_class = NULL;
  41
  42 static void
  43 pidgin_mini_dialog_class_intern_init (gpointer klass)
  44 {
  45         pidgin_mini_dialog_parent_class = g_type_class_peek_parent (klass);
  46         pidgin_mini_dialog_class_init ((PidginMiniDialogClass*) klass);
  47 }
  48
  49 GType
  50 pidgin_mini_dialog_get_type (void)
  51 {
  52         static GType g_define_type_id = 0;
  53         if (g_define_type_id == 0)
  54         {
  55                 static const GTypeInfo g_define_type_info = {
  56                         sizeof (PidginMiniDialogClass),
  57                         (GBaseInitFunc) NULL,
  58                         (GBaseFinalizeFunc) NULL,
  59                         (GClassInitFunc) pidgin_mini_dialog_class_intern_init,
  60                         (GClassFinalizeFunc) NULL,
  61                         NULL,   /* class_data */
  62                         sizeof (PidginMiniDialog),
  63                         0,      /* n_preallocs */
  64                         (GInstanceInitFunc) pidgin_mini_dialog_init,
  65                         NULL,
  66                 };
  67                 g_define_type_id = g_type_register_static (GTK_TYPE_VBOX,
  68                         "PidginMiniDialog", &g_define_type_info, 0);
  69         }
  70         return g_define_type_id;
  71 }
  72
  73 enum
  74 {
  75         PROP_TITLE = 1,
  76         PROP_DESCRIPTION,
  77         PROP_ICON_NAME,
  78         PROP_CUSTOM_ICON,
  79         PROP_ENABLE_DESCRIPTION_MARKUP,
  80
  81         LAST_PROPERTY
  82 } HazeConnectionProperties;
  83
  84 typedef struct _PidginMiniDialogPrivate
  85 {
  86         GtkImage *icon;
  87         GtkBox *title_box;
  88         GtkLabel *title;
  89         GtkLabel *desc;
  90         GtkBox *buttons;
  91         gboolean enable_description_markup;
  92
  93         guint idle_destroy_cb_id;
  94 } PidginMiniDialogPrivate;
  95
  96 #define PIDGIN_MINI_DIALOG_GET_PRIVATE(dialog) \
  97         ((PidginMiniDialogPrivate *) ((dialog)->priv))
  98
  99 static PidginMiniDialog *
 100 mini_dialog_new(const gchar *title, const gchar *description)
 101 {
 102         return g_object_new(PIDGIN_TYPE_MINI_DIALOG,
 103                 "title", title,
 104                 "description", description,
 105                 NULL);
 106 }
 107
 108 PidginMiniDialog *
 109 pidgin_mini_dialog_new(const gchar *title,
 110                        const gchar *description,
 111                        const gchar *icon_name)
 112 {
 113         PidginMiniDialog *mini_dialog = mini_dialog_new(title, description);
 114         pidgin_mini_dialog_set_icon_name(mini_dialog, icon_name);
 115         return mini_dialog;
 116 }
 117
 118 PidginMiniDialog *
 119 pidgin_mini_dialog_new_with_custom_icon(const gchar *title,
 120                                         const gchar *description,
 121                                         GdkPixbuf *custom_icon)
 122 {
 123         PidginMiniDialog *mini_dialog = mini_dialog_new(title, description);
 124         pidgin_mini_dialog_set_custom_icon(mini_dialog, custom_icon);
 125         return mini_dialog;
 126 }
 127
 128 void
 129 pidgin_mini_dialog_set_title(PidginMiniDialog *mini_dialog,
 130                              const char *title)
 131 {
 132         g_object_set(G_OBJECT(mini_dialog), "title", title, NULL);
 133 }
 134
 135 void
 136 pidgin_mini_dialog_set_description(PidginMiniDialog *mini_dialog,
 137                                    const char *description)
 138 {
 139         g_object_set(G_OBJECT(mini_dialog), "description", description, NULL);
 140 }
 141
 142 void
 143 pidgin_mini_dialog_enable_description_markup(PidginMiniDialog *mini_dialog)
 144 {
 145         g_object_set(G_OBJECT(mini_dialog), "enable-description-markup", TRUE, NULL);
 146 }
 147
 148 gboolean
 149 pidgin_mini_dialog_links_supported()
 150 {
 151 #if GTK_CHECK_VERSION(2,18,0)
 152         return TRUE;
 153 #else
 154         return FALSE;
 155 #endif
 156 }
 157
 158 void pidgin_mini_dialog_set_link_callback(PidginMiniDialog *mini_dialog, GCallback cb, gpointer user_data)
 159 {
 160         g_signal_connect(PIDGIN_MINI_DIALOG_GET_PRIVATE(mini_dialog)->desc, "activate-link", cb, user_data);
 161 }
 162
 163 void
 164 pidgin_mini_dialog_set_icon_name(PidginMiniDialog *mini_dialog,
 165                                  const char *icon_name)
 166 {
 167         g_object_set(G_OBJECT(mini_dialog), "icon-name", icon_name, NULL);
 168 }
 169
 170 void
 171 pidgin_mini_dialog_set_custom_icon(PidginMiniDialog *mini_dialog, GdkPixbuf *custom_icon)
 172 {
 173         g_object_set(G_OBJECT(mini_dialog), "custom-icon", custom_icon, NULL);
 174 }
 175
 176 struct _mini_dialog_button_clicked_cb_data
 177 {
 178         PidginMiniDialog *mini_dialog;
 179         PidginMiniDialogCallback callback;
 180         gpointer user_data;
 181         gboolean close_dialog_after_click;
 182 };
 183
 184 guint
 185 pidgin_mini_dialog_get_num_children(PidginMiniDialog *mini_dialog)
 186 {
 187         return g_list_length(mini_dialog->contents->children);
 188 }
 189
 190 static gboolean
 191 idle_destroy_cb(GtkWidget *mini_dialog)
 192 {
 193         gtk_widget_destroy(mini_dialog);
 194         return FALSE;
 195 }
 196
 197 static void
 198 mini_dialog_button_clicked_cb(GtkButton *button,
 199                               gpointer user_data)
 200 {
 201         struct _mini_dialog_button_clicked_cb_data *data = user_data;
 202         PidginMiniDialogPrivate *priv =
 203                 PIDGIN_MINI_DIALOG_GET_PRIVATE(data->mini_dialog);
 204
 205         if (data->close_dialog_after_click) {
 206                 /* Set up the destruction callback before calling the clicked callback,
 207                  * so that if the mini-dialog gets destroyed during the clicked callback
 208                  * the idle_destroy_cb is correctly removed by _finalize.
 209                  */
 210                 priv->idle_destroy_cb_id =
 211                         g_idle_add((GSourceFunc) idle_destroy_cb, data->mini_dialog);
 212         }
 213
 214         if (data->callback != NULL)
 215                 data->callback(data->mini_dialog, button, data->user_data);
 216
 217 }
 218
 219 static void
 220 mini_dialog_button_destroy_cb(GtkButton *button,
 221                               gpointer user_data)
 222 {
 223         struct _mini_dialog_button_clicked_cb_data *data = user_data;
 224         g_free(data);
 225 }
 226
 227 static void
 228 mini_dialog_add_button(PidginMiniDialog *self,
 229                        const char *text,
 230                        PidginMiniDialogCallback clicked_cb,
 231                        gpointer user_data,
 232                        gboolean close_dialog_after_click)
 233 {
 234         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 235         struct _mini_dialog_button_clicked_cb_data *callback_data
 236                 = g_new0(struct _mini_dialog_button_clicked_cb_data, 1);
 237         GtkWidget *button = gtk_button_new();
 238         GtkWidget *label = gtk_label_new(NULL);
 239         char *button_text =
 240                 g_strdup_printf("<span size=\"smaller\">%s</span>", text);
 241
 242         gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), button_text);
 243         g_free(button_text);
 244
 245         callback_data->mini_dialog = self;
 246         callback_data->callback = clicked_cb;
 247         callback_data->user_data = user_data;
 248         callback_data->close_dialog_after_click = close_dialog_after_click;
 249         g_signal_connect(G_OBJECT(button), "clicked",
 250                 (GCallback) mini_dialog_button_clicked_cb, callback_data);
 251         g_signal_connect(G_OBJECT(button), "destroy",
 252                 (GCallback) mini_dialog_button_destroy_cb, callback_data);
 253
 254         gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
 255         gtk_container_add(GTK_CONTAINER(button), label);
 256
 257         gtk_box_pack_end(GTK_BOX(priv->buttons), button, FALSE, FALSE,
 258                 0);
 259         gtk_widget_show_all(GTK_WIDGET(button));
 260 }
 261
 262 void
 263 pidgin_mini_dialog_add_button(PidginMiniDialog *self,
 264                               const char *text,
 265                               PidginMiniDialogCallback clicked_cb,
 266                               gpointer user_data)
 267 {
 268         mini_dialog_add_button(self, text, clicked_cb, user_data, TRUE);
 269 }
 270
 271 void
 272 pidgin_mini_dialog_add_non_closing_button(PidginMiniDialog *self,
 273                                           const char *text,
 274                                           PidginMiniDialogCallback clicked_cb,
 275                                           gpointer user_data)
 276 {
 277         mini_dialog_add_button(self, text, clicked_cb, user_data, FALSE);
 278 }
 279
 280 static void
 281 pidgin_mini_dialog_get_property(GObject *object,
 282                                 guint property_id,
 283                                 GValue *value,
 284                                 GParamSpec *pspec)
 285 {
 286         PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object);
 287         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 288
 289         switch (property_id) {
 290                 case PROP_TITLE:
 291                         g_value_set_string(value, gtk_label_get_text(priv->title));
 292                         break;
 293                 case PROP_DESCRIPTION:
 294                         g_value_set_string(value, gtk_label_get_text(priv->desc));
 295                         break;
 296                 case PROP_ICON_NAME:
 297                 {
 298                         gchar *icon_name = NULL;
 299                         GtkIconSize size;
 300                         gtk_image_get_stock(priv->icon, &icon_name, &size);
 301                         g_value_set_string(value, icon_name);
 302                         break;
 303                 }
 304                 case PROP_CUSTOM_ICON:
 305                         g_value_set_object(value, gtk_image_get_pixbuf(priv->icon));
 306                         break;
 307                 case PROP_ENABLE_DESCRIPTION_MARKUP:
 308                         g_value_set_boolean(value, priv->enable_description_markup);
 309                         break;
 310                 default:
 311                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 312         }
 313 }
 314
 315 static void
 316 mini_dialog_set_title(PidginMiniDialog *self,
 317                       const char *title)
 318 {
 319         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 320
 321         char *title_esc = g_markup_escape_text(title, -1);
 322         char *title_markup = g_strdup_printf(
 323                 "<span weight=\"bold\" size=\"smaller\">%s</span>",
 324                 title_esc ? title_esc : "");
 325
 326         gtk_label_set_markup(priv->title, title_markup);
 327
 328         g_free(title_esc);
 329         g_free(title_markup);
 330 }
 331
 332 static void
 333 mini_dialog_set_description(PidginMiniDialog *self,
 334                             const char *description)
 335 {
 336         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 337         if(description)
 338         {
 339                 char *desc_esc = priv->enable_description_markup ? g_strdup(description) : g_markup_escape_text(description, -1);
 340                 char *desc_markup = g_strdup_printf(
 341                         "<span size=\"smaller\">%s</span>", desc_esc);
 342
 343                 gtk_label_set_markup(priv->desc, desc_markup);
 344
 345                 g_free(desc_esc);
 346                 g_free(desc_markup);
 347
 348                 gtk_widget_show(GTK_WIDGET(priv->desc));
 349                 g_object_set(G_OBJECT(priv->desc), "no-show-all", FALSE, NULL);
 350         }
 351         else
 352         {
 353                 gtk_label_set_text(priv->desc, NULL);
 354                 gtk_widget_hide(GTK_WIDGET(priv->desc));
 355                 /* make calling show_all() on the minidialog not affect desc
 356                  * even though it's packed inside it.
 357                  */
 358                 g_object_set(G_OBJECT(priv->desc), "no-show-all", TRUE, NULL);
 359         }
 360 }
 361
 362 static void
 363 pidgin_mini_dialog_set_property(GObject *object,
 364                                 guint property_id,
 365                                 const GValue *value,
 366                                 GParamSpec *pspec)
 367 {
 368         PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object);
 369         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 370
 371         switch (property_id) {
 372                 case PROP_TITLE:
 373                         mini_dialog_set_title(self, g_value_get_string(value));
 374                         break;
 375                 case PROP_DESCRIPTION:
 376                         mini_dialog_set_description(self, g_value_get_string(value));
 377                         break;
 378                 case PROP_ICON_NAME:
 379                         gtk_image_set_from_stock(priv->icon, g_value_get_string(value),
 380                                 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
 381                         break;
 382                 case PROP_CUSTOM_ICON:
 383                         gtk_image_set_from_pixbuf(priv->icon, g_value_get_object(value));
 384                         break;
 385                 case PROP_ENABLE_DESCRIPTION_MARKUP:
 386                         priv->enable_description_markup = g_value_get_boolean(value);
 387                         break;
 388                 default:
 389                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 390         }
 391 }
 392
 393 static void
 394 pidgin_mini_dialog_finalize(GObject *object)
 395 {
 396         PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object);
 397         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 398
 399         if (priv->idle_destroy_cb_id)
 400                 g_source_remove(priv->idle_destroy_cb_id);
 401
 402         g_free(priv);
 403         self->priv = NULL;
 404
 405         purple_prefs_disconnect_by_handle(self);
 406
 407         G_OBJECT_CLASS (pidgin_mini_dialog_parent_class)->finalize (object);
 408 }
 409
 410 static void
 411 pidgin_mini_dialog_class_init(PidginMiniDialogClass *klass)
 412 {
 413         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 414         GParamSpec *param_spec;
 415
 416         object_class->get_property = pidgin_mini_dialog_get_property;
 417         object_class->set_property = pidgin_mini_dialog_set_property;
 418         object_class->finalize = pidgin_mini_dialog_finalize;
 419
 420         param_spec = g_param_spec_string("title", "title",
 421                 "String specifying the mini-dialog's title", NULL,
 422                 G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 423                 G_PARAM_READWRITE);
 424         g_object_class_install_property (object_class, PROP_TITLE, param_spec);
 425
 426         param_spec = g_param_spec_string("description", "description",
 427                 "Description text for the mini-dialog, if desired", NULL,
 428                 G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 429                 G_PARAM_READWRITE);
 430         g_object_class_install_property (object_class, PROP_DESCRIPTION, param_spec);
 431
 432         param_spec = g_param_spec_string("icon-name", "icon-name",
 433                 "String specifying the Gtk stock name of the dialog's icon",
 434                 NULL,
 435                 G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 436                 G_PARAM_READWRITE);
 437         g_object_class_install_property (object_class, PROP_ICON_NAME, param_spec);
 438
 439         param_spec = g_param_spec_object("custom-icon", "custom-icon",
 440                 "Pixbuf to use as the dialog's icon",
 441                 GDK_TYPE_PIXBUF,
 442                 G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 443                 G_PARAM_READWRITE);
 444         g_object_class_install_property (object_class, PROP_CUSTOM_ICON, param_spec);
 445
 446         param_spec = g_param_spec_boolean("enable-description-markup", "enable-description-markup",
 447                 "Use GMarkup in the description text", FALSE,
 448                 G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 449                 G_PARAM_READWRITE);
 450         g_object_class_install_property (object_class, PROP_ENABLE_DESCRIPTION_MARKUP, param_spec);
 451 }
 452
 453 /* 16 is the width of the icon, due to PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL */
 454 #define BLIST_WIDTH_OTHER_THAN_LABEL \
 455         ((PIDGIN_HIG_BOX_SPACE * 3) + 16)
 456
 457 #define BLIST_WIDTH_PREF \
 458         (PIDGIN_PREFS_ROOT "/blist/width")
 459
 460 static void
 461 blist_width_changed_cb(const char *name,
 462                        PurplePrefType type,
 463                        gconstpointer val,
 464                        gpointer data)
 465 {
 466         PidginMiniDialog *self = PIDGIN_MINI_DIALOG(data);
 467         PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
 468         guint blist_width = GPOINTER_TO_INT(val);
 469         guint label_width = blist_width - BLIST_WIDTH_OTHER_THAN_LABEL;
 470
 471         gtk_widget_set_size_request(GTK_WIDGET(priv->title), label_width, -1);
 472         gtk_widget_set_size_request(GTK_WIDGET(priv->desc), label_width, -1);
 473 }
 474
 475 static void
 476 pidgin_mini_dialog_init(PidginMiniDialog *self)
 477 {
 478         GtkBox *self_box = GTK_BOX(self);
 479         guint blist_width = purple_prefs_get_int(BLIST_WIDTH_PREF);
 480         guint label_width = blist_width - BLIST_WIDTH_OTHER_THAN_LABEL;
 481
 482         PidginMiniDialogPrivate *priv = g_new0(PidginMiniDialogPrivate, 1);
 483         self->priv = priv;
 484
 485         gtk_container_set_border_width(GTK_CONTAINER(self), PIDGIN_HIG_BOX_SPACE);
 486
 487         priv->title_box = GTK_BOX(gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE));
 488
 489         priv->icon = GTK_IMAGE(gtk_image_new());
 490         gtk_misc_set_alignment(GTK_MISC(priv->icon), 0, 0);
 491
 492         priv->title = GTK_LABEL(gtk_label_new(NULL));
 493         gtk_widget_set_size_request(GTK_WIDGET(priv->title), label_width, -1);
 494         gtk_label_set_line_wrap(priv->title, TRUE);
 495         gtk_label_set_selectable(priv->title, TRUE);
 496         gtk_misc_set_alignment(GTK_MISC(priv->title), 0, 0);
 497
 498         gtk_box_pack_start(priv->title_box, GTK_WIDGET(priv->icon), FALSE, FALSE, 0);
 499         gtk_box_pack_start(priv->title_box, GTK_WIDGET(priv->title), TRUE, TRUE, 0);
 500
 501         priv->desc = GTK_LABEL(gtk_label_new(NULL));
 502         gtk_widget_set_size_request(GTK_WIDGET(priv->desc), label_width, -1);
 503         gtk_label_set_line_wrap(priv->desc, TRUE);
 504         gtk_misc_set_alignment(GTK_MISC(priv->desc), 0, 0);
 505         gtk_label_set_selectable(priv->desc, TRUE);
 506         /* make calling show_all() on the minidialog not affect desc even though
 507          * it's packed inside it.
 508          */
 509         g_object_set(G_OBJECT(priv->desc), "no-show-all", TRUE, NULL);
 510
 511         purple_prefs_connect_callback(self, BLIST_WIDTH_PREF,
 512                 blist_width_changed_cb, self);
 513
 514         self->contents = GTK_BOX(gtk_vbox_new(FALSE, 0));
 515
 516         priv->buttons = GTK_BOX(gtk_hbox_new(FALSE, 0));
 517
 518         gtk_box_pack_start(self_box, GTK_WIDGET(priv->title_box), FALSE, FALSE, 0);
 519         gtk_box_pack_start(self_box, GTK_WIDGET(priv->desc), FALSE, FALSE, 0);
 520         gtk_box_pack_start(self_box, GTK_WIDGET(self->contents), TRUE, TRUE, 0);
 521         gtk_box_pack_start(self_box, GTK_WIDGET(priv->buttons), FALSE, FALSE, 0);
 522
 523         gtk_widget_show_all(GTK_WIDGET(self));
 524 }