← Back to branch summary

~noskcaj/ubuntu/trusty/gnome-documents/3.10.2

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson, Thomas Bechtold
  • Date: 2013-04-04 13:32:08 UTC
  • mfrom: (3.1.4 experimental)
  • Revision ID: package-import@ubuntu.com-20130404133208-n19gqczi05z31ogb
Tags: 3.8.0-1
[ Thomas Bechtold ]
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgd/libgd/gd-main-toolbar.c
1
1
/*
2
 
 * Copyright (c) 2011 Red Hat, Inc.
 
2
 * Copyright (c) 2011, 2012 Red Hat, Inc.
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU Lesser General Public License as published by 
20
20
 */
21
21
 
22
22
#include "gd-main-toolbar.h"
 
23
#include "gd-header-button.h"
23
24
 
24
25
#include <math.h>
25
26
#include <glib/gi18n.h>
26
27
 
27
28
G_DEFINE_TYPE (GdMainToolbar, gd_main_toolbar, GTK_TYPE_TOOLBAR)
28
29
 
29
 
typedef enum {
30
 
  CHILD_NORMAL = 0,
31
 
  CHILD_TOGGLE = 1,
32
 
  CHILD_MENU = 2,
33
 
} ChildType;
34
 
 
35
30
struct _GdMainToolbarPrivate {
36
31
  GtkSizeGroup *size_group;
37
32
  GtkSizeGroup *vertical_size_group;
41
36
  GtkToolItem *right_group;
42
37
 
43
38
  GtkWidget *left_grid;
 
39
  GtkWidget *center_grid;
44
40
 
45
41
  GtkWidget *labels_grid;
46
42
  GtkWidget *title_label;
47
43
  GtkWidget *detail_label;
48
44
 
 
45
  GtkWidget *modes_box;
 
46
 
49
47
  GtkWidget *center_menu;
50
48
  GtkWidget *center_menu_child;
51
49
 
52
50
  GtkWidget *right_grid;
 
51
 
 
52
  gboolean show_modes;
 
53
};
 
54
 
 
55
enum {
 
56
        PROP_0,
 
57
        PROP_SHOW_MODES,
53
58
};
54
59
 
55
60
static void
63
68
  G_OBJECT_CLASS (gd_main_toolbar_parent_class)->dispose (obj);
64
69
}
65
70
 
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
71
static GtkSizeGroup *
77
 
get_vertical_size_group (void)
 
72
get_vertical_size_group (GdMainToolbar *self)
78
73
{
79
74
  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);
 
75
  GtkWidget *dummy;
 
76
  GtkToolItem *container;
 
77
 
 
78
  dummy = gd_header_simple_button_new ();
 
79
  gd_header_button_set_label (GD_HEADER_BUTTON (dummy), "Dummy");
 
80
  container = gtk_tool_item_new ();
 
81
  gtk_widget_set_no_show_all (GTK_WIDGET (container), TRUE);
 
82
  gtk_container_add (GTK_CONTAINER (container), dummy);
 
83
  gtk_toolbar_insert (GTK_TOOLBAR (self), container, -1);
90
84
 
91
85
  retval = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
92
86
  gtk_size_group_add_widget (retval, dummy);
94
88
  return retval;
95
89
}
96
90
 
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;
 
91
gboolean
 
92
gd_main_toolbar_get_show_modes (GdMainToolbar *self)
 
93
{
 
94
  return self->priv->show_modes;
 
95
}
 
96
 
 
97
void
 
98
gd_main_toolbar_set_show_modes (GdMainToolbar *self,
 
99
                                gboolean show_modes)
 
100
{
 
101
  if (self->priv->show_modes == show_modes)
 
102
    return;
 
103
 
 
104
  self->priv->show_modes = show_modes;
 
105
  if (self->priv->show_modes)
 
106
    {
 
107
      gtk_widget_set_no_show_all (self->priv->labels_grid, TRUE);
 
108
      gtk_widget_hide (self->priv->labels_grid);
 
109
 
 
110
      gtk_widget_set_valign (self->priv->center_grid, GTK_ALIGN_FILL);
 
111
      gtk_widget_set_no_show_all (self->priv->modes_box, FALSE);
 
112
      gtk_widget_show_all (self->priv->modes_box);
 
113
    }
 
114
  else
 
115
    {
 
116
      gtk_widget_set_no_show_all (self->priv->modes_box, TRUE);
 
117
      gtk_widget_hide (self->priv->modes_box);
 
118
 
 
119
      gtk_widget_set_valign (self->priv->center_grid, GTK_ALIGN_CENTER);
 
120
      gtk_widget_set_no_show_all (self->priv->labels_grid, FALSE);
 
121
      gtk_widget_show_all (self->priv->labels_grid);
 
122
    }
 
123
 
 
124
  g_object_notify (G_OBJECT (self), "show-modes");
 
125
}
 
126
 
 
127
static void
 
128
gd_main_toolbar_set_property (GObject      *object,
 
129
                              guint         prop_id,
 
130
                              const GValue *value,
 
131
                              GParamSpec   *pspec)
 
132
{
 
133
 
 
134
  GdMainToolbar *self = GD_MAIN_TOOLBAR (object);
 
135
 
 
136
  switch (prop_id)
 
137
    {
 
138
    case PROP_SHOW_MODES:
 
139
      gd_main_toolbar_set_show_modes (GD_MAIN_TOOLBAR (self), g_value_get_boolean (value));
 
140
      break;
 
141
    default:
 
142
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
143
      break;
 
144
    }
 
145
}
 
146
 
 
147
static void
 
148
gd_main_toolbar_get_property (GObject    *object,
 
149
                              guint       prop_id,
 
150
                              GValue     *value,
 
151
                              GParamSpec *pspec)
 
152
{
 
153
  GdMainToolbar *self = GD_MAIN_TOOLBAR (object);
 
154
 
 
155
  switch (prop_id)
 
156
    {
 
157
    case PROP_SHOW_MODES:
 
158
      g_value_set_boolean (value, self->priv->show_modes);
 
159
      break;
 
160
    default:
 
161
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
162
      break;
 
163
    }
179
164
}
180
165
 
181
166
static void
187
172
 
188
173
  G_OBJECT_CLASS (gd_main_toolbar_parent_class)->constructed (obj);
189
174
 
190
 
  self->priv->vertical_size_group = get_vertical_size_group ();
 
175
  self->priv->vertical_size_group = get_vertical_size_group (self);
191
176
 
192
177
  /* left section */
193
178
  self->priv->left_group = gtk_tool_item_new ();
206
191
  self->priv->center_group = gtk_tool_item_new ();
207
192
  gtk_tool_item_set_expand (self->priv->center_group, TRUE);
208
193
  gtk_toolbar_insert (tb, self->priv->center_group, -1);
 
194
  self->priv->center_grid = gtk_grid_new ();
 
195
  gtk_widget_set_halign (self->priv->center_grid, GTK_ALIGN_CENTER);
 
196
  gtk_widget_set_valign (self->priv->center_grid, GTK_ALIGN_CENTER);
 
197
  gtk_container_add (GTK_CONTAINER (self->priv->center_group), self->priv->center_grid);
209
198
  gtk_size_group_add_widget (self->priv->vertical_size_group,
210
199
                             GTK_WIDGET (self->priv->center_group));
211
200
 
212
201
  /* centered label group */
213
202
  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
203
  gtk_grid_set_column_spacing (GTK_GRID (grid), 12);
217
 
  gtk_container_add (GTK_CONTAINER (self->priv->center_group), grid);
 
204
  gtk_container_add (GTK_CONTAINER (self->priv->center_grid), grid);
218
205
 
219
206
  self->priv->title_label = gtk_label_new (NULL);
220
207
  gtk_label_set_ellipsize (GTK_LABEL (self->priv->title_label), PANGO_ELLIPSIZE_END);
226
213
  gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->detail_label), "dim-label");
227
214
  gtk_container_add (GTK_CONTAINER (grid), self->priv->detail_label);
228
215
 
 
216
  /* centered mode group */
 
217
  self->priv->modes_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 
218
  gtk_box_set_homogeneous (GTK_BOX (self->priv->modes_box), TRUE);
 
219
  gtk_widget_set_no_show_all (self->priv->modes_box, TRUE);
 
220
  gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->modes_box), "linked");
 
221
  gtk_container_add (GTK_CONTAINER (self->priv->center_grid), self->priv->modes_box);
 
222
 
229
223
  /* right section */
230
224
  self->priv->right_group = gtk_tool_item_new ();
231
225
  gtk_widget_set_margin_left (GTK_WIDGET (self->priv->right_group), 12);
256
250
 
257
251
  oclass = G_OBJECT_CLASS (klass);
258
252
  oclass->constructed = gd_main_toolbar_constructed;
 
253
  oclass->set_property = gd_main_toolbar_set_property;
 
254
  oclass->get_property = gd_main_toolbar_get_property;
259
255
  oclass->dispose = gd_main_toolbar_dispose;
260
256
 
 
257
  g_object_class_install_property (oclass,
 
258
                                   PROP_SHOW_MODES,
 
259
                                   g_param_spec_boolean ("show-modes",
 
260
                                                         "Show Modes",
 
261
                                                         "Show Modes",
 
262
                                                         FALSE,
 
263
                                                         G_PARAM_READWRITE));
 
264
 
261
265
  g_type_class_add_private (klass, sizeof (GdMainToolbarPrivate));
262
266
}
263
267
 
271
275
  /* clear all added buttons */
272
276
  gtk_container_foreach (GTK_CONTAINER (self->priv->left_grid),
273
277
                         (GtkCallback) gtk_widget_destroy, self);
 
278
  gtk_container_foreach (GTK_CONTAINER (self->priv->modes_box),
 
279
                         (GtkCallback) gtk_widget_destroy, self);
274
280
  gtk_container_foreach (GTK_CONTAINER (self->priv->right_grid), 
275
281
                         (GtkCallback) gtk_widget_destroy, self);
276
282
}
323
329
  return g_object_new (GD_TYPE_MAIN_TOOLBAR, NULL);
324
330
}
325
331
 
326
 
static GtkWidget *
327
 
add_button_internal (GdMainToolbar *self,
328
 
                     const gchar *icon_name,
329
 
                     const gchar *label,
330
 
                     gboolean pack_start,
331
 
                     ChildType type)
332
 
{
333
 
  GtkWidget *button;
334
 
 
335
 
  if (icon_name != NULL)
336
 
    {
337
 
      button = get_symbolic_button (icon_name, type);
338
 
      if (label != NULL)
339
 
        gtk_widget_set_tooltip_text (button, label);
340
 
    }
341
 
  else if (label != NULL)
342
 
    {
343
 
      button = get_text_button (label, type);
344
 
    }
345
 
  else
346
 
    {
347
 
      button = get_empty_button (type);
348
 
    }
349
 
 
350
 
  gd_main_toolbar_add_widget (self, button, pack_start);
351
 
 
352
 
  gtk_widget_show_all (button);
353
 
 
354
 
  return button;
355
 
}
356
 
 
357
332
/**
358
333
 * gd_main_toolbar_set_labels_menu:
359
334
 * @self:
367
342
  GtkWidget *button, *grid, *w;
368
343
 
369
344
  if (menu == NULL &&
370
 
      ((gtk_widget_get_parent (self->priv->labels_grid) == GTK_WIDGET (self->priv->center_group)) ||
 
345
      ((gtk_widget_get_parent (self->priv->labels_grid) == self->priv->center_grid) ||
371
346
       self->priv->center_menu_child == NULL))
372
347
    return;
373
348
 
374
349
  if (menu != NULL)
375
350
    {
376
351
      g_object_ref (self->priv->labels_grid);
377
 
      gtk_container_remove (GTK_CONTAINER (self->priv->center_group),
 
352
      gtk_container_remove (GTK_CONTAINER (self->priv->center_grid),
378
353
                            self->priv->labels_grid);
379
354
 
380
355
      self->priv->center_menu_child = grid = gtk_grid_new ();
393
368
      gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu);
394
369
      gtk_container_add (GTK_CONTAINER (self->priv->center_menu), grid);
395
370
 
396
 
      gtk_container_add (GTK_CONTAINER (self->priv->center_group), button);
 
371
      gtk_container_add (GTK_CONTAINER (self->priv->center_grid), button);
397
372
    }
398
373
  else
399
374
    {
405
380
      self->priv->center_menu = NULL;
406
381
      self->priv->center_menu_child = NULL;
407
382
 
408
 
      gtk_container_add (GTK_CONTAINER (self->priv->center_group),
 
383
      gtk_container_add (GTK_CONTAINER (self->priv->center_grid),
409
384
                         self->priv->labels_grid);
410
385
      g_object_unref (self->priv->labels_grid);
411
386
    }
412
387
 
413
 
  gtk_widget_show_all (GTK_WIDGET (self->priv->center_group));
 
388
  gtk_widget_show_all (self->priv->center_grid);
 
389
}
 
390
 
 
391
/**
 
392
 * gd_main_toolbar_add_mode:
 
393
 * @self:
 
394
 * @label:
 
395
 *
 
396
 * Returns: (transfer none):
 
397
 */
 
398
GtkWidget *
 
399
gd_main_toolbar_add_mode (GdMainToolbar *self,
 
400
                          const gchar *label)
 
401
{
 
402
  GtkWidget *button;
 
403
  GList *group;
 
404
 
 
405
  button = gtk_radio_button_new_with_label (NULL, label);
 
406
  gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
 
407
  gtk_widget_set_size_request (button, 100, -1);
 
408
  gtk_style_context_add_class (gtk_widget_get_style_context (button), "raised");
 
409
  gtk_style_context_add_class (gtk_widget_get_style_context (button), "text-button");
 
410
 
 
411
  group = gtk_container_get_children (GTK_CONTAINER (self->priv->modes_box));
 
412
  if (group != NULL)
 
413
    {
 
414
      gtk_radio_button_join_group (GTK_RADIO_BUTTON (button), GTK_RADIO_BUTTON (group->data));
 
415
      g_list_free (group);
 
416
    }
 
417
 
 
418
  gtk_container_add (GTK_CONTAINER (self->priv->modes_box), button);
 
419
  gtk_widget_show (button);
 
420
 
 
421
  return button;
414
422
}
415
423
 
416
424
/**
428
436
                            const gchar *label,
429
437
                            gboolean pack_start)
430
438
{
431
 
  return add_button_internal (self, icon_name, label, pack_start, CHILD_NORMAL);
 
439
  GtkWidget *button = gd_header_simple_button_new ();
 
440
 
 
441
  gd_header_button_set_symbolic_icon_name (GD_HEADER_BUTTON (button), icon_name);
 
442
  gd_header_button_set_label (GD_HEADER_BUTTON (button), label);
 
443
 
 
444
  gd_main_toolbar_add_widget (self, button, pack_start);
 
445
 
 
446
  return button;
432
447
}
433
448
 
434
449
/**
446
461
                          const gchar *label,
447
462
                          gboolean pack_start)
448
463
{
449
 
  return add_button_internal (self, icon_name, label, pack_start, CHILD_MENU);
 
464
  GtkWidget *button = gd_header_menu_button_new ();
 
465
 
 
466
  gd_header_button_set_symbolic_icon_name (GD_HEADER_BUTTON (button), icon_name);
 
467
  gd_header_button_set_label (GD_HEADER_BUTTON (button), label);
 
468
 
 
469
  gd_main_toolbar_add_widget (self, button, pack_start);
 
470
 
 
471
  return button;
450
472
}
451
473
 
452
474
/**
464
486
                            const gchar *label,
465
487
                            gboolean pack_start)
466
488
{
467
 
  return add_button_internal (self, icon_name, label, pack_start, CHILD_TOGGLE);
 
489
  GtkWidget *button = gd_header_toggle_button_new ();
 
490
 
 
491
  gd_header_button_set_symbolic_icon_name (GD_HEADER_BUTTON (button), icon_name);
 
492
  gd_header_button_set_label (GD_HEADER_BUTTON (button), label);
 
493
 
 
494
  gd_main_toolbar_add_widget (self, button, pack_start);
 
495
 
 
496
  return button;
468
497
}
469
498
 
470
499
/**