← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/widgets/gimpcontainertreeview.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/gimpcontainertreeview.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
 * gimpcontainertreeview.c
29
29
 
30
30
#include "widgets-types.h"
31
31
 
32
 
#include "base/temp-buf.h"
33
 
 
34
32
#include "core/gimpcontainer.h"
35
33
#include "core/gimpcontext.h"
36
34
#include "core/gimpviewable.h"
53
51
};
54
52
 
55
53
 
56
 
static void     gimp_container_tree_view_class_init   (GimpContainerTreeViewClass *klass);
57
 
static void     gimp_container_tree_view_init         (GimpContainerTreeView      *view);
58
 
 
59
 
static void  gimp_container_tree_view_view_iface_init (GimpContainerViewInterface *view_iface);
 
54
static void  gimp_container_tree_view_view_iface_init (GimpContainerViewInterface *iface);
60
55
 
61
56
static GObject *gimp_container_tree_view_constructor  (GType                   type,
62
57
                                                       guint                   n_params,
65
60
static void    gimp_container_tree_view_unrealize     (GtkWidget              *widget);
66
61
static void    gimp_container_tree_view_unmap         (GtkWidget              *widget);
67
62
static gboolean  gimp_container_tree_view_popup_menu  (GtkWidget              *widget);
 
63
 
68
64
static void    gimp_container_tree_view_set_container (GimpContainerView      *view,
69
65
                                                       GimpContainer          *container);
70
 
 
 
66
static void    gimp_container_tree_view_set_context   (GimpContainerView      *view,
 
67
                                                       GimpContext            *context);
71
68
static gpointer gimp_container_tree_view_insert_item  (GimpContainerView      *view,
72
69
                                                       GimpViewable           *viewable,
73
70
                                                       gint                    index);
85
82
                                                       GimpViewable           *viewable,
86
83
                                                       gpointer                insert_data);
87
84
static void     gimp_container_tree_view_clear_items  (GimpContainerView      *view);
88
 
static void gimp_container_tree_view_set_preview_size (GimpContainerView      *view);
 
85
static void    gimp_container_tree_view_set_view_size (GimpContainerView      *view);
89
86
 
90
87
static void gimp_container_tree_view_name_canceled    (GtkCellRendererText    *cell,
91
88
                                                       GimpContainerTreeView  *tree_view);
99
96
                                                       GimpContainerTreeView  *tree_view);
100
97
 
101
98
static GimpViewable * gimp_container_tree_view_drag_viewable (GtkWidget       *widget,
102
 
                                                              gpointer         data);
103
 
 
104
 
 
105
 
static GimpContainerBoxClass      *parent_class      = NULL;
 
99
                                                              GimpContext    **context,
 
100
                                                              gpointer         data);
 
101
static GdkPixbuf    * gimp_container_tree_view_drag_pixbuf   (GtkWidget       *widget,
 
102
                                                              gpointer         data);
 
103
 
 
104
 
 
105
G_DEFINE_TYPE_WITH_CODE (GimpContainerTreeView, gimp_container_tree_view,
 
106
                         GIMP_TYPE_CONTAINER_BOX,
 
107
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
 
108
                                                gimp_container_tree_view_view_iface_init))
 
109
 
 
110
#define parent_class gimp_container_tree_view_parent_class
 
111
 
106
112
static GimpContainerViewInterface *parent_view_iface = NULL;
107
113
 
108
114
 
109
 
GType
110
 
gimp_container_tree_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 (GimpContainerTreeViewClass),
119
 
        NULL,           /* base_init */
120
 
        NULL,           /* base_finalize */
121
 
        (GClassInitFunc) gimp_container_tree_view_class_init,
122
 
        NULL,           /* class_finalize */
123
 
        NULL,           /* class_data */
124
 
        sizeof (GimpContainerTreeView),
125
 
        0,              /* n_preallocs */
126
 
        (GInstanceInitFunc) gimp_container_tree_view_init,
127
 
      };
128
 
 
129
 
      static const GInterfaceInfo view_iface_info =
130
 
      {
131
 
        (GInterfaceInitFunc) gimp_container_tree_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
 
                                          "GimpContainerTreeView",
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
115
static void
148
116
gimp_container_tree_view_class_init (GimpContainerTreeViewClass *klass)
149
117
{
150
118
  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
151
119
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
152
120
 
153
 
  parent_class = g_type_class_peek_parent (klass);
154
 
 
155
121
  object_class->constructor = gimp_container_tree_view_constructor;
156
122
 
157
123
  widget_class->unrealize   = gimp_container_tree_view_unrealize;
163
129
  klass->drop_color         = NULL;
164
130
  klass->drop_uri_list      = NULL;
165
131
  klass->drop_svg           = NULL;
 
132
  klass->drop_component     = NULL;
 
133
  klass->drop_pixbuf        = NULL;
 
134
}
 
135
 
 
136
static void
 
137
gimp_container_tree_view_view_iface_init (GimpContainerViewInterface *iface)
 
138
{
 
139
  parent_view_iface = g_type_interface_peek_parent (iface);
 
140
 
 
141
  iface->set_container = gimp_container_tree_view_set_container;
 
142
  iface->set_context   = gimp_container_tree_view_set_context;
 
143
  iface->insert_item   = gimp_container_tree_view_insert_item;
 
144
  iface->remove_item   = gimp_container_tree_view_remove_item;
 
145
  iface->reorder_item  = gimp_container_tree_view_reorder_item;
 
146
  iface->rename_item   = gimp_container_tree_view_rename_item;
 
147
  iface->select_item   = gimp_container_tree_view_select_item;
 
148
  iface->clear_items   = gimp_container_tree_view_clear_items;
 
149
  iface->set_view_size = gimp_container_tree_view_set_view_size;
 
150
 
 
151
  iface->insert_data_free = (GDestroyNotify) g_free;
166
152
}
167
153
 
168
154
static void
186
172
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
187
173
}
188
174
 
189
 
static void
190
 
gimp_container_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
191
 
{
192
 
  parent_view_iface = g_type_interface_peek_parent (view_iface);
193
 
 
194
 
  view_iface->set_container    = gimp_container_tree_view_set_container;
195
 
  view_iface->insert_item      = gimp_container_tree_view_insert_item;
196
 
  view_iface->remove_item      = gimp_container_tree_view_remove_item;
197
 
  view_iface->reorder_item     = gimp_container_tree_view_reorder_item;
198
 
  view_iface->rename_item      = gimp_container_tree_view_rename_item;
199
 
  view_iface->select_item      = gimp_container_tree_view_select_item;
200
 
  view_iface->clear_items      = gimp_container_tree_view_clear_items;
201
 
  view_iface->set_preview_size = gimp_container_tree_view_set_preview_size;
202
 
 
203
 
  view_iface->insert_data_free = (GDestroyNotify) g_free;
204
 
}
205
 
 
206
175
static GObject *
207
176
gimp_container_tree_view_constructor (GType                  type,
208
177
                                      guint                  n_params,
254
223
  tree_view->name_cell = gtk_cell_renderer_text_new ();
255
224
  g_object_set (tree_view->name_cell, "xalign", 0.0, NULL);
256
225
  gtk_tree_view_column_pack_end (tree_view->main_column,
257
 
                                   tree_view->name_cell,
258
 
                                   FALSE);
 
226
                                 tree_view->name_cell,
 
227
                                 FALSE);
259
228
 
260
229
  gtk_tree_view_column_set_attributes (tree_view->main_column,
261
230
                                       tree_view->name_cell,
276
245
                    G_CALLBACK (gimp_container_tree_view_selection_changed),
277
246
                    tree_view);
278
247
 
279
 
  g_signal_connect (tree_view->view, "drag_leave",
 
248
  g_signal_connect (tree_view->view, "drag-leave",
280
249
                    G_CALLBACK (gimp_container_tree_view_drag_leave),
281
250
                    tree_view);
282
 
  g_signal_connect (tree_view->view, "drag_motion",
 
251
  g_signal_connect (tree_view->view, "drag-motion",
283
252
                    G_CALLBACK (gimp_container_tree_view_drag_motion),
284
253
                    tree_view);
285
 
  g_signal_connect (tree_view->view, "drag_drop",
 
254
  g_signal_connect (tree_view->view, "drag-drop",
286
255
                    G_CALLBACK (gimp_container_tree_view_drag_drop),
287
256
                    tree_view);
288
 
  g_signal_connect (tree_view->view, "drag_data_received",
 
257
  g_signal_connect (tree_view->view, "drag-data-received",
289
258
                    G_CALLBACK (gimp_container_tree_view_drag_data_received),
290
259
                    tree_view);
291
260
 
378
347
static gboolean
379
348
gimp_container_tree_view_popup_menu (GtkWidget *widget)
380
349
{
381
 
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (widget);
382
 
 
383
 
  if (gtk_tree_selection_get_selected (tree_view->selection, NULL, NULL))
384
 
    {
385
 
      return gimp_editor_popup_menu (GIMP_EDITOR (tree_view),
386
 
                                     gimp_container_tree_view_menu_position,
387
 
                                     tree_view);
388
 
    }
389
 
 
390
 
  return FALSE;
 
350
  return gimp_editor_popup_menu (GIMP_EDITOR (widget),
 
351
                                 gimp_container_tree_view_menu_position,
 
352
                                 widget);
391
353
}
392
354
 
393
355
GtkWidget *
394
356
gimp_container_tree_view_new (GimpContainer *container,
395
357
                              GimpContext   *context,
396
 
                              gint           preview_size,
397
 
                              gint           preview_border_width)
 
358
                              gint           view_size,
 
359
                              gint           view_border_width)
398
360
{
399
361
  GimpContainerTreeView *tree_view;
400
362
  GimpContainerView     *view;
402
364
  g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),
403
365
                        NULL);
404
366
  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);
405
 
  g_return_val_if_fail (preview_size > 0 &&
406
 
                        preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);
407
 
  g_return_val_if_fail (preview_border_width >= 0 &&
408
 
                        preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,
 
367
  g_return_val_if_fail (view_size > 0 &&
 
368
                        view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);
 
369
  g_return_val_if_fail (view_border_width >= 0 &&
 
370
                        view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,
409
371
                        NULL);
410
372
 
411
373
  tree_view = g_object_new (GIMP_TYPE_CONTAINER_TREE_VIEW, NULL);
412
374
 
413
375
  view = GIMP_CONTAINER_VIEW (tree_view);
414
376
 
415
 
  gimp_container_view_set_preview_size (view, preview_size,
416
 
                                        preview_border_width);
 
377
  gimp_container_view_set_view_size (view, view_size, view_border_width);
417
378
 
418
379
  if (container)
419
380
    gimp_container_view_set_container (view, container);
432
393
  GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view);
433
394
  GimpViewRenderer  *renderer;
434
395
  gchar             *name;
435
 
  gint               preview_size;
 
396
  gint               view_size;
436
397
  gint               border_width;
437
398
 
438
 
  preview_size = gimp_container_view_get_preview_size (view, &border_width);
 
399
  view_size = gimp_container_view_get_view_size (view, &border_width);
439
400
 
440
 
  renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (viewable),
441
 
                                     preview_size, border_width,
 
401
  renderer = gimp_view_renderer_new (gimp_container_view_get_context (view),
 
402
                                     G_TYPE_FROM_INSTANCE (viewable),
 
403
                                     view_size, border_width,
442
404
                                     FALSE);
443
405
  gimp_view_renderer_set_viewable (renderer, viewable);
444
406
  gimp_view_renderer_remove_idle (renderer);
476
438
          if (gimp_dnd_viewable_source_remove (GTK_WIDGET (tree_view->view),
477
439
                                               old_container->children_type))
478
440
            {
 
441
              if (GIMP_VIEWABLE_CLASS (g_type_class_peek (old_container->children_type))->get_size)
 
442
                gimp_dnd_pixbuf_source_remove (GTK_WIDGET (tree_view->view));
 
443
 
479
444
              gtk_drag_source_unset (GTK_WIDGET (tree_view->view));
480
445
            }
481
446
 
495
460
                                        container->children_type,
496
461
                                        gimp_container_tree_view_drag_viewable,
497
462
                                        tree_view);
 
463
 
 
464
          if (GIMP_VIEWABLE_CLASS (g_type_class_peek (container->children_type))->get_size)
 
465
            gimp_dnd_pixbuf_source_add (GTK_WIDGET (tree_view->view),
 
466
                                        gimp_container_tree_view_drag_pixbuf,
 
467
                                        tree_view);
498
468
        }
499
469
 
500
470
      /*  connect button_press_event after DND so we can keep the list from
501
471
       *  selecting the item on button2
502
472
       */
503
 
      g_signal_connect (tree_view->view, "button_press_event",
 
473
      g_signal_connect (tree_view->view, "button-press-event",
504
474
                        G_CALLBACK (gimp_container_tree_view_button_press),
505
475
                        tree_view);
506
476
    }
508
478
  parent_view_iface->set_container (view, container);
509
479
}
510
480
 
 
481
static void
 
482
gimp_container_tree_view_set_context (GimpContainerView *view,
 
483
                                      GimpContext       *context)
 
484
{
 
485
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
 
486
 
 
487
  parent_view_iface->set_context (view, context);
 
488
 
 
489
  if (tree_view->model)
 
490
    {
 
491
      GtkTreeIter iter;
 
492
      gboolean    iter_valid;
 
493
 
 
494
      for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
 
495
           iter_valid;
 
496
           iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
 
497
        {
 
498
          GimpViewRenderer *renderer;
 
499
 
 
500
          gtk_tree_model_get (tree_view->model, &iter,
 
501
                              COLUMN_RENDERER, &renderer,
 
502
                              -1);
 
503
 
 
504
          gimp_view_renderer_set_context (renderer, context);
 
505
          g_object_unref (renderer);
 
506
        }
 
507
    }
 
508
}
 
509
 
511
510
static gpointer
512
511
gimp_container_tree_view_insert_item (GimpContainerView *view,
513
512
                                      GimpViewable      *viewable,
540
539
    {
541
540
      gtk_list_store_remove (GTK_LIST_STORE (tree_view->model), iter);
542
541
 
 
542
#ifdef __GNUC__
 
543
#warning FIXME: remove this hack as soon as bug #149906 is fixed
 
544
#endif
543
545
      /*  if the store is empty after this remove, clear out renderers
544
546
       *  from all cells so they don't keep refing the viewables
545
547
       */
691
693
 
692
694
  gtk_list_store_clear (GTK_LIST_STORE (tree_view->model));
693
695
 
 
696
#ifdef __GNUC__
 
697
#warning FIXME: remove this hack as soon as bug #149906 is fixed
 
698
#endif
694
699
  /*  clear out renderers from all cells so they don't keep refing the
695
700
   *  viewables
696
701
   */
706
711
}
707
712
 
708
713
static void
709
 
gimp_container_tree_view_set_preview_size (GimpContainerView *view)
 
714
gimp_container_tree_view_set_view_size (GimpContainerView *view)
710
715
{
711
716
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
712
717
  GtkWidget             *tree_widget;
713
 
  GtkTreeIter            iter;
714
 
  gboolean               iter_valid;
715
718
  GList                 *list;
716
 
  gint                   preview_size;
 
719
  gint                   view_size;
717
720
  gint                   border_width;
718
721
 
719
 
  preview_size = gimp_container_view_get_preview_size (view, &border_width);
 
722
  view_size = gimp_container_view_get_view_size (view, &border_width);
 
723
 
 
724
  if (tree_view->model)
 
725
    {
 
726
      GtkTreeIter iter;
 
727
      gboolean    iter_valid;
 
728
 
 
729
      for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
 
730
           iter_valid;
 
731
           iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
 
732
        {
 
733
          GimpViewRenderer *renderer;
 
734
 
 
735
          gtk_tree_model_get (tree_view->model, &iter,
 
736
                              COLUMN_RENDERER, &renderer,
 
737
                              -1);
 
738
 
 
739
          gimp_view_renderer_set_size (renderer, view_size, border_width);
 
740
          g_object_unref (renderer);
 
741
        }
 
742
    }
720
743
 
721
744
  tree_widget = GTK_WIDGET (tree_view->view);
722
745
 
 
746
  if (! tree_widget)
 
747
    return;
 
748
 
723
749
  for (list = tree_view->toggle_cells; list; list = g_list_next (list))
724
750
    {
725
751
      gchar       *stock_id;
732
758
          icon_size = gimp_get_icon_size (tree_widget,
733
759
                                          stock_id,
734
760
                                          GTK_ICON_SIZE_BUTTON,
735
 
                                          preview_size -
 
761
                                          view_size -
736
762
                                          2 * tree_widget->style->xthickness,
737
 
                                          preview_size -
 
763
                                          view_size -
738
764
                                          2 * tree_widget->style->ythickness);
739
765
 
740
766
          g_object_set (list->data, "stock-size", icon_size, NULL);
743
769
        }
744
770
    }
745
771
 
746
 
  for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
747
 
       iter_valid;
748
 
       iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
749
 
    {
750
 
      GimpViewRenderer *renderer;
751
 
 
752
 
      gtk_tree_model_get (tree_view->model, &iter,
753
 
                          COLUMN_RENDERER, &renderer,
754
 
                          -1);
755
 
 
756
 
      gimp_view_renderer_set_size (renderer, preview_size, border_width);
757
 
      g_object_unref (renderer);
758
 
    }
759
 
 
760
772
  gtk_tree_view_columns_autosize (tree_view->view);
761
773
}
762
774
 
769
781
{
770
782
  GtkTreeIter iter;
771
783
 
 
784
  g_print ("editing canceled\n");
 
785
 
772
786
  if (gtk_tree_selection_get_selected (tree_view->selection, NULL, &iter))
773
787
    {
774
788
      GimpViewRenderer *renderer;
780
794
 
781
795
      name = gimp_viewable_get_description (renderer->viewable, NULL);
782
796
 
 
797
      g_print ("restoring '%s'\n", name);
 
798
 
783
799
      gtk_list_store_set (GTK_LIST_STORE (tree_view->model), &iter,
784
800
                          tree_view->model_column_name, name,
785
801
                          -1);
856
872
  GimpContainerView *container_view = GIMP_CONTAINER_VIEW (tree_view);
857
873
  GtkTreeViewColumn *column;
858
874
  GtkTreePath       *path;
859
 
  gint               x;
860
875
 
861
 
  tree_view->dnd_viewable = NULL;
 
876
  tree_view->dnd_renderer = NULL;
862
877
 
863
878
  if (! GTK_WIDGET_HAS_FOCUS (widget))
864
879
    gtk_widget_grab_focus (widget);
865
880
 
866
 
  /*  Actually gtk_tree_view_get_path_at_pos() should take care of the
867
 
   *  render direction, but unfortunately it doesn't seem to do that.
868
 
   */
869
 
  if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL &&
870
 
      ! gtk_check_version (2, 7, 0))
871
 
    x = MAX (widget->requisition.width, widget->allocation.width) - bevent->x;
872
 
  else
873
 
    x = bevent->x;
874
 
 
875
881
  if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
876
 
                                     x, bevent->y,
 
882
                                     bevent->x, bevent->y,
877
883
                                     &path, &column, NULL, NULL))
878
884
    {
879
885
      GimpViewRenderer         *renderer;
889
895
                          COLUMN_RENDERER, &renderer,
890
896
                          -1);
891
897
 
892
 
      tree_view->dnd_viewable = renderer->viewable;
 
898
      tree_view->dnd_renderer = renderer;
893
899
 
894
900
      gtk_tree_view_get_background_area (tree_view->view, path,
895
901
                                         column, &column_area);
1039
1045
      gtk_tree_path_free (path);
1040
1046
      g_object_unref (renderer);
1041
1047
    }
 
1048
  else
 
1049
    {
 
1050
      switch (bevent->button)
 
1051
        {
 
1052
        case 3:
 
1053
          gimp_editor_popup_menu (GIMP_EDITOR (tree_view), NULL, NULL);
 
1054
          break;
 
1055
 
 
1056
        default:
 
1057
          break;
 
1058
        }
 
1059
    }
1042
1060
 
1043
1061
  return TRUE;
1044
1062
}
1063
1081
}
1064
1082
 
1065
1083
static GimpViewable *
1066
 
gimp_container_tree_view_drag_viewable (GtkWidget *widget,
1067
 
                                        gpointer   data)
1068
 
{
1069
 
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (data);
1070
 
 
1071
 
  return tree_view->dnd_viewable;
 
1084
gimp_container_tree_view_drag_viewable (GtkWidget    *widget,
 
1085
                                        GimpContext **context,
 
1086
                                        gpointer      data)
 
1087
{
 
1088
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (data);
 
1089
 
 
1090
  if (context)
 
1091
    *context = gimp_container_view_get_context (GIMP_CONTAINER_VIEW (data));
 
1092
 
 
1093
  if (tree_view->dnd_renderer)
 
1094
    return tree_view->dnd_renderer->viewable;
 
1095
 
 
1096
  return NULL;
 
1097
}
 
1098
 
 
1099
static GdkPixbuf *
 
1100
gimp_container_tree_view_drag_pixbuf (GtkWidget *widget,
 
1101
                                      gpointer   data)
 
1102
{
 
1103
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (data);
 
1104
  GimpViewRenderer      *renderer  = tree_view->dnd_renderer;
 
1105
  gint                   width;
 
1106
  gint                   height;
 
1107
 
 
1108
  if (renderer && gimp_viewable_get_size (renderer->viewable, &width, &height))
 
1109
    return gimp_viewable_get_new_pixbuf (renderer->viewable,
 
1110
                                         renderer->context,
 
1111
                                         width, height);
 
1112
 
 
1113
  return NULL;
1072
1114
}