← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Andrea Veri, Andrea Veri, Loïc Minier
  • Date: 2009-09-23 20:25:41 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20090923202541-q9lr8b7ykic314xy
Tags: 2.28.0.1-1
[ Andrea Veri ]
* New upstream release.
* debian/control:
  - Bumped Standards-version to 3.8.3. No changes needed.
  - libgtk2.0-dev bumped to >= 2.17.4 as per configure.ac
    requirements.
  - libgnome-desktop-dev bumped to >= 2.26.0 as per configure.ac
    requirements.
  - added a B-D on x11proto-core-dev needed from multimedia keys
    to work properly.
* debian/copyright:
  - added missing copyright holders.
* debian/patches:
  - removed as long as it has no patches in it.
* debian/rules:
  - simple-patchsys include removed, there are no patches to be
    applied.

[ Loïc Minier ]
* Bdep on rarian-compat instead of scrollkeeper.

Show diffs side-by-side

added added

removed removed

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