~ubuntu-branches/ubuntu/utopic/gnome-online-accounts/utopic

« back to all changes in this revision

Viewing changes to src/goabackend/goaeditablelabel.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson, Laurent Bigonville, Andreas Henriksson
  • Date: 2014-05-16 11:42:52 UTC
  • mfrom: (1.1.28) (0.1.12 sid)
  • Revision ID: package-import@ubuntu.com-20140516114252-u5ect6mk6ht8i38x
Tags: 3.12.2-1
[ Laurent Bigonville ]
* debian/control.in: Recommends realmd package (Closes: #725965)

[ Andreas Henriksson ]
* New upstream release.
  - Removes chat support from Windows Live provider (XMPP gateway gone).
* Bump Standards-Version to 3.9.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
2
 
 *
3
 
 * Copyright (C) 2009-2011 Red Hat, Inc.
4
 
 *
5
 
 * This library 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) any later version.
9
 
 *
10
 
 * This library 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
16
 
 * Public License along with this library; if not, write to the
17
 
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18
 
 * Boston, MA 02111-1307, USA.
19
 
 *
20
 
 * Based on panels/user-accounts/um-editable-entry.c from
21
 
 * gnome-control-center by Matthias Clasen <mclasen@redhat.com>.
22
 
 * Relicensed to LGPLv2 after obtaining permission.
23
 
 */
24
 
 
25
 
#include <gdk/gdkkeysyms.h>
26
 
#include "goaeditablelabel.h"
27
 
 
28
 
#define EMPTY_TEXT "\xe2\x80\x94"
29
 
 
30
 
struct _GoaEditableLabelPrivate {
31
 
        GtkNotebook *notebook;
32
 
        GtkLabel    *label;
33
 
        GtkButton   *button;
34
 
        GtkEntry    *entry;
35
 
 
36
 
        gchar *text;
37
 
        gboolean editable;
38
 
        gint weight;
39
 
        gboolean weight_set;
40
 
        gdouble scale;
41
 
        gboolean scale_set;
42
 
};
43
 
 
44
 
#define GOA_EDITABLE_LABEL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GOA_TYPE_EDITABLE_LABEL, GoaEditableLabelPrivate))
45
 
 
46
 
enum {
47
 
        PROP_0,
48
 
        PROP_TEXT,
49
 
        PROP_EDITABLE,
50
 
        PROP_SCALE,
51
 
        PROP_SCALE_SET,
52
 
        PROP_WEIGHT,
53
 
        PROP_WEIGHT_SET
54
 
};
55
 
 
56
 
enum {
57
 
        EDITING_DONE,
58
 
        LAST_SIGNAL
59
 
};
60
 
 
61
 
static guint signals [LAST_SIGNAL] = { 0, };
62
 
 
63
 
G_DEFINE_TYPE (GoaEditableLabel, goa_editable_label, GTK_TYPE_ALIGNMENT);
64
 
 
65
 
void
66
 
goa_editable_label_set_text (GoaEditableLabel *e,
67
 
                             const gchar    *text)
68
 
{
69
 
        GoaEditableLabelPrivate *priv;
70
 
        gchar *tmp;
71
 
        const gchar *label_text;
72
 
        GtkWidget *label;
73
 
 
74
 
        priv = e->priv;
75
 
 
76
 
        tmp = g_strdup (text);
77
 
        g_free (priv->text);
78
 
        priv->text = tmp;
79
 
 
80
 
        gtk_entry_set_text (priv->entry, tmp);
81
 
 
82
 
        label_text = tmp;
83
 
        if (label_text == NULL || label_text[0] == '\0')
84
 
                label_text = EMPTY_TEXT;
85
 
 
86
 
        gtk_label_set_text (priv->label, label_text);
87
 
        label = gtk_bin_get_child (GTK_BIN (priv->button));
88
 
        gtk_label_set_text (GTK_LABEL (label), label_text);
89
 
 
90
 
        g_object_notify (G_OBJECT (e), "text");
91
 
}
92
 
 
93
 
const gchar *
94
 
goa_editable_label_get_text (GoaEditableLabel *e)
95
 
{
96
 
        return e->priv->text;
97
 
}
98
 
 
99
 
void
100
 
goa_editable_label_set_editable (GoaEditableLabel *e,
101
 
                                 gboolean        editable)
102
 
{
103
 
        GoaEditableLabelPrivate *priv;
104
 
 
105
 
        priv = e->priv;
106
 
 
107
 
        if (priv->editable != editable) {
108
 
                priv->editable = editable;
109
 
 
110
 
                gtk_notebook_set_current_page (priv->notebook, editable ? 1 : 0);
111
 
 
112
 
                g_object_notify (G_OBJECT (e), "editable");
113
 
        }
114
 
}
115
 
 
116
 
gboolean
117
 
goa_editable_label_get_editable (GoaEditableLabel *e)
118
 
{
119
 
        return e->priv->editable;
120
 
}
121
 
 
122
 
static void
123
 
update_entry_font (GtkWidget        *widget,
124
 
                   GoaEditableLabel *e)
125
 
{
126
 
        GoaEditableLabelPrivate *priv = e->priv;
127
 
        PangoFontDescription *desc;
128
 
        GtkStyleContext *style;
129
 
        gint size;
130
 
 
131
 
        if (!priv->weight_set && !priv->scale_set)
132
 
                return;
133
 
 
134
 
        g_signal_handlers_block_by_func (widget, update_entry_font, e);
135
 
 
136
 
        gtk_widget_override_font (widget, NULL);        
137
 
 
138
 
        style = gtk_widget_get_style_context (widget);
139
 
        desc = pango_font_description_copy 
140
 
                (gtk_style_context_get_font (style, gtk_widget_get_state_flags (widget)));
141
 
 
142
 
        if (priv->weight_set)
143
 
                pango_font_description_set_weight (desc, priv->weight);
144
 
        if (priv->scale_set) {
145
 
                size = pango_font_description_get_size (desc);
146
 
                pango_font_description_set_size (desc, priv->scale * size);
147
 
        }
148
 
        gtk_widget_override_font (widget, desc);
149
 
 
150
 
        pango_font_description_free (desc);
151
 
 
152
 
        g_signal_handlers_unblock_by_func (widget, update_entry_font, e);
153
 
}
154
 
 
155
 
static void
156
 
update_fonts (GoaEditableLabel *e)
157
 
{
158
 
        PangoAttrList *attrs;
159
 
        PangoAttribute *attr;
160
 
        GtkWidget *label;
161
 
 
162
 
        GoaEditableLabelPrivate *priv = e->priv;
163
 
 
164
 
        attrs = pango_attr_list_new ();
165
 
        if (priv->scale_set) {
166
 
                attr = pango_attr_scale_new (priv->scale);
167
 
                pango_attr_list_insert (attrs, attr);
168
 
        }
169
 
        if (priv->weight_set) {
170
 
                attr = pango_attr_weight_new (priv->weight);
171
 
                pango_attr_list_insert (attrs, attr);
172
 
        }
173
 
 
174
 
        gtk_label_set_attributes (priv->label, attrs);
175
 
 
176
 
        label = gtk_bin_get_child (GTK_BIN (priv->button));
177
 
        gtk_label_set_attributes (GTK_LABEL (label), attrs);
178
 
 
179
 
        pango_attr_list_unref (attrs);
180
 
 
181
 
        update_entry_font ((GtkWidget *)priv->entry, e);
182
 
}
183
 
 
184
 
void
185
 
goa_editable_label_set_weight (GoaEditableLabel *e,
186
 
                               gint            weight)
187
 
{
188
 
        GoaEditableLabelPrivate *priv = e->priv;
189
 
 
190
 
        if (priv->weight == weight && priv->weight_set)
191
 
                return;
192
 
 
193
 
        priv->weight = weight;
194
 
        priv->weight_set = TRUE;
195
 
 
196
 
        update_fonts (e);
197
 
 
198
 
        g_object_notify (G_OBJECT (e), "weight");
199
 
        g_object_notify (G_OBJECT (e), "weight-set");
200
 
}
201
 
 
202
 
gint
203
 
goa_editable_label_get_weight (GoaEditableLabel *e)
204
 
{
205
 
        return e->priv->weight;
206
 
}
207
 
 
208
 
void
209
 
goa_editable_label_set_scale (GoaEditableLabel *e,
210
 
                              gdouble         scale)
211
 
{
212
 
        GoaEditableLabelPrivate *priv = e->priv;
213
 
 
214
 
        if (priv->scale == scale && priv->scale_set)
215
 
                return;
216
 
 
217
 
        priv->scale = scale;
218
 
        priv->scale_set = TRUE;
219
 
 
220
 
        update_fonts (e);
221
 
 
222
 
        g_object_notify (G_OBJECT (e), "scale");
223
 
        g_object_notify (G_OBJECT (e), "scale-set");
224
 
}
225
 
 
226
 
gdouble
227
 
goa_editable_label_get_scale (GoaEditableLabel *e)
228
 
{
229
 
        return e->priv->scale;
230
 
}
231
 
 
232
 
static void
233
 
goa_editable_label_set_property (GObject      *object,
234
 
                                guint         prop_id,
235
 
                                const GValue *value,
236
 
                                GParamSpec   *pspec)
237
 
{
238
 
        GoaEditableLabel *e = GOA_EDITABLE_LABEL (object);
239
 
 
240
 
        switch (prop_id) {
241
 
        case PROP_TEXT:
242
 
                goa_editable_label_set_text (e, g_value_get_string (value));
243
 
                break;
244
 
        case PROP_EDITABLE:
245
 
                goa_editable_label_set_editable (e, g_value_get_boolean (value));
246
 
                break;
247
 
        case PROP_WEIGHT:
248
 
                goa_editable_label_set_weight (e, g_value_get_int (value));
249
 
                break;
250
 
        case PROP_WEIGHT_SET:
251
 
                e->priv->weight_set = g_value_get_boolean (value);
252
 
                break;
253
 
        case PROP_SCALE:
254
 
                goa_editable_label_set_scale (e, g_value_get_double (value));
255
 
                break;
256
 
        case PROP_SCALE_SET:
257
 
                e->priv->scale_set = g_value_get_boolean (value);
258
 
                break;
259
 
        default:
260
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
261
 
                break;
262
 
        }
263
 
}
264
 
 
265
 
static void
266
 
goa_editable_label_get_property (GObject    *object,
267
 
                                guint       prop_id,
268
 
                                GValue     *value,
269
 
                                GParamSpec *pspec)
270
 
{
271
 
        GoaEditableLabel *e = GOA_EDITABLE_LABEL (object);
272
 
 
273
 
        switch (prop_id) {
274
 
        case PROP_TEXT:
275
 
                g_value_set_string (value,
276
 
                                    goa_editable_label_get_text (e));
277
 
                break;
278
 
        case PROP_EDITABLE:
279
 
                g_value_set_boolean (value,
280
 
                                     goa_editable_label_get_editable (e));
281
 
                break;
282
 
        case PROP_WEIGHT:
283
 
                g_value_set_int (value,
284
 
                                 goa_editable_label_get_weight (e));
285
 
                break;
286
 
        case PROP_WEIGHT_SET:
287
 
                g_value_set_boolean (value, e->priv->weight_set);
288
 
                break;
289
 
        case PROP_SCALE:
290
 
                g_value_set_double (value,
291
 
                                    goa_editable_label_get_scale (e));
292
 
                break;
293
 
        case PROP_SCALE_SET:
294
 
                g_value_set_boolean (value, e->priv->scale_set);
295
 
                break;
296
 
        default:
297
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
298
 
                break;
299
 
        }
300
 
}
301
 
 
302
 
static void
303
 
goa_editable_label_finalize (GObject *object)
304
 
{
305
 
        GoaEditableLabel *e = (GoaEditableLabel*)object;
306
 
 
307
 
        g_free (e->priv->text);
308
 
 
309
 
        G_OBJECT_CLASS (goa_editable_label_parent_class)->finalize (object);
310
 
}
311
 
 
312
 
static void
313
 
goa_editable_label_class_init (GoaEditableLabelClass *class)
314
 
{
315
 
        GObjectClass *object_class;
316
 
 
317
 
        object_class = G_OBJECT_CLASS (class);
318
 
 
319
 
        object_class->set_property = goa_editable_label_set_property;
320
 
        object_class->get_property = goa_editable_label_get_property;
321
 
        object_class->finalize = goa_editable_label_finalize;
322
 
 
323
 
        signals[EDITING_DONE] =
324
 
                g_signal_new ("editing-done",
325
 
                              G_TYPE_FROM_CLASS (class),
326
 
                              G_SIGNAL_RUN_LAST,
327
 
                              G_STRUCT_OFFSET (GoaEditableLabelClass, editing_done),
328
 
                              NULL, NULL,
329
 
                              g_cclosure_marshal_VOID__VOID,
330
 
                              G_TYPE_NONE, 0);
331
 
 
332
 
        g_object_class_install_property (object_class, PROP_TEXT,
333
 
                g_param_spec_string ("text",
334
 
                                     "Text", "The text of the button",
335
 
                                     NULL,
336
 
                                     G_PARAM_READWRITE));
337
 
 
338
 
        g_object_class_install_property (object_class, PROP_EDITABLE,
339
 
                g_param_spec_boolean ("editable",
340
 
                                      "Editable", "Whether the text can be edited",
341
 
                                      FALSE,
342
 
                                      G_PARAM_READWRITE));
343
 
 
344
 
        g_object_class_install_property (object_class, PROP_WEIGHT,
345
 
                g_param_spec_int ("weight",
346
 
                                  "Font Weight", "The font weight to use",
347
 
                                  0, G_MAXINT, PANGO_WEIGHT_NORMAL,
348
 
                                  G_PARAM_READWRITE));
349
 
 
350
 
        g_object_class_install_property (object_class, PROP_WEIGHT_SET,
351
 
                g_param_spec_boolean ("weight-set",
352
 
                                      "Font Weight Set", "Whether a font weight is set",
353
 
                                      FALSE,
354
 
                                      G_PARAM_READWRITE));
355
 
 
356
 
        g_object_class_install_property (object_class, PROP_SCALE,
357
 
                g_param_spec_double ("scale",
358
 
                                     "Font Scale", "The font scale to use",
359
 
                                     0.0, G_MAXDOUBLE, 1.0,
360
 
                                     G_PARAM_READWRITE));
361
 
 
362
 
        g_object_class_install_property (object_class, PROP_SCALE_SET,
363
 
                g_param_spec_boolean ("scale-set",
364
 
                                      "Font Scale Set", "Whether a font scale is set",
365
 
                                      FALSE,
366
 
                                      G_PARAM_READWRITE));
367
 
 
368
 
        g_type_class_add_private (class, sizeof (GoaEditableLabelPrivate));
369
 
}
370
 
 
371
 
static void
372
 
start_editing (GoaEditableLabel *e)
373
 
{
374
 
        gtk_notebook_set_current_page (e->priv->notebook, 2);
375
 
}
376
 
 
377
 
static void
378
 
stop_editing (GoaEditableLabel *e)
379
 
{
380
 
        goa_editable_label_set_text (e, gtk_entry_get_text (e->priv->entry));
381
 
        gtk_notebook_set_current_page (e->priv->notebook, 1);
382
 
        g_signal_emit (e, signals[EDITING_DONE], 0);
383
 
}
384
 
 
385
 
static void
386
 
cancel_editing (GoaEditableLabel *e)
387
 
{
388
 
        gtk_entry_set_text (e->priv->entry, goa_editable_label_get_text (e));
389
 
        gtk_notebook_set_current_page (e->priv->notebook, 1);
390
 
}
391
 
 
392
 
static void
393
 
button_clicked (GtkWidget       *widget,
394
 
                GoaEditableLabel *e)
395
 
{
396
 
        start_editing (e);
397
 
}
398
 
 
399
 
static void
400
 
entry_activated (GtkWidget       *widget,
401
 
                 GoaEditableLabel *e)
402
 
{
403
 
        stop_editing (e);
404
 
}
405
 
 
406
 
static gboolean
407
 
entry_focus_out (GtkWidget       *widget,
408
 
                 GdkEventFocus   *event,
409
 
                 GoaEditableLabel *e)
410
 
{
411
 
        stop_editing (e);
412
 
        return FALSE;
413
 
}
414
 
 
415
 
static gboolean
416
 
entry_key_press (GtkWidget       *widget,
417
 
                 GdkEventKey     *event,
418
 
                 GoaEditableLabel *e)
419
 
{
420
 
        if (event->keyval == GDK_KEY_Escape) {
421
 
                cancel_editing (e);
422
 
        }
423
 
        return FALSE;
424
 
}
425
 
 
426
 
static void
427
 
update_button_padding (GtkWidget       *widget,
428
 
                       GtkAllocation   *allocation,
429
 
                       GoaEditableLabel *e)
430
 
{
431
 
        GoaEditableLabelPrivate *priv = e->priv;
432
 
        GtkAllocation alloc;
433
 
        gint offset;
434
 
        gint pad;
435
 
 
436
 
        gtk_widget_get_allocation (gtk_widget_get_parent (widget), &alloc);
437
 
 
438
 
        offset = allocation->x - alloc.x;
439
 
 
440
 
        gtk_misc_get_padding  (GTK_MISC (priv->label), &pad, NULL);
441
 
        if (offset != pad)
442
 
                gtk_misc_set_padding (GTK_MISC (priv->label), offset, 0);
443
 
}
444
 
 
445
 
static void
446
 
goa_editable_label_init (GoaEditableLabel *e)
447
 
{
448
 
        GoaEditableLabelPrivate *priv;
449
 
 
450
 
        priv = e->priv = GOA_EDITABLE_LABEL_GET_PRIVATE (e);
451
 
 
452
 
        priv->weight = PANGO_WEIGHT_NORMAL;
453
 
        priv->weight_set = FALSE;
454
 
        priv->scale = 1.0;
455
 
        priv->scale_set = FALSE;
456
 
 
457
 
        priv->notebook = (GtkNotebook*)gtk_notebook_new ();
458
 
        gtk_notebook_set_show_tabs (priv->notebook, FALSE);
459
 
        gtk_notebook_set_show_border (priv->notebook, FALSE);
460
 
 
461
 
        priv->label = (GtkLabel*)gtk_label_new (EMPTY_TEXT);
462
 
        gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
463
 
        gtk_notebook_append_page (priv->notebook, (GtkWidget*)priv->label, NULL);
464
 
 
465
 
        priv->button = (GtkButton*)gtk_button_new_with_label (EMPTY_TEXT);
466
 
        gtk_widget_set_receives_default ((GtkWidget*)priv->button, TRUE);
467
 
        gtk_button_set_relief (priv->button, GTK_RELIEF_NONE);
468
 
        gtk_button_set_alignment (priv->button, 0.0, 0.5);
469
 
        gtk_notebook_append_page (priv->notebook, (GtkWidget*)priv->button, NULL);
470
 
        g_signal_connect (priv->button, "clicked", G_CALLBACK (button_clicked), e);
471
 
 
472
 
        priv->entry = (GtkEntry*)gtk_entry_new ();
473
 
        gtk_notebook_append_page (priv->notebook, (GtkWidget*)priv->entry, NULL);
474
 
 
475
 
        g_signal_connect (priv->entry, "activate", G_CALLBACK (entry_activated), e);
476
 
        g_signal_connect (priv->entry, "focus-out-event", G_CALLBACK (entry_focus_out), e);
477
 
        g_signal_connect (priv->entry, "key-press-event", G_CALLBACK (entry_key_press), e);
478
 
        g_signal_connect (priv->entry, "style-updated", G_CALLBACK (update_entry_font), e);
479
 
        g_signal_connect (gtk_bin_get_child (GTK_BIN (priv->button)), "size-allocate", G_CALLBACK (update_button_padding), e);
480
 
 
481
 
        gtk_container_add (GTK_CONTAINER (e), (GtkWidget*)priv->notebook);
482
 
 
483
 
        gtk_widget_show ((GtkWidget*)priv->notebook);
484
 
        gtk_widget_show ((GtkWidget*)priv->label);
485
 
        gtk_widget_show ((GtkWidget*)priv->button);
486
 
        gtk_widget_show ((GtkWidget*)priv->entry);
487
 
 
488
 
        gtk_notebook_set_current_page (priv->notebook, 0);
489
 
}
490
 
 
491
 
GtkWidget *
492
 
goa_editable_label_new (void)
493
 
{
494
 
        return (GtkWidget *) g_object_new (GOA_TYPE_EDITABLE_LABEL, NULL);
495
 
}