← Back to branch summary

~ubuntu-branches/debian/sid/cheese/sid

« back to all changes in this revision

Viewing changes to src/thumbview/eog-thumb-nav.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2011-07-17 21:04:16 UTC
  • mfrom: (15.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110717210416-nt5qi659qei7a2yy
Tags: 3.0.1-2
* debian/control.in:
  - Change gir1.2-cheese-3.0 Section to libs
  - Make library packages depend against cheese-common package
  - Make cheese package recommends against hicolor-icon-theme
  - Move gst Dependency to libcheese package
* debian/patches/0002-fix-linking.patch: Add missing library to fix linking
* debian/watch:
  - Switch to .bz2 tarballs.
  - Bump version to 3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/thumbview/eog-thumb-nav.c
 
1
/* Eye Of Gnome - Thumbnail Navigator
 
2
 *
 
3
 * Copyright (C) 2006 The Free Software Foundation
 
4
 *
 
5
 * Author: Lucas Rocha <lucasr@gnome.org>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License as published by
 
9
 * the Free Software Foundation; either version 2 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
20
 */
 
21
 
 
22
#ifdef HAVE_CONFIG_H
 
23
  #include <cheese-config.h>
 
24
#endif
 
25
 
 
26
#include "eog-thumb-nav.h"
 
27
#include "cheese-thumb-view.h"
 
28
 
 
29
#include <glib.h>
 
30
#include <glib/gi18n.h>
 
31
#include <glib-object.h>
 
32
#include <gtk/gtk.h>
 
33
#include <string.h>
 
34
 
 
35
#define EOG_THUMB_NAV_GET_PRIVATE(object) \
 
36
  (G_TYPE_INSTANCE_GET_PRIVATE ((object), EOG_TYPE_THUMB_NAV, EogThumbNavPrivate))
 
37
 
 
38
G_DEFINE_TYPE (EogThumbNav, eog_thumb_nav, GTK_TYPE_HBOX);
 
39
 
 
40
#define EOG_THUMB_NAV_SCROLL_INC     20
 
41
#define EOG_THUMB_NAV_SCROLL_MOVE    20
 
42
#define EOG_THUMB_NAV_SCROLL_TIMEOUT 20
 
43
 
 
44
enum
 
45
{
 
46
  PROP_SHOW_BUTTONS = 1,
 
47
  PROP_THUMB_VIEW,
 
48
  PROP_MODE
 
49
};
 
50
 
 
51
struct _EogThumbNavPrivate
 
52
{
 
53
  gboolean show_buttons;
 
54
  gboolean vertical;
 
55
  gboolean scroll_dir;
 
56
  gint scroll_pos;
 
57
  gint scroll_id;
 
58
 
 
59
  GtkWidget *button_up;
 
60
  GtkWidget *button_down;
 
61
  GtkWidget *button_left;
 
62
  GtkWidget *button_right;
 
63
  GtkWidget *sw;
 
64
  GtkWidget *thumbview;
 
65
  GtkWidget *vbox;
 
66
  GtkAdjustment *hadj;
 
67
  GtkAdjustment *vadj;
 
68
  GtkAdjustment *adj;
 
69
};
 
70
 
 
71
static gboolean
 
72
eog_thumb_nav_scroll_event (GtkWidget *widget, GdkEventScroll *event, gpointer user_data)
 
73
{
 
74
  EogThumbNav *nav = EOG_THUMB_NAV (user_data);
 
75
  gint         inc = EOG_THUMB_NAV_SCROLL_INC * 3;
 
76
  gdouble      value, upper, page_size;
 
77
 
 
78
  nav->priv->adj = nav->priv->vertical ? nav->priv->vadj : nav->priv->hadj;
 
79
 
 
80
  switch (event->direction)
 
81
  {
 
82
    case GDK_SCROLL_UP:
 
83
    case GDK_SCROLL_LEFT:
 
84
      inc *= -1;
 
85
      break;
 
86
 
 
87
    case GDK_SCROLL_DOWN:
 
88
    case GDK_SCROLL_RIGHT:
 
89
      break;
 
90
 
 
91
    default:
 
92
      g_assert_not_reached ();
 
93
      return FALSE;
 
94
  }
 
95
 
 
96
  value = gtk_adjustment_get_value (nav->priv->adj);
 
97
  if (inc < 0)
 
98
    gtk_adjustment_set_value (nav->priv->adj, MAX (0, value + inc));
 
99
  else
 
100
  {
 
101
    upper     = gtk_adjustment_get_upper (nav->priv->adj);
 
102
    page_size = gtk_adjustment_get_page_size (nav->priv->adj);
 
103
    gtk_adjustment_set_value (nav->priv->adj, MIN (upper - page_size, value + inc));
 
104
  }
 
105
 
 
106
  gtk_adjustment_value_changed (nav->priv->adj);
 
107
 
 
108
  return TRUE;
 
109
}
 
110
 
 
111
static void
 
112
eog_thumb_nav_vadj_changed (GtkAdjustment *vadj, gpointer user_data)
 
113
{
 
114
  EogThumbNav        *nav;
 
115
  EogThumbNavPrivate *priv;
 
116
  gboolean            ltr;
 
117
  gdouble             value, upper, page_size;
 
118
 
 
119
  nav  = EOG_THUMB_NAV (user_data);
 
120
  priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
121
  ltr  = gtk_widget_get_direction (priv->sw) == GTK_TEXT_DIR_LTR;
 
122
 
 
123
  g_object_get (vadj,
 
124
                "value", &value,
 
125
                "upper", &upper,
 
126
                "page_size", &page_size,
 
127
                NULL);
 
128
  gtk_widget_set_sensitive (priv->button_up, value > 0);
 
129
 
 
130
  gtk_widget_set_sensitive (priv->button_down,
 
131
                            value < upper - page_size);
 
132
}
 
133
 
 
134
static void
 
135
eog_thumb_nav_hadj_changed (GtkAdjustment *hadj, gpointer user_data)
 
136
{
 
137
  EogThumbNav        *nav;
 
138
  EogThumbNavPrivate *priv;
 
139
  gboolean            ltr;
 
140
  gdouble             value, upper, page_size;
 
141
 
 
142
  nav  = EOG_THUMB_NAV (user_data);
 
143
  priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
144
  ltr  = gtk_widget_get_direction (priv->sw) == GTK_TEXT_DIR_LTR;
 
145
 
 
146
  g_object_get (hadj,
 
147
                "value", &value,
 
148
                "upper", &upper,
 
149
                "page_size", &page_size,
 
150
                NULL);
 
151
 
 
152
  gtk_widget_set_sensitive (ltr ? priv->button_right : priv->button_left,
 
153
                            value < upper - page_size);
 
154
}
 
155
 
 
156
static void
 
157
eog_thumb_nav_vadj_value_changed (GtkAdjustment *vadj, gpointer user_data)
 
158
{
 
159
  EogThumbNav        *nav;
 
160
  EogThumbNavPrivate *priv;
 
161
  gboolean            ltr;
 
162
  gdouble             value, upper, page_size;
 
163
 
 
164
  nav  = EOG_THUMB_NAV (user_data);
 
165
  priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
166
  ltr  = gtk_widget_get_direction (priv->sw) == GTK_TEXT_DIR_LTR;
 
167
 
 
168
  g_object_get (vadj,
 
169
                "value", &value,
 
170
                "upper", &upper,
 
171
                "page_size", &page_size,
 
172
                NULL);
 
173
 
 
174
  gtk_widget_set_sensitive (priv->button_up, value > 0);
 
175
 
 
176
  gtk_widget_set_sensitive (priv->button_down,
 
177
                            value < upper - page_size);
 
178
}
 
179
 
 
180
static void
 
181
eog_thumb_nav_hadj_value_changed (GtkAdjustment *hadj, gpointer user_data)
 
182
{
 
183
  EogThumbNav        *nav;
 
184
  EogThumbNavPrivate *priv;
 
185
  gboolean            ltr;
 
186
  gdouble             value, upper, page_size;
 
187
 
 
188
  nav  = EOG_THUMB_NAV (user_data);
 
189
  priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
190
  ltr  = gtk_widget_get_direction (priv->sw) == GTK_TEXT_DIR_LTR;
 
191
 
 
192
  g_object_get (hadj,
 
193
                "value", &value,
 
194
                "upper", &upper,
 
195
                "page_size", &page_size,
 
196
                NULL);
 
197
 
 
198
  gtk_widget_set_sensitive (ltr ? priv->button_left : priv->button_right, value > 0);
 
199
 
 
200
  gtk_widget_set_sensitive (ltr ? priv->button_right : priv->button_left,
 
201
                            value < upper - page_size);
 
202
}
 
203
 
 
204
static gboolean
 
205
eog_thumb_nav_scroll_step (gpointer user_data)
 
206
{
 
207
  EogThumbNav *nav = EOG_THUMB_NAV (user_data);
 
208
  gint         delta;
 
209
  gdouble      value, upper, page_size;
 
210
 
 
211
  if (nav->priv->scroll_pos < 10)
 
212
    delta = EOG_THUMB_NAV_SCROLL_INC;
 
213
  else if (nav->priv->scroll_pos < 20)
 
214
    delta = EOG_THUMB_NAV_SCROLL_INC * 2;
 
215
  else if (nav->priv->scroll_pos < 30)
 
216
    delta = EOG_THUMB_NAV_SCROLL_INC * 2 + 5;
 
217
  else
 
218
    delta = EOG_THUMB_NAV_SCROLL_INC * 2 + 12;
 
219
 
 
220
  if (!nav->priv->scroll_dir)
 
221
    delta *= -1;
 
222
 
 
223
  g_object_get (nav->priv->adj,
 
224
                "value", &value,
 
225
                "upper", &upper,
 
226
                "page_size", &page_size,
 
227
                NULL);
 
228
 
 
229
  if ((gint) (value + (gdouble) delta) >= 0 &&
 
230
      (gint) (value + (gdouble) delta) <= upper - page_size)
 
231
  {
 
232
    gtk_adjustment_set_value (nav->priv->adj, value + (gdouble) delta);
 
233
    nav->priv->scroll_pos++;
 
234
    gtk_adjustment_value_changed (nav->priv->adj);
 
235
  }
 
236
  else
 
237
  {
 
238
    if (delta > 0)
 
239
      gtk_adjustment_set_value (nav->priv->adj, upper - page_size);
 
240
    else
 
241
      gtk_adjustment_set_value (nav->priv->adj, 0);
 
242
 
 
243
    nav->priv->scroll_pos = 0;
 
244
 
 
245
    gtk_adjustment_value_changed (nav->priv->adj);
 
246
 
 
247
    return FALSE;
 
248
  }
 
249
 
 
250
  return TRUE;
 
251
}
 
252
 
 
253
static void
 
254
eog_thumb_nav_button_clicked (GtkButton *button, EogThumbNav *nav)
 
255
{
 
256
  nav->priv->scroll_pos = 0;
 
257
 
 
258
  if ((GTK_WIDGET (button) == nav->priv->button_right) ||
 
259
      (GTK_WIDGET (button) == nav->priv->button_left))
 
260
  {
 
261
    nav->priv->scroll_dir = gtk_widget_get_direction (GTK_WIDGET (button)) == GTK_TEXT_DIR_LTR ?
 
262
                            GTK_WIDGET (button) == nav->priv->button_right :
 
263
                            GTK_WIDGET (button) == nav->priv->button_left;
 
264
  }
 
265
  else
 
266
  {
 
267
    nav->priv->scroll_dir = (GTK_WIDGET (button) == nav->priv->button_down);
 
268
  }
 
269
 
 
270
  nav->priv->adj = ((GTK_WIDGET (button) == nav->priv->button_right) ||
 
271
                    (GTK_WIDGET (button) == nav->priv->button_left)) ? nav->priv->hadj : nav->priv->vadj;
 
272
 
 
273
  eog_thumb_nav_scroll_step (nav);
 
274
}
 
275
 
 
276
static void
 
277
eog_thumb_nav_start_scroll (GtkButton *button, EogThumbNav *nav)
 
278
{
 
279
  if ((GTK_WIDGET (button) == nav->priv->button_right) ||
 
280
      (GTK_WIDGET (button) == nav->priv->button_left))
 
281
  {
 
282
    nav->priv->scroll_dir = gtk_widget_get_direction (GTK_WIDGET (button)) == GTK_TEXT_DIR_LTR ?
 
283
                            GTK_WIDGET (button) == nav->priv->button_right :
 
284
                            GTK_WIDGET (button) == nav->priv->button_left;
 
285
  }
 
286
  else
 
287
  {
 
288
    nav->priv->scroll_dir = (GTK_WIDGET (button) == nav->priv->button_down);
 
289
  }
 
290
 
 
291
  nav->priv->adj = ((GTK_WIDGET (button) == nav->priv->button_right) ||
 
292
                    (GTK_WIDGET (button) == nav->priv->button_left)) ? nav->priv->hadj : nav->priv->vadj;
 
293
 
 
294
  nav->priv->scroll_id = g_timeout_add (EOG_THUMB_NAV_SCROLL_TIMEOUT,
 
295
                                        eog_thumb_nav_scroll_step,
 
296
                                        nav);
 
297
}
 
298
 
 
299
static void
 
300
eog_thumb_nav_stop_scroll (GtkButton *button, EogThumbNav *nav)
 
301
{
 
302
  if (nav->priv->scroll_id > 0)
 
303
  {
 
304
    g_source_remove (nav->priv->scroll_id);
 
305
    nav->priv->scroll_id  = 0;
 
306
    nav->priv->scroll_pos = 0;
 
307
  }
 
308
}
 
309
 
 
310
static void
 
311
eog_thumb_nav_get_property (GObject    *object,
 
312
                            guint       property_id,
 
313
                            GValue     *value,
 
314
                            GParamSpec *pspec)
 
315
{
 
316
  EogThumbNav *nav = EOG_THUMB_NAV (object);
 
317
 
 
318
  switch (property_id)
 
319
  {
 
320
    case PROP_SHOW_BUTTONS:
 
321
      g_value_set_boolean (value,
 
322
                           eog_thumb_nav_get_show_buttons (nav));
 
323
      break;
 
324
 
 
325
    case PROP_THUMB_VIEW:
 
326
      g_value_set_object (value, nav->priv->thumbview);
 
327
      break;
 
328
  }
 
329
}
 
330
 
 
331
static void
 
332
eog_thumb_nav_set_property (GObject      *object,
 
333
                            guint         property_id,
 
334
                            const GValue *value,
 
335
                            GParamSpec   *pspec)
 
336
{
 
337
  EogThumbNav *nav = EOG_THUMB_NAV (object);
 
338
 
 
339
  switch (property_id)
 
340
  {
 
341
    case PROP_SHOW_BUTTONS:
 
342
      eog_thumb_nav_set_show_buttons (nav,
 
343
                                      g_value_get_boolean (value));
 
344
      break;
 
345
 
 
346
    case PROP_THUMB_VIEW:
 
347
      nav->priv->thumbview =
 
348
        GTK_WIDGET (g_value_get_object (value));
 
349
      break;
 
350
  }
 
351
}
 
352
 
 
353
static GObject *
 
354
eog_thumb_nav_constructor (GType                  type,
 
355
                           guint                  n_construct_properties,
 
356
                           GObjectConstructParam *construct_params)
 
357
{
 
358
  GObject            *object;
 
359
  EogThumbNav        *nav;
 
360
  EogThumbNavPrivate *priv;
 
361
 
 
362
  object = G_OBJECT_CLASS (eog_thumb_nav_parent_class)->constructor
 
363
             (type, n_construct_properties, construct_params);
 
364
 
 
365
  nav  = EOG_THUMB_NAV (object);
 
366
  priv = EOG_THUMB_NAV_GET_PRIVATE (object);
 
367
 
 
368
  if (priv->thumbview != NULL)
 
369
  {
 
370
    gtk_container_add (GTK_CONTAINER (priv->sw), priv->thumbview);
 
371
    gtk_widget_show_all (priv->sw);
 
372
  }
 
373
 
 
374
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->sw),
 
375
                                  GTK_POLICY_AUTOMATIC,
 
376
                                  GTK_POLICY_NEVER);
 
377
 
 
378
  return object;
 
379
}
 
380
 
 
381
static void
 
382
eog_thumb_nav_class_init (EogThumbNavClass *class)
 
383
{
 
384
  GObjectClass *g_object_class = (GObjectClass *) class;
 
385
 
 
386
  g_object_class->constructor  = eog_thumb_nav_constructor;
 
387
  g_object_class->get_property = eog_thumb_nav_get_property;
 
388
  g_object_class->set_property = eog_thumb_nav_set_property;
 
389
 
 
390
  g_object_class_install_property (g_object_class,
 
391
                                   PROP_SHOW_BUTTONS,
 
392
                                   g_param_spec_boolean ("show-buttons",
 
393
                                                         "Show Buttons",
 
394
                                                         "Whether to show navigation buttons or not",
 
395
                                                         TRUE,
 
396
                                                         (G_PARAM_READABLE | G_PARAM_WRITABLE)));
 
397
 
 
398
  g_object_class_install_property (g_object_class,
 
399
                                   PROP_THUMB_VIEW,
 
400
                                   g_param_spec_object ("thumbview",
 
401
                                                        "Thumbnail View",
 
402
                                                        "The internal thumbnail viewer widget",
 
403
                                                        CHEESE_TYPE_THUMB_VIEW,
 
404
                                                        (G_PARAM_CONSTRUCT_ONLY |
 
405
                                                         G_PARAM_READABLE |
 
406
                                                         G_PARAM_WRITABLE)));
 
407
 
 
408
  g_type_class_add_private (g_object_class, sizeof (EogThumbNavPrivate));
 
409
}
 
410
 
 
411
static void
 
412
eog_thumb_nav_init (EogThumbNav *nav)
 
413
{
 
414
  EogThumbNavPrivate *priv;
 
415
  GtkWidget          *arrow;
 
416
 
 
417
  nav->priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
418
 
 
419
  priv = nav->priv;
 
420
 
 
421
  priv->show_buttons = TRUE;
 
422
  priv->vertical     = FALSE;
 
423
 
 
424
  priv->button_left = gtk_button_new ();
 
425
  gtk_button_set_relief (GTK_BUTTON (priv->button_left), GTK_RELIEF_NONE);
 
426
 
 
427
  arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_ETCHED_IN);
 
428
  gtk_container_add (GTK_CONTAINER (priv->button_left), arrow);
 
429
 
 
430
  gtk_widget_set_size_request (GTK_WIDGET (priv->button_left), 25, 0);
 
431
 
 
432
  g_signal_connect (priv->button_left,
 
433
                    "clicked",
 
434
                    G_CALLBACK (eog_thumb_nav_button_clicked),
 
435
                    nav);
 
436
 
 
437
  g_signal_connect (priv->button_left,
 
438
                    "button-press-event",
 
439
                    G_CALLBACK (eog_thumb_nav_start_scroll),
 
440
                    nav);
 
441
 
 
442
  g_signal_connect (priv->button_left,
 
443
                    "button-release-event",
 
444
                    G_CALLBACK (eog_thumb_nav_stop_scroll),
 
445
                    nav);
 
446
 
 
447
  priv->button_left = gtk_button_new ();
 
448
  gtk_button_set_relief (GTK_BUTTON (priv->button_left), GTK_RELIEF_NONE);
 
449
 
 
450
  arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_ETCHED_IN);
 
451
  gtk_container_add (GTK_CONTAINER (priv->button_left), arrow);
 
452
 
 
453
  gtk_widget_set_size_request (GTK_WIDGET (priv->button_left), 25, 0);
 
454
 
 
455
  g_signal_connect (priv->button_left,
 
456
                    "clicked",
 
457
                    G_CALLBACK (eog_thumb_nav_button_clicked),
 
458
                    nav);
 
459
 
 
460
  g_signal_connect (priv->button_left,
 
461
                    "button-press-event",
 
462
                    G_CALLBACK (eog_thumb_nav_start_scroll),
 
463
                    nav);
 
464
 
 
465
  g_signal_connect (priv->button_left,
 
466
                    "button-release-event",
 
467
                    G_CALLBACK (eog_thumb_nav_stop_scroll),
 
468
                    nav);
 
469
 
 
470
  priv->vbox = gtk_vbox_new (FALSE, 0);
 
471
 
 
472
  priv->sw = gtk_scrolled_window_new (NULL, NULL);
 
473
 
 
474
  gtk_widget_set_name (gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (priv->sw)),
 
475
                       "hscrollbar");
 
476
  gtk_widget_set_name (gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (priv->sw)),
 
477
                       "vscrollbar");
 
478
 
 
479
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->sw),
 
480
                                       GTK_SHADOW_IN);
 
481
 
 
482
 
 
483
 
 
484
  g_signal_connect (priv->sw,
 
485
                    "scroll-event",
 
486
                    G_CALLBACK (eog_thumb_nav_scroll_event),
 
487
                    nav);
 
488
 
 
489
  priv->hadj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (priv->sw));
 
490
 
 
491
  g_signal_connect (priv->hadj,
 
492
                    "changed",
 
493
                    G_CALLBACK (eog_thumb_nav_hadj_changed),
 
494
                    nav);
 
495
 
 
496
  g_signal_connect (priv->hadj,
 
497
                    "value-changed",
 
498
                    G_CALLBACK (eog_thumb_nav_hadj_value_changed),
 
499
                    nav);
 
500
 
 
501
  priv->vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->sw));
 
502
 
 
503
  g_signal_connect (priv->vadj,
 
504
                    "changed",
 
505
                    G_CALLBACK (eog_thumb_nav_vadj_changed),
 
506
                    nav);
 
507
 
 
508
  g_signal_connect (priv->vadj,
 
509
                    "value-changed",
 
510
                    G_CALLBACK (eog_thumb_nav_vadj_value_changed),
 
511
                    nav);
 
512
 
 
513
  priv->button_right = gtk_button_new ();
 
514
  gtk_button_set_relief (GTK_BUTTON (priv->button_right), GTK_RELIEF_NONE);
 
515
 
 
516
  arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
 
517
  gtk_container_add (GTK_CONTAINER (priv->button_right), arrow);
 
518
 
 
519
  gtk_widget_set_size_request (GTK_WIDGET (priv->button_right), 25, 0);
 
520
 
 
521
  g_signal_connect (priv->button_right,
 
522
                    "clicked",
 
523
                    G_CALLBACK (eog_thumb_nav_button_clicked),
 
524
                    nav);
 
525
 
 
526
  g_signal_connect (priv->button_right,
 
527
                    "button-press-event",
 
528
                    G_CALLBACK (eog_thumb_nav_start_scroll),
 
529
                    nav);
 
530
 
 
531
  g_signal_connect (priv->button_right,
 
532
                    "button-release-event",
 
533
                    G_CALLBACK (eog_thumb_nav_stop_scroll),
 
534
                    nav);
 
535
 
 
536
  priv->button_down = gtk_button_new ();
 
537
  gtk_button_set_relief (GTK_BUTTON (priv->button_down), GTK_RELIEF_NONE);
 
538
 
 
539
  arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
 
540
  gtk_container_add (GTK_CONTAINER (priv->button_down), arrow);
 
541
 
 
542
  gtk_widget_set_size_request (GTK_WIDGET (priv->button_down), 0, 25);
 
543
 
 
544
  g_signal_connect (priv->button_down,
 
545
                    "clicked",
 
546
                    G_CALLBACK (eog_thumb_nav_button_clicked),
 
547
                    nav);
 
548
 
 
549
  g_signal_connect (priv->button_down,
 
550
                    "button-press-event",
 
551
                    G_CALLBACK (eog_thumb_nav_start_scroll),
 
552
                    nav);
 
553
 
 
554
  g_signal_connect (priv->button_down,
 
555
                    "button-release-event",
 
556
                    G_CALLBACK (eog_thumb_nav_stop_scroll),
 
557
                    nav);
 
558
 
 
559
  priv->button_up = gtk_button_new ();
 
560
  gtk_button_set_relief (GTK_BUTTON (priv->button_up), GTK_RELIEF_NONE);
 
561
 
 
562
  arrow = gtk_arrow_new (GTK_ARROW_UP, GTK_SHADOW_NONE);
 
563
  gtk_container_add (GTK_CONTAINER (priv->button_up), arrow);
 
564
 
 
565
  gtk_widget_set_size_request (GTK_WIDGET (priv->button_up), 0, 25);
 
566
 
 
567
  g_signal_connect (priv->button_up,
 
568
                    "clicked",
 
569
                    G_CALLBACK (eog_thumb_nav_button_clicked),
 
570
                    nav);
 
571
 
 
572
  g_signal_connect (priv->button_up,
 
573
                    "button-press-event",
 
574
                    G_CALLBACK (eog_thumb_nav_start_scroll),
 
575
                    nav);
 
576
 
 
577
  g_signal_connect (priv->button_up,
 
578
                    "button-release-event",
 
579
                    G_CALLBACK (eog_thumb_nav_stop_scroll),
 
580
                    nav);
 
581
 
 
582
 
 
583
  g_object_ref (priv->button_up);
 
584
  g_object_ref (priv->button_down);
 
585
  gtk_box_pack_start (GTK_BOX (nav), priv->button_left, FALSE, FALSE, 0);
 
586
  gtk_box_pack_start (GTK_BOX (nav), priv->vbox, TRUE, TRUE, 0);
 
587
  gtk_box_pack_start (GTK_BOX (nav), priv->button_right, FALSE, FALSE, 0);
 
588
  gtk_box_pack_start (GTK_BOX (priv->vbox), priv->sw, TRUE, TRUE, 0);
 
589
 
 
590
  gtk_adjustment_value_changed (priv->hadj);
 
591
}
 
592
 
 
593
/**
 
594
 * eog_thumb_nav_new:
 
595
 * @thumbview: a #CheeseThumbView to embed in the navigation widget.
 
596
 * @mode: The navigation mode.
 
597
 * @show_buttons: Whether to show the navigation buttons.
 
598
 *
 
599
 * Creates a new thumbnail navigation widget.
 
600
 *
 
601
 * Returns: a new #EogThumbNav object.
 
602
 **/
 
603
GtkWidget *
 
604
eog_thumb_nav_new (GtkWidget *thumbview,
 
605
                   gboolean   show_buttons)
 
606
{
 
607
  EogThumbNav        *nav;
 
608
  EogThumbNavPrivate *priv;
 
609
 
 
610
  nav = g_object_new (EOG_TYPE_THUMB_NAV,
 
611
                      "show-buttons", show_buttons,
 
612
                      "thumbview", thumbview,
 
613
                      "homogeneous", FALSE,
 
614
                      "spacing", 0,
 
615
                      NULL);
 
616
 
 
617
  priv = nav->priv;
 
618
 
 
619
  return GTK_WIDGET (nav);
 
620
}
 
621
 
 
622
/**
 
623
 * eog_thumb_nav_get_show_buttons:
 
624
 * @nav: an #EogThumbNav.
 
625
 *
 
626
 * Gets whether the navigation buttons are visible.
 
627
 *
 
628
 * Returns: %TRUE if the navigation buttons are visible,
 
629
 * %FALSE otherwise.
 
630
 **/
 
631
gboolean
 
632
eog_thumb_nav_get_show_buttons (EogThumbNav *nav)
 
633
{
 
634
  g_return_val_if_fail (EOG_IS_THUMB_NAV (nav), FALSE);
 
635
 
 
636
  return nav->priv->show_buttons;
 
637
}
 
638
 
 
639
/**
 
640
 * eog_thumb_nav_set_show_buttons:
 
641
 * @nav: an #EogThumbNav.
 
642
 * @show_buttons: %TRUE to show the buttons, %FALSE to hide them.
 
643
 *
 
644
 * Sets whether the navigation buttons to the left and right of the
 
645
 * widget should be visible.
 
646
 **/
 
647
void
 
648
eog_thumb_nav_set_show_buttons (EogThumbNav *nav, gboolean show_buttons)
 
649
{
 
650
  g_return_if_fail (EOG_IS_THUMB_NAV (nav));
 
651
  g_return_if_fail (nav->priv->button_left != NULL);
 
652
  g_return_if_fail (nav->priv->button_right != NULL);
 
653
 
 
654
  nav->priv->show_buttons = show_buttons;
 
655
 
 
656
  if (show_buttons)
 
657
  {
 
658
    gtk_widget_show_all (nav->priv->button_left);
 
659
    gtk_widget_show_all (nav->priv->button_right);
 
660
  }
 
661
  else
 
662
  {
 
663
    gtk_widget_hide (nav->priv->button_left);
 
664
    gtk_widget_hide (nav->priv->button_right);
 
665
  }
 
666
}
 
667
 
 
668
void
 
669
eog_thumb_nav_set_policy (EogThumbNav  *nav,
 
670
                          GtkPolicyType hscrollbar_policy,
 
671
                          GtkPolicyType vscrollbar_policy)
 
672
{
 
673
  EogThumbNavPrivate *priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
674
 
 
675
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->sw),
 
676
                                  hscrollbar_policy,
 
677
                                  vscrollbar_policy);
 
678
}
 
679
 
 
680
gboolean
 
681
eog_thumb_nav_is_vertical (EogThumbNav *nav)
 
682
{
 
683
  EogThumbNavPrivate *priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
684
 
 
685
  return priv->vertical;
 
686
}
 
687
 
 
688
void
 
689
eog_thumb_nav_set_vertical (EogThumbNav *nav, gboolean vertical)
 
690
{
 
691
  EogThumbNavPrivate *priv = EOG_THUMB_NAV_GET_PRIVATE (nav);
 
692
 
 
693
  g_return_if_fail (EOG_IS_THUMB_NAV (nav));
 
694
  g_return_if_fail (priv->button_left != NULL);
 
695
  g_return_if_fail (priv->button_right != NULL);
 
696
  g_return_if_fail (priv->vbox != NULL);
 
697
  g_return_if_fail (priv->sw != NULL);
 
698
 
 
699
  if (vertical == priv->vertical) return;
 
700
 
 
701
  /* show/hide doesn't work because of a mandatory show_all in cheese-window */
 
702
 
 
703
  if (vertical)
 
704
  {
 
705
    g_return_if_fail (!gtk_widget_get_parent (priv->button_up));
 
706
    g_return_if_fail (!gtk_widget_get_parent (priv->button_down));
 
707
    g_return_if_fail (gtk_widget_get_parent (priv->button_left));
 
708
    g_return_if_fail (gtk_widget_get_parent (priv->button_right));
 
709
 
 
710
    gtk_box_pack_start (GTK_BOX (priv->vbox), priv->button_up, FALSE, FALSE, 0);
 
711
    gtk_box_reorder_child (GTK_BOX (priv->vbox), priv->button_up, 0);
 
712
    gtk_box_pack_start (GTK_BOX (priv->vbox), priv->button_down, FALSE, FALSE, 0);
 
713
    g_object_unref (priv->button_up);
 
714
    g_object_unref (priv->button_down);
 
715
 
 
716
    g_object_ref (priv->button_left);
 
717
    gtk_container_remove (GTK_CONTAINER (nav), priv->button_left);
 
718
    g_object_ref (priv->button_right);
 
719
    gtk_container_remove (GTK_CONTAINER (nav), priv->button_right);
 
720
    gtk_adjustment_value_changed (priv->vadj);
 
721
 
 
722
    eog_thumb_nav_set_policy (nav,
 
723
                              GTK_POLICY_NEVER,
 
724
                              GTK_POLICY_AUTOMATIC);
 
725
    priv->vertical = TRUE;
 
726
  }
 
727
  else
 
728
  {
 
729
    g_return_if_fail (!gtk_widget_get_parent (priv->button_left));
 
730
    g_return_if_fail (!gtk_widget_get_parent (priv->button_right));
 
731
    g_return_if_fail (gtk_widget_get_parent (priv->button_up));
 
732
    g_return_if_fail (gtk_widget_get_parent (priv->button_down));
 
733
 
 
734
    gtk_box_pack_start (GTK_BOX (nav), priv->button_left, FALSE, FALSE, 0);
 
735
    gtk_box_reorder_child (GTK_BOX (nav), priv->button_left, 0);
 
736
    gtk_box_pack_start (GTK_BOX (nav), priv->button_right, FALSE, FALSE, 0);
 
737
    g_object_unref (priv->button_left);
 
738
    g_object_unref (priv->button_right);
 
739
 
 
740
    g_object_ref (priv->button_up);
 
741
    gtk_container_remove (GTK_CONTAINER (priv->vbox), priv->button_up);
 
742
    g_object_ref (priv->button_down);
 
743
    gtk_container_remove (GTK_CONTAINER (priv->vbox), priv->button_down);
 
744
    gtk_adjustment_value_changed (priv->hadj);
 
745
 
 
746
    eog_thumb_nav_set_policy (nav,
 
747
                              GTK_POLICY_AUTOMATIC,
 
748
                              GTK_POLICY_NEVER);
 
749
    priv->vertical = FALSE;
 
750
  }
 
751
  gtk_widget_show_all (GTK_WIDGET (nav));
 
752
}