← Back to branch summary

~ubuntu-branches/ubuntu/saucy/sflphone/saucy

« back to all changes in this revision

Viewing changes to sflphone-client-gnome/src/widget/minidialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Francois Marier
  • Date: 2010-12-24 16:33:55 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20101224163355-tkvvikqxbrbav6up
Tags: 0.9.11-1
* New upstream release
* Add new build dependencies on libwebkit-dev and libyaml-dev

* Bump Standards-Version up to 3.9.1
* Bump debhelper compatibility to 8
* Patch another typo in the upstream code (lintian notice)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sflphone-client-gnome/src/widget/minidialog.c
26
26
#include <gtk/gtkhbox.h>
27
27
#include <gtk/gtkbutton.h>
28
28
#include <gtk/gtk.h>
29
 
 
 
29
#include "sflphone_const.h"
30
30
#include "minidialog.h"
31
31
 
32
32
#define HIG_BOX_SPACE 6
33
33
#define LABEL_WIDTH 200
34
34
 
35
 
static void     pidgin_mini_dialog_init       (PidginMiniDialog      *self);
 
35
static void     pidgin_mini_dialog_init (PidginMiniDialog      *self);
36
36
static void     pidgin_mini_dialog_class_init (PidginMiniDialogClass *klass);
37
37
 
38
38
static gpointer pidgin_mini_dialog_parent_class = NULL;
40
40
static void
41
41
pidgin_mini_dialog_class_intern_init (gpointer klass)
42
42
{
43
 
        pidgin_mini_dialog_parent_class = g_type_class_peek_parent (klass);
44
 
        pidgin_mini_dialog_class_init ((PidginMiniDialogClass*) klass);
 
43
    pidgin_mini_dialog_parent_class = g_type_class_peek_parent (klass);
 
44
    pidgin_mini_dialog_class_init ( (PidginMiniDialogClass*) klass);
45
45
}
46
46
 
47
47
GType
48
48
pidgin_mini_dialog_get_type (void)
49
49
{
50
 
        static GType g_define_type_id = 0;
51
 
        if (g_define_type_id == 0)
52
 
        {
53
 
                static const GTypeInfo g_define_type_info = {
54
 
                        sizeof (PidginMiniDialogClass),
55
 
                        (GBaseInitFunc) NULL,
56
 
                        (GBaseFinalizeFunc) NULL,
57
 
                        (GClassInitFunc) pidgin_mini_dialog_class_intern_init,
58
 
                        (GClassFinalizeFunc) NULL,
59
 
                        NULL,   /* class_data */
60
 
                        sizeof (PidginMiniDialog),
61
 
                        0,      /* n_preallocs */
62
 
                        (GInstanceInitFunc) pidgin_mini_dialog_init,
63
 
                        NULL,
64
 
                };
65
 
                g_define_type_id = g_type_register_static (GTK_TYPE_VBOX,
66
 
                        "PidginMiniDialog", &g_define_type_info, 0);
67
 
        }
68
 
        return g_define_type_id;
 
50
    static GType g_define_type_id = 0;
 
51
 
 
52
    if (g_define_type_id == 0) {
 
53
        static const GTypeInfo g_define_type_info = {
 
54
            sizeof (PidginMiniDialogClass),
 
55
            (GBaseInitFunc) NULL,
 
56
            (GBaseFinalizeFunc) NULL,
 
57
            (GClassInitFunc) pidgin_mini_dialog_class_intern_init,
 
58
            (GClassFinalizeFunc) NULL,
 
59
            NULL,   /* class_data */
 
60
            sizeof (PidginMiniDialog),
 
61
            0,      /* n_preallocs */
 
62
            (GInstanceInitFunc) pidgin_mini_dialog_init,
 
63
            NULL,
 
64
        };
 
65
        g_define_type_id = g_type_register_static (GTK_TYPE_VBOX,
 
66
                           "PidginMiniDialog", &g_define_type_info, 0);
 
67
    }
 
68
 
 
69
    return g_define_type_id;
69
70
}
70
71
 
71
 
enum
72
 
{
73
 
        PROP_TITLE = 1,
74
 
        PROP_DESCRIPTION,
75
 
        PROP_ICON_NAME,
 
72
enum {
 
73
    PROP_TITLE = 1,
 
74
    PROP_DESCRIPTION,
 
75
    PROP_ICON_NAME,
76
76
 
77
 
        LAST_PROPERTY
 
77
    LAST_PROPERTY
78
78
} HazeConnectionProperties;
79
79
 
80
 
typedef struct _PidginMiniDialogPrivate
81
 
{
82
 
        GtkImage *icon;
83
 
        GtkBox *title_box;
84
 
        GtkLabel *title;
85
 
        GtkLabel *desc;
86
 
        GtkBox *buttons;
 
80
typedef struct _PidginMiniDialogPrivate {
 
81
    GtkImage *icon;
 
82
    GtkBox *title_box;
 
83
    GtkLabel *title;
 
84
    GtkLabel *desc;
 
85
    GtkBox *buttons;
87
86
 
88
 
        guint idle_destroy_cb_id;
 
87
    guint idle_destroy_cb_id;
89
88
} PidginMiniDialogPrivate;
90
89
 
91
90
#define PIDGIN_MINI_DIALOG_GET_PRIVATE(dialog) \
92
91
        ((PidginMiniDialogPrivate *) ((dialog)->priv))
93
92
 
94
93
PidginMiniDialog *
95
 
pidgin_mini_dialog_new(const gchar *title,
96
 
                       const gchar *description,
97
 
                       const gchar *icon_name)
98
 
{
99
 
        PidginMiniDialog *mini_dialog = g_object_new(PIDGIN_TYPE_MINI_DIALOG,
100
 
                "title", title,
101
 
                "description", description,
102
 
                "icon-name", icon_name,
103
 
                NULL);
104
 
 
105
 
        return mini_dialog;
106
 
}
107
 
 
108
 
void
109
 
pidgin_mini_dialog_set_title(PidginMiniDialog *mini_dialog,
110
 
                             const char *title)
111
 
{
112
 
        g_object_set(G_OBJECT(mini_dialog), "title", title, NULL);
113
 
}
114
 
 
115
 
void
116
 
pidgin_mini_dialog_set_description(PidginMiniDialog *mini_dialog,
117
 
                                   const char *description)
118
 
{
119
 
        g_object_set(G_OBJECT(mini_dialog), "description", description, NULL);
120
 
}
121
 
 
122
 
void
123
 
pidgin_mini_dialog_set_icon_name(PidginMiniDialog *mini_dialog,
124
 
                                 const char *icon_name)
125
 
{
126
 
        g_object_set(G_OBJECT(mini_dialog), "icon_name", icon_name, NULL);
127
 
}
128
 
 
129
 
struct _mini_dialog_button_clicked_cb_data
130
 
{
131
 
        PidginMiniDialog *mini_dialog;
132
 
        PidginMiniDialogCallback callback;
133
 
        gpointer user_data;
 
94
pidgin_mini_dialog_new (const gchar *title,
 
95
                        const gchar *description,
 
96
                        const gchar *icon_name)
 
97
{
 
98
    PidginMiniDialog *mini_dialog = g_object_new (PIDGIN_TYPE_MINI_DIALOG,
 
99
                                    "title", title,
 
100
                                    "description", description,
 
101
                                    "icon-name", icon_name,
 
102
                                    NULL);
 
103
 
 
104
    return mini_dialog;
 
105
}
 
106
 
 
107
void
 
108
pidgin_mini_dialog_set_title (PidginMiniDialog *mini_dialog,
 
109
                              const char *title)
 
110
{
 
111
    g_object_set (G_OBJECT (mini_dialog), "title", title, NULL);
 
112
}
 
113
 
 
114
void
 
115
pidgin_mini_dialog_set_description (PidginMiniDialog *mini_dialog,
 
116
                                    const char *description)
 
117
{
 
118
    g_object_set (G_OBJECT (mini_dialog), "description", description, NULL);
 
119
}
 
120
 
 
121
void
 
122
pidgin_mini_dialog_set_icon_name (PidginMiniDialog *mini_dialog,
 
123
                                  const char *icon_name)
 
124
{
 
125
    g_object_set (G_OBJECT (mini_dialog), "icon_name", icon_name, NULL);
 
126
}
 
127
 
 
128
struct _mini_dialog_button_clicked_cb_data {
 
129
    PidginMiniDialog *mini_dialog;
 
130
    PidginMiniDialogCallback callback;
 
131
    gpointer user_data;
134
132
};
135
133
 
136
134
guint
137
 
pidgin_mini_dialog_get_num_children(PidginMiniDialog *mini_dialog)
 
135
pidgin_mini_dialog_get_num_children (PidginMiniDialog *mini_dialog)
138
136
{
139
 
        return g_list_length(mini_dialog->contents->children);
 
137
    return g_list_length (mini_dialog->contents->children);
140
138
}
141
139
 
142
140
static gboolean
143
 
idle_destroy_cb(GtkWidget *mini_dialog)
144
 
{
145
 
        gtk_widget_destroy(mini_dialog);
146
 
        return FALSE;
147
 
}
148
 
 
149
 
static void
150
 
mini_dialog_button_clicked_cb(GtkButton *button,
151
 
                              gpointer user_data)
152
 
{
153
 
        struct _mini_dialog_button_clicked_cb_data *data = user_data;
154
 
        PidginMiniDialogPrivate *priv =
155
 
                PIDGIN_MINI_DIALOG_GET_PRIVATE(data->mini_dialog);
156
 
 
157
 
        /* Set up the destruction callback before calling the clicked callback,
158
 
         * so that if the mini-dialog gets destroyed during the clicked callback
159
 
         * the idle_destroy_cb is correctly removed by _finalize.
160
 
         */
161
 
        priv->idle_destroy_cb_id =
162
 
                g_idle_add((GSourceFunc) idle_destroy_cb, data->mini_dialog);
163
 
 
164
 
        if (data->callback != NULL)
165
 
                data->callback(data->mini_dialog, button, data->user_data);
166
 
 
167
 
}
168
 
 
169
 
static void
170
 
mini_dialog_button_destroy_cb(GtkButton *button,
171
 
                              gpointer user_data)
172
 
{
173
 
        struct _mini_dialog_button_clicked_cb_data *data = user_data;
174
 
        g_free(data);
 
141
idle_destroy_cb (GtkWidget *mini_dialog)
 
142
{
 
143
    gtk_widget_destroy (mini_dialog);
 
144
    return FALSE;
 
145
}
 
146
 
 
147
static void
 
148
mini_dialog_button_clicked_cb (GtkButton *button,
 
149
                               gpointer user_data)
 
150
{
 
151
    struct _mini_dialog_button_clicked_cb_data *data = user_data;
 
152
    PidginMiniDialogPrivate *priv =
 
153
        PIDGIN_MINI_DIALOG_GET_PRIVATE (data->mini_dialog);
 
154
 
 
155
    /* Set up the destruction callback before calling the clicked callback,
 
156
     * so that if the mini-dialog gets destroyed during the clicked callback
 
157
     * the idle_destroy_cb is correctly removed by _finalize.
 
158
     */
 
159
    priv->idle_destroy_cb_id =
 
160
        g_idle_add ( (GSourceFunc) idle_destroy_cb, data->mini_dialog);
 
161
 
 
162
    if (data->callback != NULL)
 
163
        data->callback (data->mini_dialog, button, data->user_data);
 
164
 
 
165
}
 
166
 
 
167
static void
 
168
mini_dialog_button_destroy_cb (GtkButton *button UNUSED,
 
169
                               gpointer user_data)
 
170
{
 
171
    struct _mini_dialog_button_clicked_cb_data *data = user_data;
 
172
    g_free (data);
175
173
}
176
174
 
177
175
void
178
 
pidgin_mini_dialog_add_button(PidginMiniDialog *self,
179
 
                              const char *text,
180
 
                              PidginMiniDialogCallback clicked_cb,
181
 
                              gpointer user_data)
182
 
{
183
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
184
 
        struct _mini_dialog_button_clicked_cb_data *callback_data
185
 
                = g_new0(struct _mini_dialog_button_clicked_cb_data, 1);
186
 
        GtkWidget *button = gtk_button_new();
187
 
        GtkWidget *label = gtk_label_new(NULL);
188
 
        char *button_text =
189
 
                g_strdup_printf("<span size=\"smaller\">%s</span>", text);
190
 
 
191
 
        gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), button_text);
192
 
        g_free(button_text);
193
 
 
194
 
        callback_data->mini_dialog = self;
195
 
        callback_data->callback = clicked_cb;
196
 
        callback_data->user_data = user_data;
197
 
        g_signal_connect(G_OBJECT(button), "clicked",
198
 
                (GCallback) mini_dialog_button_clicked_cb, callback_data);
199
 
        g_signal_connect(G_OBJECT(button), "destroy",
200
 
                (GCallback) mini_dialog_button_destroy_cb, callback_data);
201
 
 
202
 
        gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
203
 
        gtk_container_add(GTK_CONTAINER(button), label);
204
 
 
205
 
        gtk_box_pack_end(GTK_BOX(priv->buttons), button, FALSE, FALSE,
206
 
                0);
207
 
        gtk_widget_show_all(GTK_WIDGET(button));
208
 
}
209
 
 
210
 
static void
211
 
pidgin_mini_dialog_get_property(GObject *object,
212
 
                                guint property_id,
213
 
                                GValue *value,
214
 
                                GParamSpec *pspec)
215
 
{
216
 
        PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object);
217
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
218
 
 
219
 
        switch (property_id) {
220
 
                case PROP_TITLE:
221
 
                        g_value_set_string(value, gtk_label_get_text(priv->title));
222
 
                        break;
223
 
                case PROP_DESCRIPTION:
224
 
                        g_value_set_string(value, gtk_label_get_text(priv->desc));
225
 
                        break;
226
 
                case PROP_ICON_NAME:
227
 
                {
228
 
                        gchar *icon_name = NULL;
229
 
                        GtkIconSize size;
230
 
                        gtk_image_get_stock(priv->icon, &icon_name, &size);
231
 
                        g_value_set_string(value, icon_name);
232
 
                        break;
233
 
                }
234
 
                default:
235
 
                        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
236
 
        }
237
 
}
238
 
 
239
 
static void
240
 
mini_dialog_set_title(PidginMiniDialog *self,
241
 
                      const char *title)
242
 
{
243
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
244
 
 
245
 
        char *title_esc = g_markup_escape_text(title, -1);
246
 
        char *title_markup = g_strdup_printf(
247
 
                "<span weight=\"bold\" size=\"smaller\">%s</span>",
248
 
                title_esc ? title_esc : "");
249
 
 
250
 
        gtk_label_set_markup(priv->title, title_markup);
251
 
 
252
 
        g_free(title_esc);
253
 
        g_free(title_markup);
254
 
}
255
 
 
256
 
static void
257
 
mini_dialog_set_description(PidginMiniDialog *self,
258
 
                            const char *description)
259
 
{
260
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
261
 
        if(description)
262
 
        {
263
 
                char *desc_esc = g_markup_escape_text(description, -1);
264
 
                char *desc_markup = g_strdup_printf(
265
 
                        "<span size=\"smaller\">%s</span>", desc_esc);
266
 
 
267
 
                gtk_label_set_markup(priv->desc, desc_markup);
268
 
 
269
 
                g_free(desc_esc);
270
 
                g_free(desc_markup);
271
 
 
272
 
                gtk_widget_show(GTK_WIDGET(priv->desc));
273
 
                g_object_set(G_OBJECT(priv->desc), "no-show-all", FALSE, NULL);
274
 
        }
275
 
        else
276
 
        {
277
 
                gtk_label_set_text(priv->desc, NULL);
278
 
                gtk_widget_hide(GTK_WIDGET(priv->desc));
279
 
                /* make calling show_all() on the minidialog not affect desc
280
 
                 * even though it's packed inside it.
281
 
                 */
282
 
                g_object_set(G_OBJECT(priv->desc), "no-show-all", TRUE, NULL);
283
 
        }
284
 
}
285
 
 
286
 
static void
287
 
pidgin_mini_dialog_set_property(GObject *object,
288
 
                                guint property_id,
289
 
                                const GValue *value,
290
 
                                GParamSpec *pspec)
291
 
{
292
 
        PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object);
293
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
294
 
 
295
 
        switch (property_id) {
296
 
                case PROP_TITLE:
297
 
                        mini_dialog_set_title(self, g_value_get_string(value));
298
 
                        break;
299
 
                case PROP_DESCRIPTION:
300
 
                        mini_dialog_set_description(self, g_value_get_string(value));
301
 
                        break;
302
 
                case PROP_ICON_NAME:
303
 
                        gtk_image_set_from_stock(priv->icon, g_value_get_string(value),
304
 
                                GTK_ICON_SIZE_BUTTON);
305
 
                        break;
306
 
                default:
307
 
                        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
308
 
        }
309
 
}
310
 
 
311
 
static void
312
 
pidgin_mini_dialog_finalize(GObject *object)
313
 
{
314
 
        PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object);
315
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
316
 
 
317
 
        if (priv->idle_destroy_cb_id)
318
 
                g_source_remove(priv->idle_destroy_cb_id);
319
 
 
320
 
        g_free(priv);
321
 
        self->priv = NULL;
322
 
 
323
 
 
324
 
        G_OBJECT_CLASS (pidgin_mini_dialog_parent_class)->finalize (object);
325
 
}
326
 
 
327
 
static void
328
 
pidgin_mini_dialog_class_init(PidginMiniDialogClass *klass)
329
 
{
330
 
        GObjectClass *object_class = G_OBJECT_CLASS(klass);
331
 
        GParamSpec *param_spec;
332
 
 
333
 
        object_class->get_property = pidgin_mini_dialog_get_property;
334
 
        object_class->set_property = pidgin_mini_dialog_set_property;
335
 
        object_class->finalize = pidgin_mini_dialog_finalize;
336
 
 
337
 
        param_spec = g_param_spec_string("title", "title",
338
 
                "String specifying the mini-dialog's title", NULL,
339
 
                G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
340
 
                G_PARAM_READWRITE);
341
 
        g_object_class_install_property (object_class, PROP_TITLE, param_spec);
342
 
 
343
 
        param_spec = g_param_spec_string("description", "description",
344
 
                "Description text for the mini-dialog, if desired", NULL,
345
 
                G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
346
 
                G_PARAM_READWRITE);
347
 
        g_object_class_install_property (object_class, PROP_DESCRIPTION, param_spec);
348
 
 
349
 
        param_spec = g_param_spec_string("icon-name", "icon-name",
350
 
                "String specifying the Gtk stock name of the dialog's icon",
351
 
                NULL,
352
 
                G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
353
 
                G_PARAM_READWRITE);
354
 
        g_object_class_install_property (object_class, PROP_ICON_NAME, param_spec);
 
176
pidgin_mini_dialog_add_button (PidginMiniDialog *self,
 
177
                               const char *text,
 
178
                               PidginMiniDialogCallback clicked_cb,
 
179
                               gpointer user_data)
 
180
{
 
181
    PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE (self);
 
182
    struct _mini_dialog_button_clicked_cb_data *callback_data
 
183
    = g_new0 (struct _mini_dialog_button_clicked_cb_data, 1);
 
184
    GtkWidget *button = gtk_button_new();
 
185
    GtkWidget *label = gtk_label_new (NULL);
 
186
    char *button_text =
 
187
        g_strdup_printf ("<span size=\"smaller\">%s</span>", text);
 
188
 
 
189
    gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), button_text);
 
190
    g_free (button_text);
 
191
 
 
192
    callback_data->mini_dialog = self;
 
193
    callback_data->callback = clicked_cb;
 
194
    callback_data->user_data = user_data;
 
195
    g_signal_connect (G_OBJECT (button), "clicked",
 
196
                      (GCallback) mini_dialog_button_clicked_cb, callback_data);
 
197
    g_signal_connect (G_OBJECT (button), "destroy",
 
198
                      (GCallback) mini_dialog_button_destroy_cb, callback_data);
 
199
 
 
200
    gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
 
201
    gtk_container_add (GTK_CONTAINER (button), label);
 
202
 
 
203
    gtk_box_pack_end (GTK_BOX (priv->buttons), button, FALSE, FALSE,
 
204
                      0);
 
205
    gtk_widget_show_all (GTK_WIDGET (button));
 
206
}
 
207
 
 
208
static void
 
209
pidgin_mini_dialog_get_property (GObject *object,
 
210
                                 guint property_id,
 
211
                                 GValue *value,
 
212
                                 GParamSpec *pspec)
 
213
{
 
214
    PidginMiniDialog *self = PIDGIN_MINI_DIALOG (object);
 
215
    PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE (self);
 
216
 
 
217
    switch (property_id) {
 
218
        case PROP_TITLE:
 
219
            g_value_set_string (value, gtk_label_get_text (priv->title));
 
220
            break;
 
221
        case PROP_DESCRIPTION:
 
222
            g_value_set_string (value, gtk_label_get_text (priv->desc));
 
223
            break;
 
224
        case PROP_ICON_NAME: {
 
225
            gchar *icon_name = NULL;
 
226
            GtkIconSize size;
 
227
            gtk_image_get_stock (priv->icon, &icon_name, &size);
 
228
            g_value_set_string (value, icon_name);
 
229
            break;
 
230
        }
 
231
        default:
 
232
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
233
    }
 
234
}
 
235
 
 
236
static void
 
237
mini_dialog_set_title (PidginMiniDialog *self,
 
238
                       const char *title)
 
239
{
 
240
    PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE (self);
 
241
 
 
242
    char *title_esc = g_markup_escape_text (title, -1);
 
243
    char *title_markup = g_strdup_printf (
 
244
                             "<span weight=\"bold\" size=\"smaller\">%s</span>",
 
245
                             title_esc ? title_esc : "");
 
246
 
 
247
    gtk_label_set_markup (priv->title, title_markup);
 
248
 
 
249
    g_free (title_esc);
 
250
    g_free (title_markup);
 
251
}
 
252
 
 
253
static void
 
254
mini_dialog_set_description (PidginMiniDialog *self,
 
255
                             const char *description)
 
256
{
 
257
    PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE (self);
 
258
 
 
259
    if (description) {
 
260
        char *desc_esc = g_markup_escape_text (description, -1);
 
261
        char *desc_markup = g_strdup_printf (
 
262
                                "<span size=\"smaller\">%s</span>", desc_esc);
 
263
 
 
264
        gtk_label_set_markup (priv->desc, desc_markup);
 
265
 
 
266
        g_free (desc_esc);
 
267
        g_free (desc_markup);
 
268
 
 
269
        gtk_widget_show (GTK_WIDGET (priv->desc));
 
270
        g_object_set (G_OBJECT (priv->desc), "no-show-all", FALSE, NULL);
 
271
    } else {
 
272
        gtk_label_set_text (priv->desc, NULL);
 
273
        gtk_widget_hide (GTK_WIDGET (priv->desc));
 
274
        /* make calling show_all() on the minidialog not affect desc
 
275
         * even though it's packed inside it.
 
276
          */
 
277
        g_object_set (G_OBJECT (priv->desc), "no-show-all", TRUE, NULL);
 
278
    }
 
279
}
 
280
 
 
281
static void
 
282
pidgin_mini_dialog_set_property (GObject *object,
 
283
                                 guint property_id,
 
284
                                 const GValue *value,
 
285
                                 GParamSpec *pspec)
 
286
{
 
287
    PidginMiniDialog *self = PIDGIN_MINI_DIALOG (object);
 
288
    PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE (self);
 
289
 
 
290
    switch (property_id) {
 
291
        case PROP_TITLE:
 
292
            mini_dialog_set_title (self, g_value_get_string (value));
 
293
            break;
 
294
        case PROP_DESCRIPTION:
 
295
            mini_dialog_set_description (self, g_value_get_string (value));
 
296
            break;
 
297
        case PROP_ICON_NAME:
 
298
            gtk_image_set_from_stock (priv->icon, g_value_get_string (value),
 
299
                                      GTK_ICON_SIZE_BUTTON);
 
300
            break;
 
301
        default:
 
302
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
303
    }
 
304
}
 
305
 
 
306
static void
 
307
pidgin_mini_dialog_finalize (GObject *object)
 
308
{
 
309
    PidginMiniDialog *self = PIDGIN_MINI_DIALOG (object);
 
310
    PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE (self);
 
311
 
 
312
    if (priv->idle_destroy_cb_id)
 
313
        g_source_remove (priv->idle_destroy_cb_id);
 
314
 
 
315
    g_free (priv);
 
316
    self->priv = NULL;
 
317
 
 
318
 
 
319
    G_OBJECT_CLASS (pidgin_mini_dialog_parent_class)->finalize (object);
 
320
}
 
321
 
 
322
static void
 
323
pidgin_mini_dialog_class_init (PidginMiniDialogClass *klass)
 
324
{
 
325
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
326
    GParamSpec *param_spec;
 
327
 
 
328
    object_class->get_property = pidgin_mini_dialog_get_property;
 
329
    object_class->set_property = pidgin_mini_dialog_set_property;
 
330
    object_class->finalize = pidgin_mini_dialog_finalize;
 
331
 
 
332
    param_spec = g_param_spec_string ("title", "title",
 
333
                                      "String specifying the mini-dialog's title", NULL,
 
334
                                      G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 
335
                                      G_PARAM_READWRITE);
 
336
    g_object_class_install_property (object_class, PROP_TITLE, param_spec);
 
337
 
 
338
    param_spec = g_param_spec_string ("description", "description",
 
339
                                      "Description text for the mini-dialog, if desired", NULL,
 
340
                                      G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 
341
                                      G_PARAM_READWRITE);
 
342
    g_object_class_install_property (object_class, PROP_DESCRIPTION, param_spec);
 
343
 
 
344
    param_spec = g_param_spec_string ("icon-name", "icon-name",
 
345
                                      "String specifying the Gtk stock name of the dialog's icon",
 
346
                                      NULL,
 
347
                                      G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 
348
                                      G_PARAM_READWRITE);
 
349
    g_object_class_install_property (object_class, PROP_ICON_NAME, param_spec);
355
350
}
356
351
 
357
352
/* 16 is the width of the icon, due to PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL */
362
357
        (PIDGIN_PREFS_ROOT "/blist/width")
363
358
 
364
359
static void
365
 
blist_width_changed_cb(const char *name,
366
 
                       gconstpointer val,
367
 
                       gpointer data)
368
 
{
369
 
        PidginMiniDialog *self = PIDGIN_MINI_DIALOG(data);
370
 
        PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
371
 
        guint blist_width = GPOINTER_TO_INT(val);
372
 
        guint label_width = LABEL_WIDTH;
373
 
 
374
 
        gtk_widget_set_size_request(GTK_WIDGET(priv->title), label_width, -1);
375
 
        gtk_widget_set_size_request(GTK_WIDGET(priv->desc), label_width, -1);
376
 
}
377
 
 
378
 
static void
379
 
pidgin_mini_dialog_init(PidginMiniDialog *self)
380
 
{
381
 
        GtkBox *self_box = GTK_BOX(self);
382
 
        guint label_width = LABEL_WIDTH;
383
 
 
384
 
        PidginMiniDialogPrivate *priv = g_new0(PidginMiniDialogPrivate, 1);
385
 
        self->priv = priv;
386
 
 
387
 
        gtk_container_set_border_width(GTK_CONTAINER(self), HIG_BOX_SPACE);
388
 
 
389
 
        priv->title_box = GTK_BOX(gtk_hbox_new(FALSE, HIG_BOX_SPACE));
390
 
 
391
 
        priv->icon = GTK_IMAGE(gtk_image_new());
392
 
        gtk_misc_set_alignment(GTK_MISC(priv->icon), 0, 0);
393
 
 
394
 
        priv->title = GTK_LABEL(gtk_label_new(NULL));
395
 
        gtk_widget_set_size_request(GTK_WIDGET(priv->title), label_width, -1);
396
 
        gtk_label_set_line_wrap(priv->title, TRUE);
397
 
        gtk_label_set_selectable(priv->title, TRUE);
398
 
        gtk_misc_set_alignment(GTK_MISC(priv->title), 0, 0);
399
 
 
400
 
        gtk_box_pack_start(priv->title_box, GTK_WIDGET(priv->icon), FALSE, FALSE, 0);
401
 
        gtk_box_pack_start(priv->title_box, GTK_WIDGET(priv->title), TRUE, TRUE, 0);
402
 
 
403
 
        priv->desc = GTK_LABEL(gtk_label_new(NULL));
404
 
        gtk_widget_set_size_request(GTK_WIDGET(priv->desc), label_width, -1);
405
 
        gtk_label_set_line_wrap(priv->desc, TRUE);
406
 
        gtk_misc_set_alignment(GTK_MISC(priv->desc), 0, 0);
407
 
        gtk_label_set_selectable(priv->desc, TRUE);
408
 
        /* make calling show_all() on the minidialog not affect desc even though
409
 
         * it's packed inside it.
410
 
         */
411
 
        g_object_set(G_OBJECT(priv->desc), "no-show-all", TRUE, NULL);
412
 
 
413
 
        self->contents = GTK_BOX(gtk_vbox_new(FALSE, 0));
414
 
 
415
 
        priv->buttons = GTK_BOX(gtk_hbox_new(FALSE, 0));
416
 
 
417
 
        gtk_box_pack_start(self_box, GTK_WIDGET(priv->title_box), FALSE, FALSE, 0);
418
 
        gtk_box_pack_start(self_box, GTK_WIDGET(priv->desc), FALSE, FALSE, 0);
419
 
        gtk_box_pack_start(self_box, GTK_WIDGET(self->contents), TRUE, TRUE, 0);
420
 
        gtk_box_pack_start(self_box, GTK_WIDGET(priv->buttons), FALSE, FALSE, 0);
421
 
 
422
 
        gtk_widget_show_all(GTK_WIDGET(self));
 
360
pidgin_mini_dialog_init (PidginMiniDialog *self)
 
361
{
 
362
    GtkBox *self_box = GTK_BOX (self);
 
363
    guint label_width = LABEL_WIDTH;
 
364
 
 
365
    PidginMiniDialogPrivate *priv = g_new0 (PidginMiniDialogPrivate, 1);
 
366
    self->priv = priv;
 
367
 
 
368
    gtk_container_set_border_width (GTK_CONTAINER (self), HIG_BOX_SPACE);
 
369
 
 
370
    priv->title_box = GTK_BOX (gtk_hbox_new (FALSE, HIG_BOX_SPACE));
 
371
 
 
372
    priv->icon = GTK_IMAGE (gtk_image_new());
 
373
    gtk_misc_set_alignment (GTK_MISC (priv->icon), 0, 0);
 
374
 
 
375
    priv->title = GTK_LABEL (gtk_label_new (NULL));
 
376
    gtk_widget_set_size_request (GTK_WIDGET (priv->title), label_width, -1);
 
377
    gtk_label_set_line_wrap (priv->title, TRUE);
 
378
    gtk_label_set_selectable (priv->title, TRUE);
 
379
    gtk_misc_set_alignment (GTK_MISC (priv->title), 0, 0);
 
380
 
 
381
    gtk_box_pack_start (priv->title_box, GTK_WIDGET (priv->icon), FALSE, FALSE, 0);
 
382
    gtk_box_pack_start (priv->title_box, GTK_WIDGET (priv->title), TRUE, TRUE, 0);
 
383
 
 
384
    priv->desc = GTK_LABEL (gtk_label_new (NULL));
 
385
    gtk_widget_set_size_request (GTK_WIDGET (priv->desc), label_width, -1);
 
386
    gtk_label_set_line_wrap (priv->desc, TRUE);
 
387
    gtk_misc_set_alignment (GTK_MISC (priv->desc), 0, 0);
 
388
    gtk_label_set_selectable (priv->desc, TRUE);
 
389
    /* make calling show_all() on the minidialog not affect desc even though
 
390
     * it's packed inside it.
 
391
     */
 
392
    g_object_set (G_OBJECT (priv->desc), "no-show-all", TRUE, NULL);
 
393
 
 
394
    self->contents = GTK_BOX (gtk_vbox_new (FALSE, 0));
 
395
 
 
396
    priv->buttons = GTK_BOX (gtk_hbox_new (FALSE, 0));
 
397
 
 
398
    gtk_box_pack_start (self_box, GTK_WIDGET (priv->title_box), FALSE, FALSE, 0);
 
399
    gtk_box_pack_start (self_box, GTK_WIDGET (priv->desc), FALSE, FALSE, 0);
 
400
    gtk_box_pack_start (self_box, GTK_WIDGET (self->contents), TRUE, TRUE, 0);
 
401
    gtk_box_pack_start (self_box, GTK_WIDGET (priv->buttons), FALSE, FALSE, 0);
 
402
 
 
403
    gtk_widget_show_all (GTK_WIDGET (self));
423
404
}