← Back to branch summary

~ubuntu-branches/ubuntu/wily/baobab/wily-proposed

« back to all changes in this revision

Viewing changes to libgd/libgd/gd-main-toolbar.c

  • Committer: Package Import Robot
  • Author(s): Matthew Fischer
  • Date: 2013-05-23 19:36:13 UTC
  • mfrom: (1.1.13)
  • Revision ID: package-import@ubuntu.com-20130523193613-6wrnnsmgwidm86c3
Tags: 3.8.2-0ubuntu1
https://launchpad.net/bugs/1181921
* New upstream release (LP: #1181921)
* Use a menu button instead of toolbar items
* Update to the latest libgd and egglistbox
* Add an High Contrast icon
* Use the newest libgd to animate tranistion to and from the results
  page
* Minor bugfixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgd/libgd/gd-main-toolbar.c
1
 
/*
2
 
 * Copyright (c) 2011 Red Hat, Inc.
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify
5
 
 * it under the terms of the GNU Lesser General Public License as published by 
6
 
 * the Free Software Foundation; either version 2 of the License, or (at your
7
 
 * option) any later version.
8
 
 *
9
 
 * This program is distributed in the hope that it will be useful, but
10
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11
 
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public 
12
 
 * License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU Lesser General Public License 
15
 
 * along with this program; if not, write to the Free Software Foundation,
16
 
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
 
 *
18
 
 * Author: Cosimo Cecchi <cosimoc@redhat.com>
19
 
 *
20
 
 */
21
 
 
22
 
#include "gd-main-toolbar.h"
23
 
 
24
 
#include <math.h>
25
 
#include <glib/gi18n.h>
26
 
 
27
 
G_DEFINE_TYPE (GdMainToolbar, gd_main_toolbar, GTK_TYPE_TOOLBAR)
28
 
 
29
 
typedef enum {
30
 
  CHILD_NORMAL = 0,
31
 
  CHILD_TOGGLE = 1,
32
 
  CHILD_MENU = 2,
33
 
} ChildType;
34
 
 
35
 
struct _GdMainToolbarPrivate {
36
 
  GtkSizeGroup *size_group;
37
 
  GtkSizeGroup *vertical_size_group;
38
 
 
39
 
  GtkToolItem *left_group;
40
 
  GtkToolItem *center_group;
41
 
  GtkToolItem *right_group;
42
 
 
43
 
  GtkWidget *left_grid;
44
 
 
45
 
  GtkWidget *labels_grid;
46
 
  GtkWidget *title_label;
47
 
  GtkWidget *detail_label;
48
 
 
49
 
  GtkWidget *center_menu;
50
 
  GtkWidget *center_menu_child;
51
 
 
52
 
  GtkWidget *right_grid;
53
 
};
54
 
 
55
 
static void
56
 
gd_main_toolbar_dispose (GObject *obj)
57
 
{
58
 
  GdMainToolbar *self = GD_MAIN_TOOLBAR (obj);
59
 
 
60
 
  g_clear_object (&self->priv->size_group);
61
 
  g_clear_object (&self->priv->vertical_size_group);
62
 
 
63
 
  G_OBJECT_CLASS (gd_main_toolbar_parent_class)->dispose (obj);
64
 
}
65
 
 
66
 
static gint
67
 
get_icon_margin (void)
68
 
{
69
 
  gint toolbar_size, menu_size;
70
 
 
71
 
  gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &menu_size, NULL);
72
 
  gtk_icon_size_lookup (GTK_ICON_SIZE_LARGE_TOOLBAR, &toolbar_size, NULL);
73
 
  return (gint) floor ((toolbar_size - menu_size) / 2.0);
74
 
}
75
 
 
76
 
static GtkSizeGroup *
77
 
get_vertical_size_group (void)
78
 
{
79
 
  GtkSizeGroup *retval;
80
 
  GtkWidget *w, *dummy;
81
 
  gint icon_margin;
82
 
 
83
 
  icon_margin = get_icon_margin ();
84
 
 
85
 
  dummy = gtk_toggle_button_new ();
86
 
  w = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
87
 
  g_object_set (w, "margin", icon_margin, NULL);
88
 
  gtk_container_add (GTK_CONTAINER (dummy), w);
89
 
  gtk_widget_show_all (dummy);
90
 
 
91
 
  retval = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
92
 
  gtk_size_group_add_widget (retval, dummy);
93
 
 
94
 
  return retval;
95
 
}
96
 
 
97
 
static GtkWidget *
98
 
get_empty_button (ChildType type)
99
 
{
100
 
  GtkWidget *button;
101
 
 
102
 
  switch (type)
103
 
    {
104
 
    case CHILD_MENU:
105
 
      button = gtk_menu_button_new ();
106
 
      break;
107
 
    case CHILD_TOGGLE:
108
 
      button = gtk_toggle_button_new ();
109
 
      break;
110
 
    case CHILD_NORMAL:
111
 
    default:
112
 
      button = gtk_button_new ();
113
 
      break;
114
 
    }
115
 
 
116
 
  return button;
117
 
}
118
 
 
119
 
static GtkWidget *
120
 
get_symbolic_button (const gchar *icon_name,
121
 
                     ChildType    type)
122
 
{
123
 
  GtkWidget *button, *w;
124
 
 
125
 
  switch (type)
126
 
    {
127
 
    case CHILD_MENU:
128
 
      button = gtk_menu_button_new ();
129
 
      gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (button)));
130
 
      break;
131
 
    case CHILD_TOGGLE:
132
 
      button = gtk_toggle_button_new ();
133
 
      break;
134
 
    case CHILD_NORMAL:
135
 
    default:
136
 
      button = gtk_button_new ();
137
 
      break;
138
 
    }
139
 
 
140
 
  gtk_style_context_add_class (gtk_widget_get_style_context (button), "raised");
141
 
 
142
 
  w = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
143
 
  g_object_set (w, "margin", get_icon_margin (), NULL);
144
 
  gtk_widget_show (w);
145
 
  gtk_container_add (GTK_CONTAINER (button), w);
146
 
 
147
 
  return button;
148
 
}
149
 
 
150
 
static GtkWidget *
151
 
get_text_button (const gchar *label,
152
 
                 ChildType    type)
153
 
{
154
 
  GtkWidget *button, *w;
155
 
 
156
 
  switch (type)
157
 
    {
158
 
    case CHILD_MENU:
159
 
      button = gtk_menu_button_new ();
160
 
      gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (button)));
161
 
 
162
 
      w = gtk_label_new (label);
163
 
      gtk_widget_show (w);
164
 
      gtk_container_add (GTK_CONTAINER (button), w);
165
 
      break;
166
 
    case CHILD_TOGGLE:
167
 
      button = gtk_toggle_button_new_with_label (label);
168
 
      break;
169
 
    case CHILD_NORMAL:
170
 
    default:
171
 
      button = gtk_button_new_with_label (label);
172
 
      break;
173
 
    }
174
 
 
175
 
  gtk_widget_set_vexpand (button, TRUE);
176
 
  gtk_style_context_add_class (gtk_widget_get_style_context (button), "raised");
177
 
 
178
 
  return button;
179
 
}
180
 
 
181
 
static void
182
 
gd_main_toolbar_constructed (GObject *obj)
183
 
{
184
 
  GdMainToolbar *self = GD_MAIN_TOOLBAR (obj);
185
 
  GtkToolbar *tb = GTK_TOOLBAR (obj);
186
 
  GtkWidget *grid;
187
 
 
188
 
  G_OBJECT_CLASS (gd_main_toolbar_parent_class)->constructed (obj);
189
 
 
190
 
  self->priv->vertical_size_group = get_vertical_size_group ();
191
 
 
192
 
  /* left section */
193
 
  self->priv->left_group = gtk_tool_item_new ();
194
 
  gtk_widget_set_margin_right (GTK_WIDGET (self->priv->left_group), 12);
195
 
  gtk_toolbar_insert (tb, self->priv->left_group, -1);
196
 
  gtk_size_group_add_widget (self->priv->vertical_size_group,
197
 
                             GTK_WIDGET (self->priv->left_group));
198
 
 
199
 
  /* left button group */
200
 
  self->priv->left_grid = gtk_grid_new ();
201
 
  gtk_grid_set_column_spacing (GTK_GRID (self->priv->left_grid), 12);
202
 
  gtk_container_add (GTK_CONTAINER (self->priv->left_group), self->priv->left_grid);
203
 
  gtk_widget_set_halign (self->priv->left_grid, GTK_ALIGN_START);
204
 
 
205
 
  /* center section */
206
 
  self->priv->center_group = gtk_tool_item_new ();
207
 
  gtk_tool_item_set_expand (self->priv->center_group, TRUE);
208
 
  gtk_toolbar_insert (tb, self->priv->center_group, -1);
209
 
  gtk_size_group_add_widget (self->priv->vertical_size_group,
210
 
                             GTK_WIDGET (self->priv->center_group));
211
 
 
212
 
  /* centered label group */
213
 
  self->priv->labels_grid = grid = gtk_grid_new ();
214
 
  gtk_widget_set_halign (grid, GTK_ALIGN_CENTER);
215
 
  gtk_widget_set_valign (grid, GTK_ALIGN_CENTER);
216
 
  gtk_grid_set_column_spacing (GTK_GRID (grid), 12);
217
 
  gtk_container_add (GTK_CONTAINER (self->priv->center_group), grid);
218
 
 
219
 
  self->priv->title_label = gtk_label_new (NULL);
220
 
  gtk_label_set_ellipsize (GTK_LABEL (self->priv->title_label), PANGO_ELLIPSIZE_END);
221
 
  gtk_container_add (GTK_CONTAINER (grid), self->priv->title_label);
222
 
 
223
 
  self->priv->detail_label = gtk_label_new (NULL);
224
 
  gtk_widget_set_no_show_all (self->priv->detail_label, TRUE);
225
 
  gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->detail_label), "dim-label");
226
 
  gtk_container_add (GTK_CONTAINER (grid), self->priv->detail_label);
227
 
 
228
 
  /* right section */
229
 
  self->priv->right_group = gtk_tool_item_new ();
230
 
  gtk_widget_set_margin_left (GTK_WIDGET (self->priv->right_group), 12);
231
 
  gtk_toolbar_insert (tb, self->priv->right_group, -1);
232
 
  gtk_size_group_add_widget (self->priv->vertical_size_group,
233
 
                             GTK_WIDGET (self->priv->right_group));
234
 
 
235
 
  self->priv->right_grid = gtk_grid_new ();
236
 
  gtk_grid_set_column_spacing (GTK_GRID (self->priv->right_grid), 12);
237
 
  gtk_container_add (GTK_CONTAINER (self->priv->right_group), self->priv->right_grid);
238
 
  gtk_widget_set_halign (self->priv->right_grid, GTK_ALIGN_END);
239
 
 
240
 
  self->priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
241
 
  gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->left_group));
242
 
  gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->right_group));
243
 
}
244
 
 
245
 
static void
246
 
gd_main_toolbar_init (GdMainToolbar *self)
247
 
{
248
 
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GD_TYPE_MAIN_TOOLBAR, GdMainToolbarPrivate);
249
 
}
250
 
 
251
 
static void
252
 
gd_main_toolbar_class_init (GdMainToolbarClass *klass)
253
 
{
254
 
  GObjectClass *oclass;
255
 
 
256
 
  oclass = G_OBJECT_CLASS (klass);
257
 
  oclass->constructed = gd_main_toolbar_constructed;
258
 
  oclass->dispose = gd_main_toolbar_dispose;
259
 
 
260
 
  g_type_class_add_private (klass, sizeof (GdMainToolbarPrivate));
261
 
}
262
 
 
263
 
void
264
 
gd_main_toolbar_clear (GdMainToolbar *self)
265
 
{
266
 
  /* reset labels */
267
 
  gtk_label_set_text (GTK_LABEL (self->priv->title_label), "");
268
 
  gtk_label_set_text (GTK_LABEL (self->priv->detail_label), "");
269
 
 
270
 
  /* clear all added buttons */
271
 
  gtk_container_foreach (GTK_CONTAINER (self->priv->left_grid),
272
 
                         (GtkCallback) gtk_widget_destroy, self);
273
 
  gtk_container_foreach (GTK_CONTAINER (self->priv->right_grid), 
274
 
                         (GtkCallback) gtk_widget_destroy, self);
275
 
}
276
 
 
277
 
/**
278
 
 * gd_main_toolbar_set_labels:
279
 
 * @self:
280
 
 * @primary: (allow-none):
281
 
 * @detail: (allow-none):
282
 
 *
283
 
 */
284
 
void
285
 
gd_main_toolbar_set_labels (GdMainToolbar *self,
286
 
                            const gchar *primary,
287
 
                            const gchar *detail)
288
 
{
289
 
  gchar *real_primary = NULL;
290
 
 
291
 
  if (primary != NULL)
292
 
    real_primary = g_markup_printf_escaped ("<b>%s</b>", primary);
293
 
 
294
 
  if (real_primary == NULL)
295
 
    {
296
 
      gtk_label_set_markup (GTK_LABEL (self->priv->title_label), "");
297
 
      gtk_widget_hide (self->priv->title_label);
298
 
    }
299
 
  else
300
 
    {
301
 
      gtk_label_set_markup (GTK_LABEL (self->priv->title_label), real_primary);
302
 
      gtk_widget_show (self->priv->title_label);
303
 
    }
304
 
 
305
 
  if (detail == NULL)
306
 
    {
307
 
      gtk_label_set_text (GTK_LABEL (self->priv->detail_label), "");
308
 
      gtk_widget_hide (self->priv->detail_label);
309
 
    }
310
 
  else
311
 
    {
312
 
      gtk_label_set_text (GTK_LABEL (self->priv->detail_label), detail);
313
 
      gtk_widget_show (self->priv->detail_label);
314
 
    }
315
 
 
316
 
  g_free (real_primary);
317
 
}
318
 
 
319
 
GtkWidget *
320
 
gd_main_toolbar_new (void)
321
 
{
322
 
  return g_object_new (GD_TYPE_MAIN_TOOLBAR, NULL);
323
 
}
324
 
 
325
 
static GtkWidget *
326
 
add_button_internal (GdMainToolbar *self,
327
 
                     const gchar *icon_name,
328
 
                     const gchar *label,
329
 
                     gboolean pack_start,
330
 
                     ChildType type)
331
 
{
332
 
  GtkWidget *button;
333
 
 
334
 
  if (icon_name != NULL)
335
 
    {
336
 
      button = get_symbolic_button (icon_name, type);
337
 
      if (label != NULL)
338
 
        gtk_widget_set_tooltip_text (button, label);
339
 
    }
340
 
  else if (label != NULL)
341
 
    {
342
 
      button = get_text_button (label, type);
343
 
    }
344
 
  else
345
 
    {
346
 
      button = get_empty_button (type);
347
 
    }
348
 
 
349
 
  gd_main_toolbar_add_widget (self, button, pack_start);
350
 
 
351
 
  gtk_widget_show_all (button);
352
 
 
353
 
  return button;
354
 
}
355
 
 
356
 
/**
357
 
 * gd_main_toolbar_set_labels_menu:
358
 
 * @self:
359
 
 * @menu: (allow-none):
360
 
 *
361
 
 */
362
 
void
363
 
gd_main_toolbar_set_labels_menu (GdMainToolbar *self,
364
 
                                 GMenuModel    *menu)
365
 
{
366
 
  GtkWidget *button, *grid, *w;
367
 
 
368
 
  if (menu == NULL &&
369
 
      ((gtk_widget_get_parent (self->priv->labels_grid) == GTK_WIDGET (self->priv->center_group)) ||
370
 
       self->priv->center_menu_child == NULL))
371
 
    return;
372
 
 
373
 
  if (menu != NULL)
374
 
    {
375
 
      g_object_ref (self->priv->labels_grid);
376
 
      gtk_container_remove (GTK_CONTAINER (self->priv->center_group),
377
 
                            self->priv->labels_grid);
378
 
 
379
 
      self->priv->center_menu_child = grid = gtk_grid_new ();
380
 
      gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
381
 
      gtk_container_add (GTK_CONTAINER (grid), self->priv->labels_grid);
382
 
      g_object_unref (self->priv->labels_grid);
383
 
 
384
 
      w = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
385
 
      gtk_container_add (GTK_CONTAINER (grid), w);
386
 
 
387
 
      self->priv->center_menu = button = gtk_menu_button_new ();
388
 
      gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->center_menu),
389
 
                                   "selection-menu");
390
 
      gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (button)));
391
 
      gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
392
 
      gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu);
393
 
      gtk_container_add (GTK_CONTAINER (self->priv->center_menu), grid);
394
 
 
395
 
      gtk_container_add (GTK_CONTAINER (self->priv->center_group), button);
396
 
    }
397
 
  else
398
 
    {
399
 
      g_object_ref (self->priv->labels_grid);
400
 
      gtk_container_remove (GTK_CONTAINER (self->priv->center_menu_child),
401
 
                            self->priv->labels_grid);
402
 
      gtk_widget_destroy (self->priv->center_menu);
403
 
 
404
 
      self->priv->center_menu = NULL;
405
 
      self->priv->center_menu_child = NULL;
406
 
 
407
 
      gtk_container_add (GTK_CONTAINER (self->priv->center_group),
408
 
                         self->priv->labels_grid);
409
 
      g_object_unref (self->priv->labels_grid);
410
 
    }
411
 
 
412
 
  gtk_widget_show_all (GTK_WIDGET (self->priv->center_group));
413
 
}
414
 
 
415
 
/**
416
 
 * gd_main_toolbar_add_button:
417
 
 * @self:
418
 
 * @icon_name: (allow-none):
419
 
 * @label: (allow-none):
420
 
 * @pack_start:
421
 
 *
422
 
 * Returns: (transfer none):
423
 
 */
424
 
GtkWidget *
425
 
gd_main_toolbar_add_button (GdMainToolbar *self,
426
 
                            const gchar *icon_name,
427
 
                            const gchar *label,
428
 
                            gboolean pack_start)
429
 
{
430
 
  return add_button_internal (self, icon_name, label, pack_start, CHILD_NORMAL);
431
 
}
432
 
 
433
 
/**
434
 
 * gd_main_toolbar_add_menu:
435
 
 * @self:
436
 
 * @icon_name: (allow-none):
437
 
 * @label: (allow-none):
438
 
 * @pack_start:
439
 
 *
440
 
 * Returns: (transfer none):
441
 
 */
442
 
GtkWidget *
443
 
gd_main_toolbar_add_menu (GdMainToolbar *self,
444
 
                          const gchar *icon_name,
445
 
                          const gchar *label,
446
 
                          gboolean pack_start)
447
 
{
448
 
  return add_button_internal (self, icon_name, label, pack_start, CHILD_MENU);
449
 
}
450
 
 
451
 
/**
452
 
 * gd_main_toolbar_add_toggle:
453
 
 * @self:
454
 
 * @icon_name: (allow-none):
455
 
 * @label: (allow-none):
456
 
 * @pack_start:
457
 
 *
458
 
 * Returns: (transfer none):
459
 
 */
460
 
GtkWidget *
461
 
gd_main_toolbar_add_toggle (GdMainToolbar *self,
462
 
                            const gchar *icon_name,
463
 
                            const gchar *label,
464
 
                            gboolean pack_start)
465
 
{
466
 
  return add_button_internal (self, icon_name, label, pack_start, CHILD_TOGGLE);
467
 
}
468
 
 
469
 
/**
470
 
 * gd_main_toolbar_add_widget:
471
 
 * @self:
472
 
 * @widget:
473
 
 * @pack_start:
474
 
 *
475
 
 */
476
 
void
477
 
gd_main_toolbar_add_widget (GdMainToolbar *self,
478
 
                            GtkWidget *widget,
479
 
                            gboolean pack_start)
480
 
{
481
 
  if (pack_start)
482
 
    gtk_container_add (GTK_CONTAINER (self->priv->left_grid), widget);
483
 
  else
484
 
    gtk_container_add (GTK_CONTAINER (self->priv->right_grid), widget);
485
 
}