← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/widgets/gimplayertreeview.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/gimplayertreeview.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
 * gimplayertreeview.c
25
25
 
26
26
#include <gtk/gtk.h>
27
27
 
28
 
#include "libgimpcolor/gimpcolor.h"
 
28
#include "libgimpbase/gimpbase.h"
29
29
#include "libgimpmath/gimpmath.h"
30
30
#include "libgimpwidgets/gimpwidgets.h"
31
31
 
32
32
#include "widgets-types.h"
33
33
 
 
34
#include "core/gimp.h"
34
35
#include "core/gimpcontainer.h"
35
 
#include "core/gimpdrawable-bucket-fill.h"
36
36
#include "core/gimplayer.h"
37
37
#include "core/gimplayermask.h"
38
38
#include "core/gimplayer-floating-sel.h"
40
40
#include "core/gimpimage.h"
41
41
#include "core/gimpimage-undo.h"
42
42
#include "core/gimpitemundo.h"
43
 
#include "core/gimppattern.h"
44
43
 
45
44
#include "text/gimptextlayer.h"
46
45
 
60
59
#include "gimp-intl.h"
61
60
 
62
61
 
63
 
static void   gimp_layer_tree_view_class_init (GimpLayerTreeViewClass *klass);
64
 
static void   gimp_layer_tree_view_init       (GimpLayerTreeView      *view);
65
 
 
66
 
static void   gimp_layer_tree_view_view_iface_init (GimpContainerViewInterface *view_iface);
 
62
static void  gimp_layer_tree_view_view_iface_init (GimpContainerViewInterface *iface);
67
63
 
68
64
static GObject * gimp_layer_tree_view_constructor (GType                type,
69
65
                                                   guint                n_params,
76
72
 
77
73
static void   gimp_layer_tree_view_set_container  (GimpContainerView   *view,
78
74
                                                   GimpContainer       *container);
 
75
static void   gimp_layer_tree_view_set_context    (GimpContainerView   *view,
 
76
                                                   GimpContext         *context);
79
77
static gpointer gimp_layer_tree_view_insert_item  (GimpContainerView   *view,
80
78
                                                   GimpViewable        *viewable,
81
79
                                                   gint                 index);
82
80
static gboolean gimp_layer_tree_view_select_item  (GimpContainerView   *view,
83
81
                                                   GimpViewable        *item,
84
82
                                                   gpointer             insert_data);
85
 
static void gimp_layer_tree_view_set_preview_size (GimpContainerView   *view);
 
83
static void    gimp_layer_tree_view_set_view_size (GimpContainerView   *view);
86
84
 
87
85
static gboolean gimp_layer_tree_view_drop_possible(GimpContainerTreeView *view,
88
86
                                                   GimpDndType          src_type,
91
89
                                                   GtkTreeViewDropPosition  drop_pos,
92
90
                                                   GtkTreeViewDropPosition *return_drop_pos,
93
91
                                                   GdkDragAction       *return_drag_action);
94
 
static void    gimp_layer_tree_view_drop_viewable (GimpContainerTreeView *view,
95
 
                                                   GimpViewable        *src_viewable,
96
 
                                                   GimpViewable        *dest_viewable,
97
 
                                                   GtkTreeViewDropPosition  drop_pos);
98
92
static void    gimp_layer_tree_view_drop_color    (GimpContainerTreeView *view,
99
93
                                                   const GimpRGB       *color,
100
94
                                                   GimpViewable        *dest_viewable,
103
97
                                                   GList               *uri_list,
104
98
                                                   GimpViewable        *dest_viewable,
105
99
                                                   GtkTreeViewDropPosition  drop_pos);
 
100
static void   gimp_layer_tree_view_drop_component (GimpContainerTreeView *tree_view,
 
101
                                                   GimpImage           *image,
 
102
                                                   GimpChannelType      component,
 
103
                                                   GimpViewable        *dest_viewable,
 
104
                                                   GtkTreeViewDropPosition  drop_pos);
 
105
static void   gimp_layer_tree_view_drop_pixbuf    (GimpContainerTreeView *tree_view,
 
106
                                                   GdkPixbuf           *pixbuf,
 
107
                                                   GimpViewable        *dest_viewable,
 
108
                                                   GtkTreeViewDropPosition  drop_pos);
106
109
 
107
110
static void   gimp_layer_tree_view_set_image      (GimpItemTreeView    *view,
108
 
                                                   GimpImage           *gimage);
 
111
                                                   GimpImage           *image);
109
112
static GimpItem * gimp_layer_tree_view_item_new   (GimpImage           *image);
110
113
 
111
114
static void   gimp_layer_tree_view_floating_selection_changed
112
 
                                                  (GimpImage           *gimage,
 
115
                                                  (GimpImage           *image,
113
116
                                                   GimpLayerTreeView   *view);
114
117
 
115
118
static void   gimp_layer_tree_view_paint_mode_menu_callback
116
119
                                                  (GtkWidget           *widget,
117
120
                                                   GimpLayerTreeView   *view);
118
 
static void   gimp_layer_tree_view_preserve_button_toggled
119
 
                                                  (GtkWidget           *widget,
120
 
                                                   GimpLayerTreeView   *view);
121
121
static void   gimp_layer_tree_view_opacity_scale_changed
122
122
                                                  (GtkAdjustment       *adj,
123
123
                                                   GimpLayerTreeView   *view);
 
124
static void   gimp_layer_tree_view_lock_alpha_button_toggled
 
125
                                                  (GtkWidget           *widget,
 
126
                                                   GimpLayerTreeView   *view);
124
127
 
125
128
static void   gimp_layer_tree_view_layer_signal_handler
126
129
                                                  (GimpLayer           *layer,
158
161
                                                   GimpLayerTreeView   *view);
159
162
 
160
163
 
161
 
static GimpDrawableTreeViewClass  *parent_class      = NULL;
 
164
G_DEFINE_TYPE_WITH_CODE (GimpLayerTreeView, gimp_layer_tree_view,
 
165
                         GIMP_TYPE_DRAWABLE_TREE_VIEW,
 
166
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
 
167
                                                gimp_layer_tree_view_view_iface_init))
 
168
 
 
169
#define parent_class gimp_layer_tree_view_parent_class
 
170
 
162
171
static GimpContainerViewInterface *parent_view_iface = NULL;
163
172
 
164
173
 
165
 
GType
166
 
gimp_layer_tree_view_get_type (void)
167
 
{
168
 
  static GType view_type = 0;
169
 
 
170
 
  if (! view_type)
171
 
    {
172
 
      static const GTypeInfo view_info =
173
 
      {
174
 
        sizeof (GimpLayerTreeViewClass),
175
 
        NULL,           /* base_init */
176
 
        NULL,           /* base_finalize */
177
 
        (GClassInitFunc) gimp_layer_tree_view_class_init,
178
 
        NULL,           /* class_finalize */
179
 
        NULL,           /* class_data */
180
 
        sizeof (GimpLayerTreeView),
181
 
        0,              /* n_preallocs */
182
 
        (GInstanceInitFunc) gimp_layer_tree_view_init,
183
 
      };
184
 
 
185
 
      static const GInterfaceInfo view_iface_info =
186
 
      {
187
 
        (GInterfaceInitFunc) gimp_layer_tree_view_view_iface_init,
188
 
        NULL,           /* iface_finalize */
189
 
        NULL            /* iface_data     */
190
 
      };
191
 
 
192
 
      view_type = g_type_register_static (GIMP_TYPE_DRAWABLE_TREE_VIEW,
193
 
                                          "GimpLayerTreeView",
194
 
                                          &view_info, 0);
195
 
 
196
 
      g_type_add_interface_static (view_type, GIMP_TYPE_CONTAINER_VIEW,
197
 
                                   &view_iface_info);
198
 
    }
199
 
 
200
 
  return view_type;
201
 
}
202
 
 
203
174
static void
204
175
gimp_layer_tree_view_class_init (GimpLayerTreeViewClass *klass)
205
176
{
213
184
  tree_view_class = GIMP_CONTAINER_TREE_VIEW_CLASS (klass);
214
185
  item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
215
186
 
216
 
  parent_class = g_type_class_peek_parent (klass);
217
 
 
218
187
  object_class->constructor = gimp_layer_tree_view_constructor;
219
188
  object_class->finalize    = gimp_layer_tree_view_finalize;
220
189
 
222
191
  widget_class->style_set   = gimp_layer_tree_view_style_set;
223
192
 
224
193
  tree_view_class->drop_possible   = gimp_layer_tree_view_drop_possible;
225
 
  tree_view_class->drop_viewable   = gimp_layer_tree_view_drop_viewable;
226
194
  tree_view_class->drop_color      = gimp_layer_tree_view_drop_color;
227
195
  tree_view_class->drop_uri_list   = gimp_layer_tree_view_drop_uri_list;
 
196
  tree_view_class->drop_component  = gimp_layer_tree_view_drop_component;
 
197
  tree_view_class->drop_pixbuf     = gimp_layer_tree_view_drop_pixbuf;
228
198
 
229
199
  item_view_class->item_type       = GIMP_TYPE_LAYER;
230
200
  item_view_class->signal_name     = "active-layer-changed";
253
223
}
254
224
 
255
225
static void
 
226
gimp_layer_tree_view_view_iface_init (GimpContainerViewInterface *iface)
 
227
{
 
228
  parent_view_iface = g_type_interface_peek_parent (iface);
 
229
 
 
230
  iface->set_container = gimp_layer_tree_view_set_container;
 
231
  iface->set_context   = gimp_layer_tree_view_set_context;
 
232
  iface->insert_item   = gimp_layer_tree_view_insert_item;
 
233
  iface->select_item   = gimp_layer_tree_view_select_item;
 
234
  iface->set_view_size = gimp_layer_tree_view_set_view_size;
 
235
}
 
236
 
 
237
static void
256
238
gimp_layer_tree_view_init (GimpLayerTreeView *view)
257
239
{
258
240
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
259
241
  GtkWidget             *hbox;
260
 
  GtkWidget             *toggle;
261
242
  GtkWidget             *image;
262
243
  GtkIconSize            icon_size;
263
244
  PangoAttribute        *attr;
279
260
  tree_view->model_columns[tree_view->n_model_columns] = G_TYPE_BOOLEAN;
280
261
  tree_view->n_model_columns++;
281
262
 
282
 
  view->options_box = gtk_table_new (2, 3, FALSE);
 
263
  view->options_box = gtk_table_new (3, 3, FALSE);
283
264
  gtk_table_set_col_spacings (GTK_TABLE (view->options_box), 2);
284
265
  gtk_box_pack_start (GTK_BOX (view), view->options_box, FALSE, FALSE, 0);
285
266
  gtk_box_reorder_child (GTK_BOX (view), view->options_box, 0);
286
267
  gtk_widget_show (view->options_box);
287
268
 
288
 
  hbox = gtk_hbox_new (FALSE, 6);
289
 
 
290
269
  /*  Paint mode menu  */
291
270
 
292
 
  view->paint_mode_menu =
293
 
    gimp_paint_mode_menu_new (G_CALLBACK (gimp_layer_tree_view_paint_mode_menu_callback),
294
 
                              view,
295
 
                              FALSE,
296
 
                              GIMP_NORMAL_MODE);
297
 
  gtk_box_pack_start (GTK_BOX (hbox), view->paint_mode_menu, TRUE, TRUE, 0);
298
 
  gtk_widget_show (view->paint_mode_menu);
 
271
  view->paint_mode_menu = gimp_paint_mode_menu_new (FALSE, FALSE);
 
272
  gimp_table_attach_aligned (GTK_TABLE (view->options_box), 0, 0,
 
273
                             _("Mode:"), 0.0, 0.5,
 
274
                             view->paint_mode_menu, 2, FALSE);
 
275
 
 
276
  gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (view->paint_mode_menu),
 
277
                              GIMP_NORMAL_MODE,
 
278
                              G_CALLBACK (gimp_layer_tree_view_paint_mode_menu_callback),
 
279
                              view);
299
280
 
300
281
  gimp_help_set_help_data (view->paint_mode_menu, NULL,
301
282
                           GIMP_HELP_LAYER_DIALOG_PAINT_MODE_MENU);
302
283
 
303
 
  /*  Preserve transparency toggle  */
304
 
 
305
 
  view->preserve_trans_toggle = toggle = gtk_check_button_new ();
306
 
  gtk_box_pack_end (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
307
 
  gtk_widget_show (toggle);
308
 
 
309
 
  g_signal_connect (toggle, "toggled",
310
 
                    G_CALLBACK (gimp_layer_tree_view_preserve_button_toggled),
311
 
                    view);
312
 
 
313
 
  gimp_help_set_help_data (toggle, _("Keep transparency"),
314
 
                           GIMP_HELP_LAYER_DIALOG_KEEP_TRANS_BUTTON);
315
 
 
316
 
  gtk_widget_style_get (GTK_WIDGET (view),
317
 
                        "button_icon_size", &icon_size,
318
 
                        NULL);
319
 
 
320
 
  image = gtk_image_new_from_stock (GIMP_STOCK_TRANSPARENCY, icon_size);
321
 
  gtk_container_add (GTK_CONTAINER (toggle), image);
322
 
  gtk_widget_show (image);
323
 
 
324
 
  gimp_table_attach_aligned (GTK_TABLE (view->options_box), 0, 0,
325
 
                             _("Mode:"), 0.0, 0.5,
326
 
                             hbox, 2, FALSE);
327
 
 
328
284
  /*  Opacity scale  */
329
285
 
330
286
  view->opacity_adjustment =
335
291
                                          NULL,
336
292
                                          GIMP_HELP_LAYER_DIALOG_OPACITY_SCALE));
337
293
 
338
 
  g_signal_connect (view->opacity_adjustment, "value_changed",
 
294
  g_signal_connect (view->opacity_adjustment, "value-changed",
339
295
                    G_CALLBACK (gimp_layer_tree_view_opacity_scale_changed),
340
296
                    view);
341
297
 
 
298
  /*  Lock alpha toggle  */
 
299
 
 
300
  hbox = gtk_hbox_new (FALSE, 6);
 
301
 
 
302
  view->lock_alpha_toggle = gtk_check_button_new ();
 
303
  gtk_box_pack_start (GTK_BOX (hbox), view->lock_alpha_toggle, FALSE, FALSE, 0);
 
304
  gtk_widget_show (view->lock_alpha_toggle);
 
305
 
 
306
  g_signal_connect (view->lock_alpha_toggle, "toggled",
 
307
                    G_CALLBACK (gimp_layer_tree_view_lock_alpha_button_toggled),
 
308
                    view);
 
309
 
 
310
  gimp_help_set_help_data (view->lock_alpha_toggle, _("Lock alpha channel"),
 
311
                           GIMP_HELP_LAYER_DIALOG_LOCK_ALPHA_BUTTON);
 
312
 
 
313
  gtk_widget_style_get (GTK_WIDGET (view),
 
314
                        "button-icon-size", &icon_size,
 
315
                        NULL);
 
316
 
 
317
  image = gtk_image_new_from_stock (GIMP_STOCK_TRANSPARENCY, icon_size);
 
318
  gtk_container_add (GTK_CONTAINER (view->lock_alpha_toggle), image);
 
319
  gtk_widget_show (image);
 
320
 
 
321
  gimp_table_attach_aligned (GTK_TABLE (view->options_box), 0, 2,
 
322
                             _("Lock:"), 0.0, 0.5,
 
323
                             hbox, 2, FALSE);
 
324
 
342
325
  gtk_widget_set_sensitive (view->options_box, FALSE);
343
326
 
344
327
  view->italic_attrs = pango_attr_list_new ();
353
336
  attr->end_index   = -1;
354
337
  pango_attr_list_insert (view->bold_attrs, attr);
355
338
 
356
 
  view->mode_changed_handler_id           = 0;
357
 
  view->opacity_changed_handler_id        = 0;
358
 
  view->preserve_trans_changed_handler_id = 0;
359
 
  view->mask_changed_handler_id           = 0;
360
 
}
361
 
 
362
 
static void
363
 
gimp_layer_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
364
 
{
365
 
  parent_view_iface = g_type_interface_peek_parent (view_iface);
366
 
 
367
 
  view_iface->set_container    = gimp_layer_tree_view_set_container;
368
 
  view_iface->insert_item      = gimp_layer_tree_view_insert_item;
369
 
  view_iface->select_item      = gimp_layer_tree_view_select_item;
370
 
  view_iface->set_preview_size = gimp_layer_tree_view_set_preview_size;
 
339
  view->mode_changed_handler_id       = 0;
 
340
  view->opacity_changed_handler_id    = 0;
 
341
  view->lock_alpha_changed_handler_id = 0;
 
342
  view->mask_changed_handler_id       = 0;
371
343
}
372
344
 
373
345
static GObject *
377
349
{
378
350
  GimpContainerTreeView *tree_view;
379
351
  GimpLayerTreeView     *layer_view;
 
352
  GtkWidget             *button;
380
353
  GObject               *object;
381
354
 
382
355
  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
406
379
                    G_CALLBACK (gimp_layer_tree_view_mask_clicked),
407
380
                    layer_view);
408
381
 
409
 
  gimp_dnd_uri_list_dest_add (GTK_WIDGET (tree_view->view),
410
 
                              NULL, tree_view);
411
 
  gimp_dnd_color_dest_add (GTK_WIDGET (tree_view->view),
412
 
                           NULL, tree_view);
413
 
  gimp_dnd_viewable_dest_add (GTK_WIDGET (tree_view->view), GIMP_TYPE_PATTERN,
414
 
                              NULL, tree_view);
 
382
  gimp_dnd_uri_list_dest_add  (GTK_WIDGET (tree_view->view),
 
383
                               NULL, tree_view);
 
384
  gimp_dnd_component_dest_add (GTK_WIDGET (tree_view->view),
 
385
                               NULL, tree_view);
 
386
  gimp_dnd_viewable_dest_add  (GTK_WIDGET (tree_view->view), GIMP_TYPE_CHANNEL,
 
387
                               NULL, tree_view);
 
388
  gimp_dnd_viewable_dest_add  (GTK_WIDGET (tree_view->view), GIMP_TYPE_LAYER_MASK,
 
389
                               NULL, tree_view);
 
390
  gimp_dnd_pixbuf_dest_add    (GTK_WIDGET (tree_view->view),
 
391
                               NULL, tree_view);
415
392
 
416
393
  /*  hide basically useless edit button  */
417
394
  gtk_widget_hide (GIMP_ITEM_TREE_VIEW (layer_view)->edit_button);
418
395
 
419
 
  layer_view->anchor_button =
420
 
    gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
421
 
                                   "layers-anchor", NULL);
 
396
  button = gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
 
397
                                          "layers-anchor", NULL);
422
398
  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
423
 
                                  GTK_BUTTON (layer_view->anchor_button),
 
399
                                  GTK_BUTTON (button),
424
400
                                  GIMP_TYPE_LAYER);
425
401
  gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (layer_view)->button_box),
426
 
                         layer_view->anchor_button, 5);
427
 
 
 
402
                         button, 5);
428
403
 
429
404
  return object;
430
405
}
486
461
  gint               button_spacing;
487
462
 
488
463
  gtk_widget_style_get (widget,
489
 
                        "content_spacing", &content_spacing,
490
 
                        "button_spacing",  &button_spacing,
 
464
                        "content-spacing", &content_spacing,
 
465
                        "button-spacing",  &button_spacing,
491
466
                        NULL);
492
467
 
493
468
  gtk_table_set_col_spacings (GTK_TABLE (layer_view->options_box),
518
493
      gimp_container_remove_handler (old_container,
519
494
                                     layer_view->opacity_changed_handler_id);
520
495
      gimp_container_remove_handler (old_container,
521
 
                                     layer_view->preserve_trans_changed_handler_id);
 
496
                                     layer_view->lock_alpha_changed_handler_id);
522
497
      gimp_container_remove_handler (old_container,
523
498
                                     layer_view->mask_changed_handler_id);
524
499
      gimp_container_remove_handler (old_container,
530
505
  if (container)
531
506
    {
532
507
      layer_view->mode_changed_handler_id =
533
 
        gimp_container_add_handler (container, "mode_changed",
 
508
        gimp_container_add_handler (container, "mode-changed",
534
509
                                    G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
535
510
                                    view);
536
511
      layer_view->opacity_changed_handler_id =
537
 
        gimp_container_add_handler (container, "opacity_changed",
 
512
        gimp_container_add_handler (container, "opacity-changed",
538
513
                                    G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
539
514
                                    view);
540
 
      layer_view->preserve_trans_changed_handler_id =
541
 
        gimp_container_add_handler (container, "preserve_trans_changed",
 
515
      layer_view->lock_alpha_changed_handler_id =
 
516
        gimp_container_add_handler (container, "lock-alpha-changed",
542
517
                                    G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
543
518
                                    view);
544
519
      layer_view->mask_changed_handler_id =
545
 
        gimp_container_add_handler (container, "mask_changed",
 
520
        gimp_container_add_handler (container, "mask-changed",
546
521
                                    G_CALLBACK (gimp_layer_tree_view_mask_changed),
547
522
                                    view);
548
523
      layer_view->alpha_changed_handler_id =
549
 
        gimp_container_add_handler (container, "alpha_changed",
 
524
        gimp_container_add_handler (container, "alpha-changed",
550
525
                                    G_CALLBACK (gimp_layer_tree_view_alpha_changed),
551
526
                                    view);
552
527
    }
553
528
}
554
529
 
 
530
static void
 
531
gimp_layer_tree_view_set_context (GimpContainerView *view,
 
532
                                  GimpContext       *context)
 
533
{
 
534
  GimpContainerTreeView *tree_view  = GIMP_CONTAINER_TREE_VIEW (view);
 
535
  GimpLayerTreeView     *layer_view = GIMP_LAYER_TREE_VIEW (view);
 
536
 
 
537
  parent_view_iface->set_context (view, context);
 
538
 
 
539
  if (tree_view->model)
 
540
    {
 
541
      GtkTreeIter iter;
 
542
      gboolean    iter_valid;
 
543
 
 
544
      for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
 
545
           iter_valid;
 
546
           iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
 
547
        {
 
548
          GimpViewRenderer *renderer;
 
549
 
 
550
          gtk_tree_model_get (tree_view->model, &iter,
 
551
                              layer_view->model_column_mask, &renderer,
 
552
                              -1);
 
553
 
 
554
          if (renderer)
 
555
            {
 
556
              gimp_view_renderer_set_context (renderer, context);
 
557
              g_object_unref (renderer);
 
558
            }
 
559
        }
 
560
    }
 
561
}
 
562
 
555
563
static gpointer
556
564
gimp_layer_tree_view_insert_item (GimpContainerView *view,
557
565
                                  GimpViewable      *viewable,
609
617
}
610
618
 
611
619
static void
612
 
gimp_layer_tree_view_set_preview_size (GimpContainerView *view)
 
620
gimp_layer_tree_view_set_view_size (GimpContainerView *view)
613
621
{
614
622
  GimpContainerTreeView *tree_view  = GIMP_CONTAINER_TREE_VIEW (view);
615
 
  GimpLayerTreeView     *layer_view = GIMP_LAYER_TREE_VIEW (view);
616
 
  GtkTreeIter            iter;
617
 
  gboolean               iter_valid;
618
 
  gint                   preview_size;
619
 
  gint                   border_width;
620
 
 
621
 
  preview_size = gimp_container_view_get_preview_size (view, &border_width);
622
 
 
623
 
  for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
624
 
       iter_valid;
625
 
       iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
 
623
 
 
624
  if (tree_view->model)
626
625
    {
627
 
      GimpViewRenderer *renderer;
628
 
 
629
 
      gtk_tree_model_get (tree_view->model, &iter,
630
 
                          layer_view->model_column_mask, &renderer,
631
 
                          -1);
632
 
 
633
 
      if (renderer)
 
626
      GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
 
627
      GtkTreeIter        iter;
 
628
      gboolean           iter_valid;
 
629
      gint               view_size;
 
630
      gint               border_width;
 
631
 
 
632
      view_size = gimp_container_view_get_view_size (view, &border_width);
 
633
 
 
634
      for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
 
635
           iter_valid;
 
636
           iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
634
637
        {
635
 
          gimp_view_renderer_set_size (renderer, preview_size, border_width);
636
 
          g_object_unref (renderer);
 
638
          GimpViewRenderer *renderer;
 
639
 
 
640
          gtk_tree_model_get (tree_view->model, &iter,
 
641
                              layer_view->model_column_mask, &renderer,
 
642
                              -1);
 
643
 
 
644
          if (renderer)
 
645
            {
 
646
              gimp_view_renderer_set_size (renderer, view_size, border_width);
 
647
              g_object_unref (renderer);
 
648
            }
637
649
        }
638
650
    }
639
651
 
640
 
  parent_view_iface->set_preview_size (view);
 
652
  parent_view_iface->set_view_size (view);
641
653
}
642
654
 
643
655
 
652
664
                                    GtkTreeViewDropPosition *return_drop_pos,
653
665
                                    GdkDragAction           *return_drag_action)
654
666
{
 
667
  /* If we are dropping a new layer, check if the destionation image
 
668
   * has a floating selection.
 
669
   */
655
670
  if  (src_type == GIMP_DND_TYPE_URI_LIST     ||
656
671
       src_type == GIMP_DND_TYPE_TEXT_PLAIN   ||
657
672
       src_type == GIMP_DND_TYPE_NETSCAPE_URL ||
658
 
       GIMP_IS_LAYER (src_viewable))
 
673
       src_type == GIMP_DND_TYPE_COMPONENT    ||
 
674
       src_type == GIMP_DND_TYPE_PIXBUF       ||
 
675
       GIMP_IS_DRAWABLE (src_viewable))
659
676
    {
660
 
      GimpLayer *dest_layer = GIMP_LAYER (dest_viewable);
661
 
      GimpImage *dest_image = gimp_item_get_image (GIMP_ITEM (dest_layer));
 
677
      GimpImage *dest_image = GIMP_ITEM_TREE_VIEW (tree_view)->image;
662
678
 
663
679
      if (gimp_image_floating_sel (dest_image))
664
680
        return FALSE;
665
 
 
666
 
      if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (dest_layer)) &&
667
 
          drop_pos == GTK_TREE_VIEW_DROP_AFTER)
668
 
        return FALSE;
669
 
 
670
 
      if (GIMP_IS_LAYER (src_viewable))
671
 
        {
672
 
          GimpLayer *src_layer  = GIMP_LAYER (src_viewable);
673
 
          GimpImage *src_image  = gimp_item_get_image (GIMP_ITEM (src_layer));
674
 
 
675
 
          if (src_image == dest_image &&
676
 
              ! gimp_drawable_has_alpha (GIMP_DRAWABLE (src_layer)))
677
 
            return FALSE;
678
 
        }
679
 
    }
680
 
 
681
 
  if (GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_possible (tree_view,
682
 
                                                                    src_type,
683
 
                                                                    src_viewable,
684
 
                                                                    dest_viewable,
685
 
                                                                    drop_pos,
686
 
                                                                    return_drop_pos,
687
 
                                                                    return_drag_action))
688
 
    {
689
 
      if (return_drop_pos &&
690
 
          (src_type == GIMP_DND_TYPE_COLOR ||
691
 
           src_type == GIMP_DND_TYPE_PATTERN))
692
 
        {
693
 
          if (drop_pos == GTK_TREE_VIEW_DROP_BEFORE)
694
 
            *return_drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
695
 
          else
696
 
            *return_drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
697
 
        }
698
 
 
699
 
      return TRUE;
700
 
    }
701
 
 
702
 
  return FALSE;
703
 
}
704
 
 
705
 
static void
706
 
gimp_layer_tree_view_drop_viewable (GimpContainerTreeView   *view,
707
 
                                    GimpViewable            *src_viewable,
708
 
                                    GimpViewable            *dest_viewable,
709
 
                                    GtkTreeViewDropPosition  drop_pos)
710
 
{
711
 
  if (GIMP_IS_PATTERN (src_viewable))
712
 
    {
713
 
      gimp_drawable_bucket_fill_full (GIMP_DRAWABLE (dest_viewable),
714
 
                                      GIMP_PATTERN_BUCKET_FILL,
715
 
                                      GIMP_NORMAL_MODE, GIMP_OPACITY_OPAQUE,
716
 
                                      FALSE,             /* no seed fill */
717
 
                                      FALSE, 0.0, FALSE, /* fill params  */
718
 
                                      0.0, 0.0,          /* ignored      */
719
 
                                      NULL, GIMP_PATTERN (src_viewable));
720
 
      gimp_image_flush (GIMP_ITEM_TREE_VIEW (view)->gimage);
721
 
      return;
722
 
    }
723
 
 
724
 
  GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_viewable (view,
725
 
                                                                src_viewable,
726
 
                                                                dest_viewable,
727
 
                                                                drop_pos);
 
681
    }
 
682
 
 
683
  return GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_possible (tree_view,
 
684
                                                                       src_type,
 
685
                                                                       src_viewable,
 
686
                                                                       dest_viewable,
 
687
                                                                       drop_pos,
 
688
                                                                       return_drop_pos,
 
689
                                                                       return_drag_action);
728
690
}
729
691
 
730
692
static void
738
700
      gimp_text_layer_set (GIMP_TEXT_LAYER (dest_viewable), NULL,
739
701
                           "color", color,
740
702
                           NULL);
741
 
    }
742
 
  else
743
 
    {
744
 
      gimp_drawable_bucket_fill_full (GIMP_DRAWABLE (dest_viewable),
745
 
                                      GIMP_FG_BUCKET_FILL,
746
 
                                      GIMP_NORMAL_MODE, GIMP_OPACITY_OPAQUE,
747
 
                                      FALSE,             /* no seed fill */
748
 
                                      FALSE, 0.0, FALSE, /* fill params  */
749
 
                                      0.0, 0.0,          /* ignored      */
750
 
                                      color, NULL);
 
703
      gimp_image_flush (GIMP_ITEM_TREE_VIEW (view)->image);
 
704
      return;
751
705
    }
752
706
 
753
 
  gimp_image_flush (GIMP_ITEM_TREE_VIEW (view)->gimage);
 
707
  GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_color (view, color,
 
708
                                                             dest_viewable,
 
709
                                                             drop_pos);
754
710
}
755
711
 
756
712
static void
759
715
                                    GimpViewable            *dest_viewable,
760
716
                                    GtkTreeViewDropPosition  drop_pos)
761
717
{
762
 
  GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
763
 
  GimpImage        *gimage    = item_view->gimage;
764
 
  GList            *list;
765
 
  gint              index;
766
 
 
767
 
  index = gimp_image_get_layer_index (gimage, GIMP_LAYER (dest_viewable));
768
 
 
769
 
  if (drop_pos == GTK_TREE_VIEW_DROP_AFTER)
770
 
    index++;
 
718
  GimpItemTreeView  *item_view = GIMP_ITEM_TREE_VIEW (view);
 
719
  GimpContainerView *cont_view = GIMP_CONTAINER_VIEW (view);
 
720
  GimpImage         *image     = item_view->image;
 
721
  gint               index     = -1;
 
722
  GList             *list;
 
723
 
 
724
  if (dest_viewable)
 
725
    {
 
726
      index = gimp_image_get_layer_index (image, GIMP_LAYER (dest_viewable));
 
727
 
 
728
      if (drop_pos == GTK_TREE_VIEW_DROP_AFTER)
 
729
        index++;
 
730
    }
771
731
 
772
732
  for (list = uri_list; list; list = g_list_next (list))
773
733
    {
774
734
      const gchar       *uri   = list->data;
775
 
      GimpLayer         *new_layer;
 
735
      GList             *new_layers;
776
736
      GimpPDBStatusType  status;
777
737
      GError            *error = NULL;
778
738
 
779
 
      new_layer = file_open_layer (gimage->gimp, item_view->context, NULL,
780
 
                                   gimage, uri, &status, &error);
 
739
      new_layers = file_open_layers (image->gimp,
 
740
                                     gimp_container_view_get_context (cont_view),
 
741
                                     NULL,
 
742
                                     image, FALSE,
 
743
                                     uri, GIMP_RUN_INTERACTIVE, NULL,
 
744
                                     &status, &error);
781
745
 
782
 
      if (new_layer)
 
746
      if (new_layers)
783
747
        {
784
 
          GimpItem *new_item = GIMP_ITEM (new_layer);
785
 
          gint      width, height;
786
 
          gint      off_x, off_y;
787
 
 
788
 
          width  = gimp_image_get_width (gimage);
789
 
          height = gimp_image_get_height (gimage);
790
 
 
791
 
          gimp_item_offsets (new_item, &off_x, &off_y);
792
 
 
793
 
          off_x = (width  - gimp_item_width  (new_item)) / 2 - off_x;
794
 
          off_y = (height - gimp_item_height (new_item)) / 2 - off_y;
795
 
 
796
 
          gimp_item_translate (new_item, off_x, off_y, FALSE);
797
 
 
798
 
          gimp_image_add_layer (gimage, new_layer, index++);
 
748
          gimp_image_add_layers (image, new_layers, index,
 
749
                                 0, 0,
 
750
                                 gimp_image_get_width (image),
 
751
                                 gimp_image_get_height (image),
 
752
                                 _("Drop layers"));
 
753
 
 
754
          index += g_list_length (new_layers);
 
755
 
 
756
          g_list_free (new_layers);
799
757
        }
800
758
      else if (status != GIMP_PDB_CANCEL)
801
759
        {
802
 
          gchar *filename = file_utils_uri_to_utf8_filename (uri);
 
760
          gchar *filename = file_utils_uri_display_name (uri);
803
761
 
804
 
          g_message (_("Opening '%s' failed:\n\n%s"),
805
 
                     filename, error->message);
 
762
          gimp_message (image->gimp, NULL, GIMP_MESSAGE_ERROR,
 
763
                        _("Opening '%s' failed:\n\n%s"),
 
764
                        filename, error->message);
806
765
 
807
766
          g_clear_error (&error);
808
767
          g_free (filename);
809
768
        }
810
769
    }
811
770
 
812
 
  gimp_image_flush (gimage);
 
771
  gimp_image_flush (image);
 
772
}
 
773
 
 
774
static void
 
775
gimp_layer_tree_view_drop_component (GimpContainerTreeView   *tree_view,
 
776
                                     GimpImage               *src_image,
 
777
                                     GimpChannelType          component,
 
778
                                     GimpViewable            *dest_viewable,
 
779
                                     GtkTreeViewDropPosition  drop_pos)
 
780
{
 
781
  GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (tree_view);
 
782
  GimpChannel      *channel;
 
783
  GimpItem         *new_item;
 
784
  const gchar      *desc;
 
785
  gint              index = -1;
 
786
 
 
787
  if (dest_viewable)
 
788
    {
 
789
      index = gimp_image_get_layer_index (item_view->image,
 
790
                                          GIMP_LAYER (dest_viewable));
 
791
 
 
792
      if (drop_pos == GTK_TREE_VIEW_DROP_AFTER)
 
793
        index++;
 
794
    }
 
795
 
 
796
  channel = gimp_channel_new_from_component (src_image, component, NULL, NULL);
 
797
 
 
798
  new_item = gimp_item_convert (GIMP_ITEM (channel), item_view->image,
 
799
                                GIMP_TYPE_LAYER, TRUE);
 
800
 
 
801
  g_object_unref (channel);
 
802
 
 
803
  gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component,
 
804
                       NULL, NULL, &desc, NULL);
 
805
  gimp_object_take_name (GIMP_OBJECT (new_item),
 
806
                         g_strdup_printf (_("%s Channel Copy"), desc));
 
807
 
 
808
  gimp_image_add_layer (item_view->image, GIMP_LAYER (new_item), index);
 
809
  gimp_image_flush (item_view->image);
 
810
}
 
811
 
 
812
static void
 
813
gimp_layer_tree_view_drop_pixbuf (GimpContainerTreeView   *tree_view,
 
814
                                  GdkPixbuf               *pixbuf,
 
815
                                  GimpViewable            *dest_viewable,
 
816
                                  GtkTreeViewDropPosition  drop_pos)
 
817
{
 
818
  GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (tree_view);
 
819
  GimpImage        *image     = item_view->image;
 
820
  GimpLayer        *new_layer;
 
821
  gint              index     = -1;
 
822
 
 
823
  if (dest_viewable)
 
824
    {
 
825
      index = gimp_image_get_layer_index (image, GIMP_LAYER (dest_viewable));
 
826
 
 
827
      if (drop_pos == GTK_TREE_VIEW_DROP_AFTER)
 
828
        index++;
 
829
    }
 
830
 
 
831
  new_layer =
 
832
    gimp_layer_new_from_pixbuf (pixbuf, image,
 
833
                                gimp_image_base_type_with_alpha (image),
 
834
                                _("Dropped Buffer"),
 
835
                                GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
 
836
 
 
837
  gimp_image_add_layer (image, new_layer, index);
 
838
  gimp_image_flush (image);
813
839
}
814
840
 
815
841
 
817
843
 
818
844
static void
819
845
gimp_layer_tree_view_set_image (GimpItemTreeView *view,
820
 
                                GimpImage        *gimage)
 
846
                                GimpImage        *image)
821
847
{
822
 
  if (view->gimage)
823
 
    g_signal_handlers_disconnect_by_func (view->gimage,
 
848
  if (view->image)
 
849
    g_signal_handlers_disconnect_by_func (view->image,
824
850
                                          gimp_layer_tree_view_floating_selection_changed,
825
851
                                          view);
826
852
 
827
 
  GIMP_ITEM_TREE_VIEW_CLASS (parent_class)->set_image (view, gimage);
 
853
  GIMP_ITEM_TREE_VIEW_CLASS (parent_class)->set_image (view, image);
828
854
 
829
 
  if (view->gimage)
830
 
    g_signal_connect (view->gimage,
831
 
                      "floating_selection_changed",
 
855
  if (view->image)
 
856
    g_signal_connect (view->image,
 
857
                      "floating-selection-changed",
832
858
                      G_CALLBACK (gimp_layer_tree_view_floating_selection_changed),
833
859
                      view);
834
860
}
858
884
/*  callbacks  */
859
885
 
860
886
static void
861
 
gimp_layer_tree_view_floating_selection_changed (GimpImage         *gimage,
 
887
gimp_layer_tree_view_floating_selection_changed (GimpImage         *image,
862
888
                                                 GimpLayerTreeView *layer_view)
863
889
{
864
890
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
866
892
  GimpLayer             *floating_sel;
867
893
  GtkTreeIter           *iter;
868
894
 
869
 
  floating_sel = gimp_image_floating_sel (gimage);
 
895
  floating_sel = gimp_image_floating_sel (image);
870
896
 
871
897
  if (floating_sel)
872
898
    {
882
908
    {
883
909
      GList *list;
884
910
 
885
 
      for (list = GIMP_LIST (gimage->layers)->list;
 
911
      for (list = GIMP_LIST (image->layers)->list;
886
912
           list;
887
913
           list = g_list_next (list))
888
914
        {
889
915
          GimpDrawable *drawable = list->data;
890
916
 
891
 
          if (gimp_drawable_has_alpha (drawable))
892
 
            {
893
 
              iter = gimp_container_view_lookup (view,
894
 
                                                 (GimpViewable *) drawable);
 
917
          iter = gimp_container_view_lookup (view, (GimpViewable *) drawable);
895
918
 
896
 
              if (iter)
897
 
                gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
898
 
                                    tree_view->model_column_name_attributes,
899
 
                                    NULL,
900
 
                                    -1);
901
 
            }
 
919
          if (iter)
 
920
            gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
 
921
                                tree_view->model_column_name_attributes,
 
922
                                gimp_drawable_has_alpha (drawable) ?
 
923
                                NULL : layer_view->bold_attrs,
 
924
                                -1);
902
925
        }
903
926
    }
904
927
}
905
928
 
906
929
 
907
 
/*  Paint Mode, Opacity and Preserve trans. callbacks  */
 
930
/*  Paint Mode, Opacity and Lock alpha callbacks  */
908
931
 
909
932
#define BLOCK() \
910
933
        g_signal_handlers_block_by_func (layer, \
919
942
gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget         *widget,
920
943
                                               GimpLayerTreeView *view)
921
944
{
922
 
  GimpImage *gimage;
923
 
  GimpLayer *layer;
924
 
 
925
 
  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
926
 
 
927
 
  layer = (GimpLayer *)
928
 
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
 
945
  GimpImage *image;
 
946
  GimpLayer *layer = NULL;
 
947
 
 
948
  image = GIMP_ITEM_TREE_VIEW (view)->image;
 
949
 
 
950
  if (image)
 
951
    layer = (GimpLayer *)
 
952
      GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
929
953
 
930
954
  if (layer)
931
955
    {
932
 
      GimpLayerModeEffects mode =
933
 
        GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
934
 
                                            "gimp-item-data"));
 
956
      gint mode;
935
957
 
936
 
      if (gimp_layer_get_mode (layer) != mode)
 
958
      if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget),
 
959
                                         &mode) &&
 
960
          gimp_layer_get_mode (layer) != (GimpLayerModeEffects) mode)
937
961
        {
938
962
          GimpUndo *undo;
939
963
          gboolean  push_undo = TRUE;
940
964
 
941
965
          /*  compress layer mode undos  */
942
 
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
966
          undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
943
967
                                               GIMP_UNDO_LAYER_MODE);
944
968
 
945
969
          if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
946
970
            push_undo = FALSE;
947
971
 
948
972
          BLOCK();
949
 
          gimp_layer_set_mode (layer, mode, push_undo);
 
973
          gimp_layer_set_mode (layer, (GimpLayerModeEffects) mode, push_undo);
950
974
          UNBLOCK();
951
975
 
952
 
          gimp_image_flush (gimage);
 
976
          gimp_image_flush (image);
953
977
 
954
 
          if (!push_undo)
955
 
            gimp_undo_refresh_preview (undo);
 
978
          if (! push_undo)
 
979
            gimp_undo_refresh_preview (undo, gimp_container_view_get_context (GIMP_CONTAINER_VIEW (view)));
956
980
        }
957
981
    }
958
982
}
959
983
 
960
984
static void
961
 
gimp_layer_tree_view_preserve_button_toggled (GtkWidget         *widget,
962
 
                                              GimpLayerTreeView *view)
 
985
gimp_layer_tree_view_lock_alpha_button_toggled (GtkWidget         *widget,
 
986
                                                GimpLayerTreeView *view)
963
987
{
964
 
  GimpImage *gimage;
 
988
  GimpImage *image;
965
989
  GimpLayer *layer;
966
990
 
967
 
  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
 
991
  image = GIMP_ITEM_TREE_VIEW (view)->image;
968
992
 
969
993
  layer = (GimpLayer *)
970
 
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
 
994
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
971
995
 
972
996
  if (layer)
973
997
    {
974
 
      gboolean preserve_trans;
975
 
 
976
 
      preserve_trans = GTK_TOGGLE_BUTTON (widget)->active;
977
 
 
978
 
      if (gimp_layer_get_preserve_trans (layer) != preserve_trans)
 
998
      gboolean lock_alpha;
 
999
 
 
1000
      lock_alpha = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
 
1001
 
 
1002
      if (gimp_layer_get_lock_alpha (layer) != lock_alpha)
979
1003
        {
980
1004
          GimpUndo *undo;
981
1005
          gboolean  push_undo = TRUE;
982
1006
 
983
1007
          /*  compress opacity undos  */
984
 
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
985
 
                                               GIMP_UNDO_LAYER_PRESERVE_TRANS);
 
1008
          undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
 
1009
                                               GIMP_UNDO_LAYER_LOCK_ALPHA);
986
1010
 
987
1011
          if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
988
1012
            push_undo = FALSE;
989
1013
 
990
1014
          BLOCK();
991
 
          gimp_layer_set_preserve_trans (layer, preserve_trans, push_undo);
 
1015
          gimp_layer_set_lock_alpha (layer, lock_alpha, push_undo);
992
1016
          UNBLOCK();
993
1017
 
994
 
          gimp_image_flush (gimage);
 
1018
          gimp_image_flush (image);
995
1019
        }
996
1020
    }
997
1021
}
1000
1024
gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment     *adjustment,
1001
1025
                                            GimpLayerTreeView *view)
1002
1026
{
1003
 
  GimpImage *gimage;
 
1027
  GimpImage *image;
1004
1028
  GimpLayer *layer;
1005
1029
 
1006
 
  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
 
1030
  image = GIMP_ITEM_TREE_VIEW (view)->image;
1007
1031
 
1008
1032
  layer = (GimpLayer *)
1009
 
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
 
1033
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
1010
1034
 
1011
1035
  if (layer)
1012
1036
    {
1018
1042
          gboolean  push_undo = TRUE;
1019
1043
 
1020
1044
          /*  compress opacity undos  */
1021
 
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
1045
          undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
1022
1046
                                               GIMP_UNDO_LAYER_OPACITY);
1023
1047
 
1024
1048
          if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
1028
1052
          gimp_layer_set_opacity (layer, opacity, push_undo);
1029
1053
          UNBLOCK();
1030
1054
 
1031
 
          gimp_image_flush (gimage);
 
1055
          gimp_image_flush (image);
1032
1056
 
1033
 
          if (!push_undo)
1034
 
            gimp_undo_refresh_preview (undo);
 
1057
          if (! push_undo)
 
1058
            gimp_undo_refresh_preview (undo, gimp_container_view_get_context (GIMP_CONTAINER_VIEW (view)));
1035
1059
        }
1036
1060
    }
1037
1061
}
1048
1072
  GimpLayer        *active_layer;
1049
1073
 
1050
1074
  active_layer = (GimpLayer *)
1051
 
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (item_view->gimage);
 
1075
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (item_view->image);
1052
1076
 
1053
1077
  if (active_layer == layer)
1054
1078
    gimp_layer_tree_view_update_options (view, layer);
1065
1089
gimp_layer_tree_view_update_options (GimpLayerTreeView *view,
1066
1090
                                     GimpLayer         *layer)
1067
1091
{
1068
 
  gimp_paint_mode_menu_set_history (GTK_OPTION_MENU (view->paint_mode_menu),
1069
 
                                    layer->mode);
1070
 
 
1071
 
  if (layer->preserve_trans !=
1072
 
      GTK_TOGGLE_BUTTON (view->preserve_trans_toggle)->active)
 
1092
  BLOCK (view->paint_mode_menu,
 
1093
         gimp_layer_tree_view_paint_mode_menu_callback);
 
1094
 
 
1095
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (view->paint_mode_menu),
 
1096
                                 layer->mode);
 
1097
 
 
1098
  UNBLOCK (view->paint_mode_menu,
 
1099
           gimp_layer_tree_view_paint_mode_menu_callback);
 
1100
 
 
1101
  if (layer->lock_alpha !=
 
1102
      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view->lock_alpha_toggle)))
1073
1103
    {
1074
 
      BLOCK (view->preserve_trans_toggle,
1075
 
             gimp_layer_tree_view_preserve_button_toggled);
1076
 
 
1077
 
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->preserve_trans_toggle),
1078
 
                                    layer->preserve_trans);
1079
 
 
1080
 
      UNBLOCK (view->preserve_trans_toggle,
1081
 
               gimp_layer_tree_view_preserve_button_toggled);
 
1104
      BLOCK (view->lock_alpha_toggle,
 
1105
             gimp_layer_tree_view_lock_alpha_button_toggled);
 
1106
 
 
1107
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->lock_alpha_toggle),
 
1108
                                    layer->lock_alpha);
 
1109
 
 
1110
      UNBLOCK (view->lock_alpha_toggle,
 
1111
               gimp_layer_tree_view_lock_alpha_button_toggled);
1082
1112
    }
1083
1113
 
1084
1114
  if (layer->opacity * 100.0 != view->opacity_adjustment->value)
1140
1170
  if (mask)
1141
1171
    {
1142
1172
      GClosure *closure;
1143
 
      gint      preview_size;
 
1173
      gint      view_size;
1144
1174
      gint      border_width;
1145
1175
 
1146
 
      preview_size = gimp_container_view_get_preview_size (view, &border_width);
 
1176
      view_size = gimp_container_view_get_view_size (view, &border_width);
1147
1177
 
1148
1178
      mask_visible = TRUE;
1149
1179
 
1150
 
      renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (mask),
1151
 
                                         preview_size, border_width,
 
1180
      renderer = gimp_view_renderer_new (gimp_container_view_get_context (view),
 
1181
                                         G_TYPE_FROM_INSTANCE (mask),
 
1182
                                         view_size, border_width,
1152
1183
                                         FALSE);
1153
1184
      gimp_view_renderer_set_viewable (renderer, GIMP_VIEWABLE (mask));
1154
1185
 
1159
1190
      closure = g_cclosure_new (G_CALLBACK (gimp_layer_tree_view_mask_callback),
1160
1191
                                layer_view, NULL);
1161
1192
      g_object_watch_closure (G_OBJECT (renderer), closure);
1162
 
      g_signal_connect_closure (mask, "apply_changed", closure, FALSE);
1163
 
      g_signal_connect_closure (mask, "edit_changed",  closure, FALSE);
1164
 
      g_signal_connect_closure (mask, "show_changed",  closure, FALSE);
 
1193
      g_signal_connect_closure (mask, "apply-changed", closure, FALSE);
 
1194
      g_signal_connect_closure (mask, "edit-changed",  closure, FALSE);
 
1195
      g_signal_connect_closure (mask, "show-changed",  closure, FALSE);
1165
1196
    }
1166
1197
 
1167
1198
  gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
1397
1428
      gimp_layer_tree_view_alpha_update (layer_view, iter, layer);
1398
1429
 
1399
1430
      /*  update button states  */
1400
 
      if (gimp_image_get_active_layer (item_view->gimage) == layer)
 
1431
      if (gimp_image_get_active_layer (item_view->image) == layer)
1401
1432
        gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view),
1402
1433
                                         GIMP_VIEWABLE (layer));
1403
1434
    }