← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/widgets/gimpcontainergridview.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/widgets/gimpcontainergridview.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * gimpcontainergridview.c
51
51
};
52
52
 
53
53
 
54
 
static void     gimp_container_grid_view_class_init   (GimpContainerGridViewClass *klass);
55
 
static void     gimp_container_grid_view_init         (GimpContainerGridView      *view);
56
 
 
57
 
static void     gimp_container_grid_view_view_iface_init (GimpContainerViewInterface *view_iface);
 
54
static void  gimp_container_grid_view_view_iface_init (GimpContainerViewInterface *iface);
58
55
 
59
56
static gboolean gimp_container_grid_view_move_cursor  (GimpContainerGridView  *view,
60
57
                                                       GtkMovementStep         step,
63
60
                                                       GtkDirectionType        direction);
64
61
static gboolean  gimp_container_grid_view_popup_menu  (GtkWidget              *widget);
65
62
 
 
63
static void     gimp_container_grid_view_set_context  (GimpContainerView      *view,
 
64
                                                       GimpContext            *context);
66
65
static gpointer gimp_container_grid_view_insert_item  (GimpContainerView      *view,
67
66
                                                       GimpViewable           *viewable,
68
67
                                                       gint                    index);
80
79
                                                       GimpViewable           *viewable,
81
80
                                                       gpointer                insert_data);
82
81
static void     gimp_container_grid_view_clear_items  (GimpContainerView      *view);
83
 
static void gimp_container_grid_view_set_preview_size (GimpContainerView      *view);
 
82
static void    gimp_container_grid_view_set_view_size (GimpContainerView      *view);
 
83
 
84
84
static gboolean gimp_container_grid_view_item_selected(GtkWidget              *widget,
85
85
                                                       GdkEventButton         *bevent,
86
86
                                                       gpointer                data);
95
95
static void gimp_container_grid_view_viewport_resized (GtkWidget              *widget,
96
96
                                                       GtkAllocation          *allocation,
97
97
                                                       GimpContainerGridView  *view);
98
 
 
99
 
 
100
 
static GimpContainerBoxClass      *parent_class      = NULL;
 
98
static gboolean gimp_container_grid_view_button_press (GtkWidget              *widget,
 
99
                                                       GdkEventButton         *bevent,
 
100
                                                       GimpContainerGridView  *view);
 
101
 
 
102
 
 
103
G_DEFINE_TYPE_WITH_CODE (GimpContainerGridView, gimp_container_grid_view,
 
104
                         GIMP_TYPE_CONTAINER_BOX,
 
105
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
 
106
                                                gimp_container_grid_view_view_iface_init))
 
107
 
 
108
#define parent_class gimp_container_grid_view_parent_class
 
109
 
101
110
static GimpContainerViewInterface *parent_view_iface = NULL;
102
111
 
103
112
static guint grid_view_signals[LAST_SIGNAL] = { 0 };
106
115
static GimpRGB  black_color;
107
116
 
108
117
 
109
 
GType
110
 
gimp_container_grid_view_get_type (void)
111
 
{
112
 
  static GType view_type = 0;
113
 
 
114
 
  if (! view_type)
115
 
    {
116
 
      static const GTypeInfo view_info =
117
 
      {
118
 
        sizeof (GimpContainerGridViewClass),
119
 
        NULL,           /* base_init */
120
 
        NULL,           /* base_finalize */
121
 
        (GClassInitFunc) gimp_container_grid_view_class_init,
122
 
        NULL,           /* class_finalize */
123
 
        NULL,           /* class_data */
124
 
        sizeof (GimpContainerGridView),
125
 
        0,              /* n_preallocs */
126
 
        (GInstanceInitFunc) gimp_container_grid_view_init,
127
 
      };
128
 
 
129
 
      static const GInterfaceInfo view_iface_info =
130
 
      {
131
 
        (GInterfaceInitFunc) gimp_container_grid_view_view_iface_init,
132
 
        NULL,           /* iface_finalize */
133
 
        NULL            /* iface_data     */
134
 
      };
135
 
 
136
 
      view_type = g_type_register_static (GIMP_TYPE_CONTAINER_BOX,
137
 
                                          "GimpContainerGridView",
138
 
                                          &view_info, 0);
139
 
 
140
 
      g_type_add_interface_static (view_type, GIMP_TYPE_CONTAINER_VIEW,
141
 
                                   &view_iface_info);
142
 
    }
143
 
 
144
 
  return view_type;
145
 
}
146
 
 
147
118
static void
148
119
gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass)
149
120
{
150
121
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
151
122
  GtkBindingSet  *binding_set;
152
123
 
153
 
  parent_class = g_type_class_peek_parent (klass);
154
124
  binding_set  = gtk_binding_set_by_class (klass);
155
125
 
156
126
  widget_class->focus      = gimp_container_grid_view_focus;
159
129
  klass->move_cursor       = gimp_container_grid_view_move_cursor;
160
130
 
161
131
  grid_view_signals[MOVE_CURSOR] =
162
 
    g_signal_new ("move_cursor",
 
132
    g_signal_new ("move-cursor",
163
133
                  G_TYPE_FROM_CLASS (klass),
164
134
                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
165
135
                  G_STRUCT_OFFSET (GimpContainerGridViewClass, move_cursor),
170
140
                  G_TYPE_INT);
171
141
 
172
142
  gtk_binding_entry_add_signal (binding_set, GDK_Home, 0,
173
 
                                "move_cursor", 2,
 
143
                                "move-cursor", 2,
174
144
                                G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
175
145
                                G_TYPE_INT, -1);
176
146
  gtk_binding_entry_add_signal (binding_set, GDK_End, 0,
177
 
                                "move_cursor", 2,
 
147
                                "move-cursor", 2,
178
148
                                G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
179
149
                                G_TYPE_INT, 1);
180
150
  gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
181
 
                                "move_cursor", 2,
 
151
                                "move-cursor", 2,
182
152
                                G_TYPE_ENUM, GTK_MOVEMENT_PAGES,
183
153
                                G_TYPE_INT, -1);
184
154
  gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
185
 
                                "move_cursor", 2,
 
155
                                "move-cursor", 2,
186
156
                                G_TYPE_ENUM, GTK_MOVEMENT_PAGES,
187
157
                                G_TYPE_INT, 1);
188
158
 
191
161
}
192
162
 
193
163
static void
 
164
gimp_container_grid_view_view_iface_init (GimpContainerViewInterface *iface)
 
165
{
 
166
  parent_view_iface = g_type_interface_peek_parent (iface);
 
167
 
 
168
  iface->set_context   = gimp_container_grid_view_set_context;
 
169
  iface->insert_item   = gimp_container_grid_view_insert_item;
 
170
  iface->remove_item   = gimp_container_grid_view_remove_item;
 
171
  iface->reorder_item  = gimp_container_grid_view_reorder_item;
 
172
  iface->rename_item   = gimp_container_grid_view_rename_item;
 
173
  iface->select_item   = gimp_container_grid_view_select_item;
 
174
  iface->clear_items   = gimp_container_grid_view_clear_items;
 
175
  iface->set_view_size = gimp_container_grid_view_set_view_size;
 
176
}
 
177
 
 
178
static void
194
179
gimp_container_grid_view_init (GimpContainerGridView *grid_view)
195
180
{
196
181
  GimpContainerBox *box = GIMP_CONTAINER_BOX (grid_view);
200
185
  grid_view->visible_rows  = 0;
201
186
  grid_view->selected_item = NULL;
202
187
 
 
188
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (box->scrolled_win),
 
189
                                       GTK_SHADOW_IN);
203
190
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (box->scrolled_win),
204
191
                                  GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
205
192
 
206
 
  grid_view->name_label = gtk_label_new (_("(None)"));
207
 
  gtk_misc_set_alignment (GTK_MISC (grid_view->name_label), 0.0, 0.5);
208
 
  gimp_label_set_attributes (GTK_LABEL (grid_view->name_label),
209
 
                             PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
210
 
                             -1);
211
 
  gtk_box_pack_start (GTK_BOX (grid_view), grid_view->name_label,
212
 
                      FALSE, FALSE, 0);
213
 
  gtk_box_reorder_child (GTK_BOX (grid_view), grid_view->name_label, 0);
214
 
  gtk_widget_show (grid_view->name_label);
 
193
  gimp_editor_set_show_name (GIMP_EDITOR (grid_view), TRUE);
215
194
 
216
195
  grid_view->wrap_box = gtk_hwrap_box_new (FALSE);
217
196
  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (box->scrolled_win),
218
197
                                         grid_view->wrap_box);
 
198
  gtk_viewport_set_shadow_type (GTK_VIEWPORT (grid_view->wrap_box->parent),
 
199
                                GTK_SHADOW_NONE);
219
200
  gtk_widget_show (grid_view->wrap_box);
220
201
 
221
 
  g_signal_connect (grid_view->wrap_box->parent, "size_allocate",
 
202
  g_signal_connect (grid_view->wrap_box->parent, "size-allocate",
222
203
                    G_CALLBACK (gimp_container_grid_view_viewport_resized),
223
204
                    grid_view);
 
205
  g_signal_connect (grid_view->wrap_box->parent, "button-press-event",
 
206
                    G_CALLBACK (gimp_container_grid_view_button_press),
 
207
                    grid_view);
224
208
 
225
209
  GTK_WIDGET_SET_FLAGS (grid_view, GTK_CAN_FOCUS);
226
210
}
227
211
 
228
 
static void
229
 
gimp_container_grid_view_view_iface_init (GimpContainerViewInterface *view_iface)
230
 
{
231
 
  parent_view_iface = g_type_interface_peek_parent (view_iface);
232
 
 
233
 
  view_iface->insert_item      = gimp_container_grid_view_insert_item;
234
 
  view_iface->remove_item      = gimp_container_grid_view_remove_item;
235
 
  view_iface->reorder_item     = gimp_container_grid_view_reorder_item;
236
 
  view_iface->rename_item      = gimp_container_grid_view_rename_item;
237
 
  view_iface->select_item      = gimp_container_grid_view_select_item;
238
 
  view_iface->clear_items      = gimp_container_grid_view_clear_items;
239
 
  view_iface->set_preview_size = gimp_container_grid_view_set_preview_size;
240
 
}
241
 
 
242
212
GtkWidget *
243
213
gimp_container_grid_view_new (GimpContainer *container,
244
214
                              GimpContext   *context,
261
231
 
262
232
  view = GIMP_CONTAINER_VIEW (grid_view);
263
233
 
264
 
  gimp_container_view_set_preview_size (view, view_size,
265
 
                                        view_border_width);
 
234
  gimp_container_view_set_view_size (view, view_size, view_border_width);
266
235
 
267
236
  if (container)
268
237
    gimp_container_view_set_container (view, container);
382
351
                                        gint     *y,
383
352
                                        gpointer  data)
384
353
{
385
 
  GtkWidget *widget = GTK_WIDGET (data);
 
354
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (data);
 
355
  GtkWidget             *widget;
 
356
 
 
357
  if (grid_view->selected_item)
 
358
    widget = GTK_WIDGET (grid_view->selected_item);
 
359
  else
 
360
    widget = GTK_WIDGET (grid_view->wrap_box);
386
361
 
387
362
  gdk_window_get_origin (widget->window, x, y);
388
363
 
392
367
      *y += widget->allocation.y;
393
368
    }
394
369
 
395
 
  *x += widget->allocation.width  / 2;
396
 
  *y += widget->allocation.height / 2;
 
370
  if (grid_view->selected_item)
 
371
    {
 
372
      *x += widget->allocation.width  / 2;
 
373
      *y += widget->allocation.height / 2;
 
374
    }
 
375
  else
 
376
    {
 
377
      *x += widget->style->xthickness;
 
378
      *y += widget->style->ythickness;
 
379
    }
397
380
 
398
381
  gimp_menu_position (menu, x, y);
399
382
}
403
386
{
404
387
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (widget);
405
388
 
406
 
  if (grid_view->selected_item)
 
389
  return gimp_editor_popup_menu (GIMP_EDITOR (widget),
 
390
                                 gimp_container_grid_view_menu_position,
 
391
                                 grid_view);
 
392
}
 
393
 
 
394
static void
 
395
gimp_container_grid_view_set_context (GimpContainerView *view,
 
396
                                      GimpContext       *context)
 
397
{
 
398
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
 
399
  GtkWrapBoxChild       *child;
 
400
 
 
401
  parent_view_iface->set_context (view, context);
 
402
 
 
403
  for (child = GTK_WRAP_BOX (grid_view->wrap_box)->children;
 
404
       child;
 
405
       child = child->next)
407
406
    {
408
 
      return gimp_editor_popup_menu (GIMP_EDITOR (grid_view),
409
 
                                     gimp_container_grid_view_menu_position,
410
 
                                     grid_view->selected_item);
 
407
      GimpView *view = GIMP_VIEW (child->widget);
 
408
 
 
409
      gimp_view_renderer_set_context (view->renderer, context);
411
410
    }
412
 
 
413
 
  return FALSE;
414
411
}
415
412
 
416
413
static gpointer
417
 
gimp_container_grid_view_insert_item (GimpContainerView *view,
 
414
gimp_container_grid_view_insert_item (GimpContainerView *container_view,
418
415
                                      GimpViewable      *viewable,
419
416
                                      gint               index)
420
417
{
421
 
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
422
 
  GtkWidget             *preview;
423
 
  gint                   preview_size;
424
 
 
425
 
  preview_size = gimp_container_view_get_preview_size (view, NULL);
426
 
 
427
 
  preview = gimp_view_new_full (viewable,
428
 
                                preview_size,
429
 
                                preview_size,
430
 
                                1,
431
 
                                FALSE, TRUE, TRUE);
432
 
  gimp_view_renderer_set_border_type (GIMP_VIEW (preview)->renderer,
 
418
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (container_view);
 
419
  GtkWidget             *view;
 
420
  gint                   view_size;
 
421
 
 
422
  view_size = gimp_container_view_get_view_size (container_view, NULL);
 
423
 
 
424
  view = gimp_view_new_full (gimp_container_view_get_context (container_view),
 
425
                             viewable,
 
426
                             view_size, view_size, 1,
 
427
                             FALSE, TRUE, TRUE);
 
428
  gimp_view_renderer_set_border_type (GIMP_VIEW (view)->renderer,
433
429
                                      GIMP_VIEW_BORDER_WHITE);
434
 
  gimp_view_renderer_remove_idle (GIMP_VIEW (preview)->renderer);
 
430
  gimp_view_renderer_remove_idle (GIMP_VIEW (view)->renderer);
435
431
 
436
 
  gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), preview,
 
432
  gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), view,
437
433
                     FALSE, FALSE, FALSE, FALSE);
438
434
 
439
435
  if (index != -1)
440
436
    gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
441
 
                                preview, index);
442
 
 
443
 
  gtk_widget_show (preview);
444
 
 
445
 
  g_signal_connect (preview, "button_press_event",
 
437
                                view, index);
 
438
 
 
439
  gtk_widget_show (view);
 
440
 
 
441
  g_signal_connect (view, "button-press-event",
446
442
                    G_CALLBACK (gimp_container_grid_view_item_selected),
447
 
                    view);
448
 
  g_signal_connect (preview, "double_clicked",
 
443
                    container_view);
 
444
  g_signal_connect (view, "double-clicked",
449
445
                    G_CALLBACK (gimp_container_grid_view_item_activated),
450
 
                    view);
451
 
  g_signal_connect (preview, "context",
 
446
                    container_view);
 
447
  g_signal_connect (view, "context",
452
448
                    G_CALLBACK (gimp_container_grid_view_item_context),
453
 
                    view);
 
449
                    container_view);
454
450
 
455
 
  return (gpointer) preview;
 
451
  return (gpointer) view;
456
452
}
457
453
 
458
454
static void
459
 
gimp_container_grid_view_remove_item (GimpContainerView *view,
 
455
gimp_container_grid_view_remove_item (GimpContainerView *container_view,
460
456
                                      GimpViewable      *viewable,
461
457
                                      gpointer           insert_data)
462
458
{
463
 
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
464
 
  GtkWidget             *preview   = GTK_WIDGET (insert_data);
 
459
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (container_view);
 
460
  GtkWidget             *view      = GTK_WIDGET (insert_data);
465
461
 
466
 
  if (preview == (GtkWidget *) grid_view->selected_item)
 
462
  if (view == (GtkWidget *) grid_view->selected_item)
467
463
    grid_view->selected_item = NULL;
468
464
 
469
 
  gtk_container_remove (GTK_CONTAINER (grid_view->wrap_box), preview);
 
465
  gtk_container_remove (GTK_CONTAINER (grid_view->wrap_box), view);
470
466
}
471
467
 
472
468
static void
473
 
gimp_container_grid_view_reorder_item (GimpContainerView *view,
 
469
gimp_container_grid_view_reorder_item (GimpContainerView *container_view,
474
470
                                       GimpViewable      *viewable,
475
471
                                       gint               new_index,
476
472
                                       gpointer           insert_data)
477
473
{
478
 
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
479
 
  GtkWidget             *preview   = GTK_WIDGET (insert_data);
 
474
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (container_view);
 
475
  GtkWidget             *view      = GTK_WIDGET (insert_data);
480
476
 
481
477
  gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
482
 
                              preview, new_index);
 
478
                              view, new_index);
483
479
}
484
480
 
485
481
static void
486
 
gimp_container_grid_view_rename_item (GimpContainerView *view,
 
482
gimp_container_grid_view_rename_item (GimpContainerView *container_view,
487
483
                                      GimpViewable      *viewable,
488
484
                                      gpointer           insert_data)
489
485
{
490
 
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
491
 
  GtkWidget             *preview   = GTK_WIDGET (insert_data);
 
486
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (container_view);
 
487
  GtkWidget             *view      = GTK_WIDGET (insert_data);
492
488
 
493
 
  if (preview == (GtkWidget *) grid_view->selected_item)
 
489
  if (view == (GtkWidget *) grid_view->selected_item)
494
490
    {
495
491
      gchar *name = gimp_viewable_get_description (viewable, NULL);
496
492
 
497
 
      gtk_label_set_text (GTK_LABEL (grid_view->name_label), name);
498
 
 
 
493
      gimp_editor_set_name (GIMP_EDITOR (container_view), name);
499
494
      g_free (name);
500
495
    }
501
496
}
525
520
}
526
521
 
527
522
static void
528
 
gimp_container_grid_view_set_preview_size (GimpContainerView *view)
 
523
gimp_container_grid_view_set_view_size (GimpContainerView *view)
529
524
{
530
525
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
531
526
  GtkWrapBoxChild       *child;
532
 
  gint                   preview_size;
 
527
  gint                   view_size;
533
528
 
534
 
  preview_size = gimp_container_view_get_preview_size (view, NULL);
 
529
  view_size = gimp_container_view_get_view_size (view, NULL);
535
530
 
536
531
  for (child = GTK_WRAP_BOX (grid_view->wrap_box)->children;
537
532
       child;
540
535
      GimpView *view = GIMP_VIEW (child->widget);
541
536
 
542
537
      gimp_view_renderer_set_size (view->renderer,
543
 
                                   preview_size,
 
538
                                   view_size,
544
539
                                   view->renderer->border_width);
545
540
    }
546
541
 
592
587
}
593
588
 
594
589
static void
595
 
gimp_container_grid_view_highlight_item (GimpContainerView *view,
 
590
gimp_container_grid_view_highlight_item (GimpContainerView *container_view,
596
591
                                         GimpViewable      *viewable,
597
592
                                         gpointer           insert_data)
598
593
{
599
 
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (view);
600
 
  GimpContainerBox      *box       = GIMP_CONTAINER_BOX (view);
 
594
  GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (container_view);
 
595
  GimpContainerBox      *box       = GIMP_CONTAINER_BOX (container_view);
601
596
  GimpContainer         *container;
602
 
  GimpView              *preview   = NULL;
 
597
  GimpView              *view      = NULL;
603
598
 
604
 
  container = gimp_container_view_get_container (view);
 
599
  container = gimp_container_view_get_container (container_view);
605
600
 
606
601
  if (insert_data)
607
 
    preview = GIMP_VIEW (insert_data);
 
602
    view = GIMP_VIEW (insert_data);
608
603
 
609
 
  if (grid_view->selected_item && grid_view->selected_item != preview)
 
604
  if (grid_view->selected_item && grid_view->selected_item != view)
610
605
    {
611
606
      gimp_view_renderer_set_border_type (grid_view->selected_item->renderer,
612
607
                                          GIMP_VIEW_BORDER_WHITE);
613
608
      gimp_view_renderer_update (grid_view->selected_item->renderer);
614
609
    }
615
610
 
616
 
  if (preview)
 
611
  if (view)
617
612
    {
618
 
      GtkRequisition  preview_requisition;
 
613
      GtkRequisition  view_requisition;
619
614
      GtkAdjustment  *adj;
620
615
      gint            item_height;
621
616
      gint            index;
625
620
      adj = gtk_scrolled_window_get_vadjustment
626
621
        (GTK_SCROLLED_WINDOW (box->scrolled_win));
627
622
 
628
 
      gtk_widget_size_request (GTK_WIDGET (preview), &preview_requisition);
 
623
      gtk_widget_size_request (GTK_WIDGET (view), &view_requisition);
629
624
 
630
 
      item_height = preview_requisition.height;
 
625
      item_height = view_requisition.height;
631
626
 
632
627
      index = gimp_container_get_child_index (container,
633
628
                                              GIMP_OBJECT (viewable));
644
639
                                    (row + 1) * item_height - adj->page_size);
645
640
        }
646
641
 
647
 
      gimp_view_renderer_set_border_type (preview->renderer,
 
642
      gimp_view_renderer_set_border_type (view->renderer,
648
643
                                          GIMP_VIEW_BORDER_BLACK);
649
 
      gimp_view_renderer_update (preview->renderer);
 
644
      gimp_view_renderer_update (view->renderer);
650
645
 
651
 
      name = gimp_viewable_get_description (preview->renderer->viewable, NULL);
652
 
      gtk_label_set_text (GTK_LABEL (grid_view->name_label), name);
 
646
      name = gimp_viewable_get_description (view->renderer->viewable, NULL);
 
647
      gimp_editor_set_name (GIMP_EDITOR (grid_view), name);
653
648
      g_free (name);
654
649
    }
655
650
  else
656
651
    {
657
 
      gtk_label_set_text (GTK_LABEL (grid_view->name_label), _("(None)"));
 
652
      gimp_editor_set_name (GIMP_EDITOR (grid_view), NULL);
658
653
    }
659
654
 
660
 
  grid_view->selected_item = preview;
 
655
  grid_view->selected_item = view;
661
656
}
662
657
 
663
658
static void
665
660
                                           GtkAllocation         *allocation,
666
661
                                           GimpContainerGridView *grid_view)
667
662
{
668
 
  GimpContainerView *view = GIMP_CONTAINER_VIEW (grid_view);
 
663
  GimpContainerView *container_view = GIMP_CONTAINER_VIEW (grid_view);
669
664
 
670
 
  if (gimp_container_view_get_container (view))
 
665
  if (gimp_container_view_get_container (container_view))
671
666
    {
672
667
      GList *children;
673
668
      gint   n_children;
677
672
 
678
673
      if (children)
679
674
        {
680
 
          GtkRequisition preview_requisition;
 
675
          GtkRequisition view_requisition;
681
676
          gint           columns;
682
677
          gint           rows;
683
678
 
684
679
          gtk_widget_size_request (GTK_WIDGET (children->data),
685
 
                                   &preview_requisition);
 
680
                                   &view_requisition);
686
681
 
687
682
          g_list_free (children);
688
683
 
689
 
          columns = MAX (1, allocation->width / preview_requisition.width);
 
684
          columns = MAX (1, allocation->width / view_requisition.width);
690
685
 
691
686
          rows = n_children / columns;
692
687
 
699
694
              grid_view->columns = columns;
700
695
 
701
696
              gtk_widget_set_size_request (grid_view->wrap_box,
702
 
                                           columns * preview_requisition.width,
703
 
                                           rows    * preview_requisition.height);
 
697
                                           columns * view_requisition.width,
 
698
                                           rows    * view_requisition.height);
704
699
 
705
700
            }
706
701
 
707
702
          grid_view->visible_rows = (allocation->height /
708
 
                                     preview_requisition.height);
 
703
                                     view_requisition.height);
709
704
        }
710
705
 
711
706
      if (grid_view->selected_item)
712
707
        {
713
 
          GimpView *preview = grid_view->selected_item;
 
708
          GimpView *view = grid_view->selected_item;
714
709
 
715
 
          gimp_container_grid_view_highlight_item (view,
716
 
                                                   preview->viewable,
717
 
                                                   preview);
 
710
          gimp_container_grid_view_highlight_item (container_view,
 
711
                                                   view->viewable,
 
712
                                                   view);
718
713
        }
719
714
    }
720
715
}
 
716
 
 
717
static gboolean
 
718
gimp_container_grid_view_button_press (GtkWidget              *widget,
 
719
                                       GdkEventButton         *bevent,
 
720
                                       GimpContainerGridView  *grid_view)
 
721
{
 
722
  switch (bevent->button)
 
723
    {
 
724
    case 3:
 
725
      gimp_editor_popup_menu (GIMP_EDITOR (grid_view), NULL, NULL);
 
726
      break;
 
727
 
 
728
    default:
 
729
      break;
 
730
    }
 
731
 
 
732
  return TRUE;
 
733
}