← Back to branch summary

~ubuntu-branches/ubuntu/trusty/unity-control-center/trusty

« back to all changes in this revision

Viewing changes to panels/user-accounts/um-editable-combo.c

  • Committer: Package Import Robot
  • Author(s): Robert Ancell
  • Date: 2014-01-08 16:29:18 UTC
  • Revision ID: package-import@ubuntu.com-20140108162918-g29dd08tr913y2qh
Tags: upstream-14.04.0
Import upstream version 14.04.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
panels/user-accounts/um-editable-combo.c
 
1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
 
2
 *
 
3
 * Copyright 2009-2010  Red Hat, Inc,
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
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 General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
18
 *
 
19
 * Written by: Matthias Clasen <mclasen@redhat.com>
 
20
 */
 
21
 
 
22
#include <gdk/gdkkeysyms.h>
 
23
#include "um-editable-combo.h"
 
24
 
 
25
#define EMPTY_TEXT "\xe2\x80\x94"
 
26
 
 
27
struct _UmEditableComboPrivate {
 
28
        GtkNotebook *notebook;
 
29
        GtkLabel    *label;
 
30
        GtkButton   *button;
 
31
        GtkComboBox *combo;
 
32
        GtkWidget   *toplevel;
 
33
 
 
34
        gint active;
 
35
        gint editable;
 
36
        gint text_column;
 
37
};
 
38
 
 
39
#define UM_EDITABLE_COMBO_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), UM_TYPE_EDITABLE_COMBO, UmEditableComboPrivate))
 
40
 
 
41
enum {
 
42
        PROP_0,
 
43
        PROP_EDITABLE,
 
44
        PROP_MODEL,
 
45
        PROP_TEXT_COLUMN
 
46
};
 
47
 
 
48
enum {
 
49
        EDITING_DONE,
 
50
        ACTIVATE,
 
51
        LAST_SIGNAL
 
52
};
 
53
 
 
54
static guint signals [LAST_SIGNAL] = { 0, };
 
55
 
 
56
G_DEFINE_TYPE (UmEditableCombo, um_editable_combo, GTK_TYPE_ALIGNMENT);
 
57
 
 
58
void
 
59
um_editable_combo_set_editable (UmEditableCombo *combo,
 
60
                                gboolean         editable)
 
61
{
 
62
        UmEditableComboPrivate *priv;
 
63
 
 
64
        priv = combo->priv;
 
65
 
 
66
        if (priv->editable != editable) {
 
67
                priv->editable = editable;
 
68
 
 
69
                gtk_notebook_set_current_page (priv->notebook, editable ? 1 : 0);
 
70
 
 
71
                g_object_notify (G_OBJECT (combo), "editable");
 
72
        }
 
73
}
 
74
 
 
75
gboolean
 
76
um_editable_combo_get_editable (UmEditableCombo *combo)
 
77
{
 
78
        return combo->priv->editable;
 
79
}
 
80
 
 
81
void
 
82
um_editable_combo_set_model (UmEditableCombo *combo,
 
83
                             GtkTreeModel    *model)
 
84
{
 
85
        gtk_combo_box_set_model (combo->priv->combo, model);
 
86
 
 
87
        g_object_notify (G_OBJECT (combo), "model");
 
88
}
 
89
 
 
90
GtkTreeModel *
 
91
um_editable_combo_get_model (UmEditableCombo *combo)
 
92
{
 
93
        return gtk_combo_box_get_model (combo->priv->combo);
 
94
}
 
95
 
 
96
void
 
97
um_editable_combo_set_text_column (UmEditableCombo *combo,
 
98
                                   gint             text_column)
 
99
{
 
100
        UmEditableComboPrivate *priv = combo->priv;
 
101
        GList *cells;
 
102
 
 
103
        if (priv->text_column == text_column)
 
104
                return;
 
105
 
 
106
        priv->text_column = text_column;
 
107
 
 
108
        cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->combo));
 
109
        gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (priv->combo),
 
110
                                        cells->data,
 
111
                                        "text", text_column,
 
112
                                        NULL);
 
113
        g_list_free (cells);
 
114
 
 
115
        g_object_notify (G_OBJECT (combo), "text-column");
 
116
}
 
117
 
 
118
gint
 
119
um_editable_combo_get_text_column (UmEditableCombo *combo)
 
120
{
 
121
        return combo->priv->text_column;
 
122
}
 
123
 
 
124
void
 
125
um_editable_combo_set_active (UmEditableCombo *combo,
 
126
                              gint             active)
 
127
{
 
128
        GtkTreeModel *model;
 
129
        GtkTreePath *path;
 
130
        GtkTreeIter iter;
 
131
 
 
132
        if (active == -1)
 
133
                um_editable_combo_set_active_iter (combo, NULL);
 
134
        else {
 
135
                model = gtk_combo_box_get_model (combo->priv->combo);
 
136
                path = gtk_tree_path_new_from_indices (active, -1);
 
137
                gtk_tree_model_get_iter (model, &iter, path);
 
138
                gtk_tree_path_free (path);
 
139
                um_editable_combo_set_active_iter (combo, &iter);
 
140
        }
 
141
}
 
142
 
 
143
void
 
144
um_editable_combo_set_active_iter (UmEditableCombo *combo,
 
145
                                   GtkTreeIter     *iter)
 
146
{
 
147
        UmEditableComboPrivate *priv = combo->priv;
 
148
        GtkWidget *label;
 
149
        gchar *text;
 
150
        GtkTreeModel *model;
 
151
 
 
152
        gtk_combo_box_set_active_iter (priv->combo, iter);
 
153
        priv->active = gtk_combo_box_get_active (priv->combo);
 
154
 
 
155
        if (priv->text_column == -1)
 
156
                return;
 
157
 
 
158
        if (iter) {
 
159
                model = gtk_combo_box_get_model (priv->combo);
 
160
                gtk_tree_model_get (model, iter, priv->text_column, &text, -1);
 
161
        }
 
162
        else {
 
163
                text = g_strdup (EMPTY_TEXT);
 
164
        }
 
165
 
 
166
        gtk_label_set_text (priv->label, text);
 
167
        label = gtk_bin_get_child ((GtkBin*)priv->button);
 
168
        gtk_label_set_text (GTK_LABEL (label), text);
 
169
 
 
170
        g_free (text);
 
171
}
 
172
 
 
173
gboolean
 
174
um_editable_combo_get_active_iter (UmEditableCombo *combo,
 
175
                                   GtkTreeIter     *iter)
 
176
{
 
177
        return gtk_combo_box_get_active_iter (combo->priv->combo, iter);
 
178
}
 
179
 
 
180
gint
 
181
um_editable_combo_get_active (UmEditableCombo *combo)
 
182
{
 
183
        return combo->priv->active;
 
184
}
 
185
 
 
186
static void
 
187
um_editable_combo_set_property (GObject      *object,
 
188
                                guint         prop_id,
 
189
                                const GValue *value,
 
190
                                GParamSpec   *pspec)
 
191
{
 
192
        UmEditableCombo *combo = UM_EDITABLE_COMBO (object);
 
193
 
 
194
        switch (prop_id) {
 
195
        case PROP_EDITABLE:
 
196
                um_editable_combo_set_editable (combo, g_value_get_boolean (value));
 
197
                break;
 
198
        case PROP_MODEL:
 
199
                um_editable_combo_set_model (combo, g_value_get_object (value));
 
200
                break;
 
201
        case PROP_TEXT_COLUMN:
 
202
                um_editable_combo_set_text_column (combo, g_value_get_int (value));
 
203
                break;
 
204
        default:
 
205
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
206
                break;
 
207
        }
 
208
}
 
209
 
 
210
static void
 
211
um_editable_combo_get_property (GObject    *object,
 
212
                                guint       prop_id,
 
213
                                GValue     *value,
 
214
                                GParamSpec *pspec)
 
215
{
 
216
        UmEditableCombo *combo = UM_EDITABLE_COMBO (object);
 
217
 
 
218
        switch (prop_id) {
 
219
        case PROP_EDITABLE:
 
220
                g_value_set_boolean (value,
 
221
                                     um_editable_combo_get_editable (combo));
 
222
                break;
 
223
        case PROP_MODEL:
 
224
                g_value_set_object (value,
 
225
                                    um_editable_combo_get_model (combo));
 
226
                break;
 
227
        case PROP_TEXT_COLUMN:
 
228
                g_value_set_int (value,
 
229
                                 um_editable_combo_get_text_column (combo));
 
230
                break;
 
231
        default:
 
232
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
233
                break;
 
234
        }
 
235
}
 
236
 
 
237
static void um_editable_combo_activate (UmEditableCombo *combo);
 
238
 
 
239
static void
 
240
um_editable_combo_class_init (UmEditableComboClass *class)
 
241
{
 
242
        GObjectClass *object_class;
 
243
        GtkWidgetClass *widget_class;
 
244
 
 
245
        object_class = G_OBJECT_CLASS (class);
 
246
        widget_class = GTK_WIDGET_CLASS (class);
 
247
 
 
248
        object_class->set_property = um_editable_combo_set_property;
 
249
        object_class->get_property = um_editable_combo_get_property;
 
250
 
 
251
        signals[EDITING_DONE] =
 
252
                g_signal_new ("editing-done",
 
253
                              G_TYPE_FROM_CLASS (class),
 
254
                              G_SIGNAL_RUN_LAST,
 
255
                              G_STRUCT_OFFSET (UmEditableComboClass, editing_done),
 
256
                              NULL, NULL,
 
257
                              g_cclosure_marshal_VOID__VOID,
 
258
                              G_TYPE_NONE, 0);
 
259
        signals[ACTIVATE] =
 
260
                g_signal_new ("activate",
 
261
                              G_TYPE_FROM_CLASS (class),
 
262
                              G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 
263
                              G_STRUCT_OFFSET (UmEditableComboClass, activate),
 
264
                              NULL, NULL,
 
265
                              g_cclosure_marshal_VOID__VOID,
 
266
                              G_TYPE_NONE, 0);
 
267
        widget_class->activate_signal = signals[ACTIVATE];
 
268
        class->activate = um_editable_combo_activate;
 
269
 
 
270
        g_object_class_install_property (object_class, PROP_MODEL,
 
271
                g_param_spec_object ("model",
 
272
                                     "Model", "The options to present in the combobox",
 
273
                                     GTK_TYPE_TREE_MODEL,
 
274
                                     G_PARAM_READWRITE));
 
275
 
 
276
        g_object_class_install_property (object_class, PROP_TEXT_COLUMN,
 
277
                g_param_spec_int ("text-column",
 
278
                                  "Text Column", "The model column that contains the displayable text",
 
279
                                  -1, G_MAXINT, -1,
 
280
                                  G_PARAM_READWRITE));
 
281
 
 
282
 
 
283
        g_object_class_install_property (object_class, PROP_EDITABLE,
 
284
                g_param_spec_boolean ("editable",
 
285
                                      "Editable", "Whether the text can be edited",
 
286
                                      FALSE,
 
287
                                      G_PARAM_READWRITE));
 
288
 
 
289
        g_type_class_add_private (class, sizeof (UmEditableComboPrivate));
 
290
}
 
291
 
 
292
static void
 
293
start_editing (UmEditableCombo *combo)
 
294
{
 
295
        gtk_notebook_set_current_page (combo->priv->notebook, 2);
 
296
        gtk_combo_box_popup (combo->priv->combo);
 
297
}
 
298
 
 
299
static void
 
300
stop_editing (UmEditableCombo *combo)
 
301
{
 
302
        um_editable_combo_set_active (combo,
 
303
                                      gtk_combo_box_get_active (combo->priv->combo));
 
304
        gtk_notebook_set_current_page (combo->priv->notebook, 1);
 
305
 
 
306
        g_signal_emit (combo, signals[EDITING_DONE], 0);
 
307
}
 
308
 
 
309
static void
 
310
cancel_editing (UmEditableCombo *combo)
 
311
{
 
312
        gtk_combo_box_set_active (combo->priv->combo,
 
313
                                  um_editable_combo_get_active (combo));
 
314
        gtk_notebook_set_current_page (combo->priv->notebook, 1);
 
315
}
 
316
 
 
317
static void
 
318
um_editable_combo_activate (UmEditableCombo *combo)
 
319
{
 
320
        if (combo->priv->editable) {
 
321
                gtk_notebook_set_current_page (combo->priv->notebook, 2);
 
322
                gtk_widget_grab_focus (GTK_WIDGET (combo->priv->combo));
 
323
        }
 
324
}
 
325
 
 
326
static void
 
327
button_clicked (GtkWidget       *widget,
 
328
                UmEditableCombo *combo)
 
329
{
 
330
        if (combo->priv->editable)
 
331
                start_editing (combo);
 
332
}
 
333
 
 
334
static void
 
335
combo_changed (GtkWidget       *widget,
 
336
               UmEditableCombo *combo)
 
337
{
 
338
        if (combo->priv->editable)
 
339
                stop_editing (combo);
 
340
}
 
341
 
 
342
static gboolean
 
343
combo_key_press (GtkWidget       *widget,
 
344
                 GdkEventKey     *event,
 
345
                 UmEditableCombo *combo)
 
346
{
 
347
        if (event->keyval == GDK_KEY_Escape) {
 
348
                cancel_editing (combo);
 
349
                return TRUE;
 
350
        }
 
351
        return FALSE;
 
352
}
 
353
 
 
354
static void
 
355
focus_moved (GtkWindow       *window,
 
356
             GtkWidget       *widget,
 
357
             UmEditableCombo *combo)
 
358
{
 
359
        if (gtk_notebook_get_current_page (combo->priv->notebook) == 2 &&
 
360
            (!widget || !gtk_widget_is_ancestor (widget, (GtkWidget *)combo)))
 
361
                stop_editing (combo);
 
362
}
 
363
 
 
364
static void
 
365
combo_hierarchy_changed (GtkWidget       *widget,
 
366
                         GtkWidget       *previous_toplevel,
 
367
                         UmEditableCombo *combo)
 
368
{
 
369
        UmEditableComboPrivate *priv;
 
370
        GtkWidget *toplevel;
 
371
 
 
372
        priv = combo->priv;
 
373
 
 
374
        toplevel = gtk_widget_get_toplevel (widget);
 
375
        if (priv->toplevel != toplevel) {
 
376
                if (priv->toplevel)
 
377
                        g_signal_handlers_disconnect_by_func (priv->toplevel,
 
378
                                                              focus_moved, combo);
 
379
 
 
380
                if (GTK_IS_WINDOW (toplevel))
 
381
                        priv->toplevel = toplevel;
 
382
                else
 
383
                        priv->toplevel = NULL;
 
384
 
 
385
                if (priv->toplevel)
 
386
                        g_signal_connect (priv->toplevel, "set-focus",
 
387
                                          G_CALLBACK (focus_moved), combo);
 
388
        }
 
389
}
 
390
 
 
391
static void
 
392
update_button_padding (GtkWidget       *widget,
 
393
                       GtkAllocation   *allocation,
 
394
                       UmEditableCombo *combo)
 
395
{
 
396
        UmEditableComboPrivate *priv = combo->priv;
 
397
        GtkAllocation parent_allocation;
 
398
        gint offset;
 
399
        gint pad;
 
400
 
 
401
        gtk_widget_get_allocation (gtk_widget_get_parent (widget), &parent_allocation);
 
402
 
 
403
        offset = allocation->x - parent_allocation.x;
 
404
 
 
405
        gtk_misc_get_padding  (GTK_MISC (priv->label), &pad, NULL);
 
406
        if (offset != pad)
 
407
                gtk_misc_set_padding (GTK_MISC (priv->label), offset, 0);
 
408
}
 
409
 
 
410
static void
 
411
um_editable_combo_init (UmEditableCombo *combo)
 
412
{
 
413
        UmEditableComboPrivate *priv;
 
414
        GtkCellRenderer *cell;
 
415
 
 
416
        priv = combo->priv = UM_EDITABLE_COMBO_GET_PRIVATE (combo);
 
417
 
 
418
        priv->active = -1;
 
419
        priv->text_column = -1;
 
420
 
 
421
        priv->notebook = (GtkNotebook*)gtk_notebook_new ();
 
422
        gtk_notebook_set_show_tabs (priv->notebook, FALSE);
 
423
        gtk_notebook_set_show_border (priv->notebook, FALSE);
 
424
 
 
425
        priv->label = (GtkLabel*)gtk_label_new ("");
 
426
        gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
 
427
        gtk_notebook_append_page (priv->notebook, (GtkWidget*)priv->label, NULL);
 
428
 
 
429
        priv->button = (GtkButton*)gtk_button_new_with_label ("");
 
430
        gtk_widget_set_receives_default ((GtkWidget*)priv->button, TRUE);
 
431
        gtk_button_set_relief (priv->button, GTK_RELIEF_NONE);
 
432
        gtk_button_set_alignment (priv->button, 0.0, 0.5);
 
433
        gtk_notebook_append_page (priv->notebook, (GtkWidget*)priv->button, NULL);
 
434
        g_signal_connect (priv->button, "clicked", G_CALLBACK (button_clicked), combo);
 
435
 
 
436
        priv->combo = (GtkComboBox*)gtk_combo_box_new ();
 
437
        cell = gtk_cell_renderer_text_new ();
 
438
        gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->combo), cell, TRUE);
 
439
        gtk_notebook_append_page (priv->notebook, (GtkWidget*)priv->combo, NULL);
 
440
 
 
441
        g_signal_connect (priv->combo, "changed", G_CALLBACK (combo_changed), combo);
 
442
        g_signal_connect (priv->combo, "key-press-event", G_CALLBACK (combo_key_press), combo);
 
443
        g_signal_connect (gtk_bin_get_child (GTK_BIN (priv->button)), "size-allocate", G_CALLBACK (update_button_padding), combo);
 
444
 
 
445
 
 
446
        gtk_container_add (GTK_CONTAINER (combo), (GtkWidget*)priv->notebook);
 
447
 
 
448
        gtk_widget_show ((GtkWidget*)priv->notebook);
 
449
        gtk_widget_show ((GtkWidget*)priv->label);
 
450
        gtk_widget_show ((GtkWidget*)priv->button);
 
451
        gtk_widget_show ((GtkWidget*)priv->combo);
 
452
 
 
453
        gtk_notebook_set_current_page (priv->notebook, 0);
 
454
 
 
455
        /* ugly hack to catch the combo box losing focus */
 
456
        g_signal_connect (combo, "hierarchy-changed",
 
457
                          G_CALLBACK (combo_hierarchy_changed), combo);
 
458
}
 
459
 
 
460
GtkWidget *
 
461
um_editable_combo_new (void)
 
462
{
 
463
        return (GtkWidget *) g_object_new (UM_TYPE_EDITABLE_COMBO, NULL);
 
464
}