← Back to branch summary

~ubuntu-branches/ubuntu/maverick/gimp/maverick-updates

« back to all changes in this revision

Viewing changes to app/widgets/gimplayertreeview.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-12-09 19:44:52 UTC
  • Revision ID: james.westby@ubuntu.com-20051209194452-yggpemjlofpjqyf4
Tags: upstream-2.2.9
Import upstream version 2.2.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/widgets/gimplayertreeview.c
 
1
/* The GIMP -- an image manipulation program
 
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 
3
 *
 
4
 * gimplayertreeview.c
 
5
 * Copyright (C) 2001-2003 Michael Natterer <mitch@gimp.org>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License as published by
 
9
 * the Free Software Foundation; either version 2 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
20
 */
 
21
 
 
22
#include "config.h"
 
23
 
 
24
#include <string.h>
 
25
 
 
26
#include <gtk/gtk.h>
 
27
 
 
28
#include "libgimpcolor/gimpcolor.h"
 
29
#include "libgimpmath/gimpmath.h"
 
30
#include "libgimpwidgets/gimpwidgets.h"
 
31
 
 
32
#include "widgets-types.h"
 
33
 
 
34
#include "core/gimpcontainer.h"
 
35
#include "core/gimpdrawable-bucket-fill.h"
 
36
#include "core/gimplayer.h"
 
37
#include "core/gimplayermask.h"
 
38
#include "core/gimplayer-floating-sel.h"
 
39
#include "core/gimplist.h"
 
40
#include "core/gimpimage.h"
 
41
#include "core/gimpimage-undo.h"
 
42
#include "core/gimpitemundo.h"
 
43
#include "core/gimppattern.h"
 
44
 
 
45
#include "text/gimptextlayer.h"
 
46
 
 
47
#include "file/file-open.h"
 
48
#include "file/file-utils.h"
 
49
 
 
50
#include "gimpactiongroup.h"
 
51
#include "gimpcellrendererviewable.h"
 
52
#include "gimpcontainerview.h"
 
53
#include "gimpdnd.h"
 
54
#include "gimphelp-ids.h"
 
55
#include "gimplayertreeview.h"
 
56
#include "gimpviewrenderer.h"
 
57
#include "gimpuimanager.h"
 
58
#include "gimpwidgets-constructors.h"
 
59
 
 
60
#include "gimp-intl.h"
 
61
 
 
62
 
 
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);
 
67
 
 
68
static GObject * gimp_layer_tree_view_constructor (GType                type,
 
69
                                                   guint                n_params,
 
70
                                                   GObjectConstructParam *params);
 
71
static void   gimp_layer_tree_view_finalize       (GObject             *object);
 
72
 
 
73
static void   gimp_layer_tree_view_unrealize      (GtkWidget           *widget);
 
74
static void   gimp_layer_tree_view_style_set      (GtkWidget           *widget,
 
75
                                                   GtkStyle            *prev_style);
 
76
 
 
77
static void   gimp_layer_tree_view_set_container  (GimpContainerView   *view,
 
78
                                                   GimpContainer       *container);
 
79
static gpointer gimp_layer_tree_view_insert_item  (GimpContainerView   *view,
 
80
                                                   GimpViewable        *viewable,
 
81
                                                   gint                 index);
 
82
static gboolean gimp_layer_tree_view_select_item  (GimpContainerView   *view,
 
83
                                                   GimpViewable        *item,
 
84
                                                   gpointer             insert_data);
 
85
static void gimp_layer_tree_view_set_preview_size (GimpContainerView   *view);
 
86
 
 
87
static gboolean gimp_layer_tree_view_drop_possible(GimpContainerTreeView *view,
 
88
                                                   GimpDndType          src_type,
 
89
                                                   GimpViewable        *src_viewable,
 
90
                                                   GimpViewable        *dest_viewable,
 
91
                                                   GtkTreeViewDropPosition  drop_pos,
 
92
                                                   GtkTreeViewDropPosition *return_drop_pos,
 
93
                                                   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
static void    gimp_layer_tree_view_drop_color    (GimpContainerTreeView *view,
 
99
                                                   const GimpRGB       *color,
 
100
                                                   GimpViewable        *dest_viewable,
 
101
                                                   GtkTreeViewDropPosition  drop_pos);
 
102
static void    gimp_layer_tree_view_drop_uri_list (GimpContainerTreeView *view,
 
103
                                                   GList               *uri_list,
 
104
                                                   GimpViewable        *dest_viewable,
 
105
                                                   GtkTreeViewDropPosition  drop_pos);
 
106
 
 
107
static void   gimp_layer_tree_view_set_image      (GimpItemTreeView    *view,
 
108
                                                   GimpImage           *gimage);
 
109
static GimpItem * gimp_layer_tree_view_item_new   (GimpImage           *image);
 
110
 
 
111
static void   gimp_layer_tree_view_floating_selection_changed
 
112
                                                  (GimpImage           *gimage,
 
113
                                                   GimpLayerTreeView   *view);
 
114
 
 
115
static void   gimp_layer_tree_view_paint_mode_menu_callback
 
116
                                                  (GtkWidget           *widget,
 
117
                                                   GimpLayerTreeView   *view);
 
118
static void   gimp_layer_tree_view_preserve_button_toggled
 
119
                                                  (GtkWidget           *widget,
 
120
                                                   GimpLayerTreeView   *view);
 
121
static void   gimp_layer_tree_view_opacity_scale_changed
 
122
                                                  (GtkAdjustment       *adj,
 
123
                                                   GimpLayerTreeView   *view);
 
124
 
 
125
static void   gimp_layer_tree_view_layer_signal_handler
 
126
                                                  (GimpLayer           *layer,
 
127
                                                   GimpLayerTreeView   *view);
 
128
static void   gimp_layer_tree_view_update_options (GimpLayerTreeView   *view,
 
129
                                                   GimpLayer           *layer);
 
130
static void   gimp_layer_tree_view_update_menu    (GimpLayerTreeView   *view,
 
131
                                                   GimpLayer           *layer);
 
132
 
 
133
static void   gimp_layer_tree_view_mask_update    (GimpLayerTreeView   *view,
 
134
                                                   GtkTreeIter         *iter,
 
135
                                                   GimpLayer           *layer);
 
136
static void   gimp_layer_tree_view_mask_changed   (GimpLayer           *layer,
 
137
                                                   GimpLayerTreeView   *view);
 
138
static void   gimp_layer_tree_view_renderer_update(GimpViewRenderer    *renderer,
 
139
                                                   GimpLayerTreeView   *view);
 
140
 
 
141
static void   gimp_layer_tree_view_update_borders (GimpLayerTreeView   *view,
 
142
                                                   GtkTreeIter         *iter);
 
143
static void   gimp_layer_tree_view_mask_callback  (GimpLayerMask       *mask,
 
144
                                                   GimpLayerTreeView   *view);
 
145
static void   gimp_layer_tree_view_layer_clicked  (GimpCellRendererViewable *cell,
 
146
                                                   const gchar         *path,
 
147
                                                   GdkModifierType      state,
 
148
                                                   GimpLayerTreeView   *view);
 
149
static void   gimp_layer_tree_view_mask_clicked   (GimpCellRendererViewable *cell,
 
150
                                                   const gchar         *path,
 
151
                                                   GdkModifierType      state,
 
152
                                                   GimpLayerTreeView   *view);
 
153
 
 
154
static void   gimp_layer_tree_view_alpha_update   (GimpLayerTreeView   *view,
 
155
                                                   GtkTreeIter         *iter,
 
156
                                                   GimpLayer           *layer);
 
157
static void   gimp_layer_tree_view_alpha_changed  (GimpLayer           *layer,
 
158
                                                   GimpLayerTreeView   *view);
 
159
 
 
160
 
 
161
static GimpDrawableTreeViewClass  *parent_class      = NULL;
 
162
static GimpContainerViewInterface *parent_view_iface = NULL;
 
163
 
 
164
 
 
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
static void
 
204
gimp_layer_tree_view_class_init (GimpLayerTreeViewClass *klass)
 
205
{
 
206
  GObjectClass               *object_class;
 
207
  GtkWidgetClass             *widget_class;
 
208
  GimpContainerTreeViewClass *tree_view_class;
 
209
  GimpItemTreeViewClass      *item_view_class;
 
210
 
 
211
  object_class    = G_OBJECT_CLASS (klass);
 
212
  widget_class    = GTK_WIDGET_CLASS (klass);
 
213
  tree_view_class = GIMP_CONTAINER_TREE_VIEW_CLASS (klass);
 
214
  item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
 
215
 
 
216
  parent_class = g_type_class_peek_parent (klass);
 
217
 
 
218
  object_class->constructor = gimp_layer_tree_view_constructor;
 
219
  object_class->finalize    = gimp_layer_tree_view_finalize;
 
220
 
 
221
  widget_class->unrealize   = gimp_layer_tree_view_unrealize;
 
222
  widget_class->style_set   = gimp_layer_tree_view_style_set;
 
223
 
 
224
  tree_view_class->drop_possible   = gimp_layer_tree_view_drop_possible;
 
225
  tree_view_class->drop_viewable   = gimp_layer_tree_view_drop_viewable;
 
226
  tree_view_class->drop_color      = gimp_layer_tree_view_drop_color;
 
227
  tree_view_class->drop_uri_list   = gimp_layer_tree_view_drop_uri_list;
 
228
 
 
229
  item_view_class->item_type       = GIMP_TYPE_LAYER;
 
230
  item_view_class->signal_name     = "active-layer-changed";
 
231
 
 
232
  item_view_class->set_image       = gimp_layer_tree_view_set_image;
 
233
  item_view_class->get_container   = gimp_image_get_layers;
 
234
  item_view_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_layer;
 
235
  item_view_class->set_active_item = (GimpSetItemFunc) gimp_image_set_active_layer;
 
236
  item_view_class->reorder_item    = (GimpReorderItemFunc) gimp_image_position_layer;
 
237
  item_view_class->add_item        = (GimpAddItemFunc) gimp_image_add_layer;
 
238
  item_view_class->remove_item     = (GimpRemoveItemFunc) gimp_image_remove_layer;
 
239
  item_view_class->new_item        = gimp_layer_tree_view_item_new;
 
240
 
 
241
  item_view_class->action_group        = "layers";
 
242
  item_view_class->activate_action     = "layers-text-tool";
 
243
  item_view_class->edit_action         = "layers-edit-attributes";
 
244
  item_view_class->new_action          = "layers-new";
 
245
  item_view_class->new_default_action  = "layers-new-last-values";
 
246
  item_view_class->raise_action        = "layers-raise";
 
247
  item_view_class->raise_top_action    = "layers-raise-to-top";
 
248
  item_view_class->lower_action        = "layers-lower";
 
249
  item_view_class->lower_bottom_action = "layers-lower-to-bottom";
 
250
  item_view_class->duplicate_action    = "layers-duplicate";
 
251
  item_view_class->delete_action       = "layers-delete";
 
252
  item_view_class->reorder_desc        = _("Reorder Layer");
 
253
}
 
254
 
 
255
static void
 
256
gimp_layer_tree_view_init (GimpLayerTreeView *view)
 
257
{
 
258
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
 
259
  GtkWidget             *hbox;
 
260
  GtkWidget             *toggle;
 
261
  GtkWidget             *image;
 
262
  GtkIconSize            icon_size;
 
263
  PangoAttribute        *attr;
 
264
 
 
265
  /* The following used to read:
 
266
   *
 
267
   * tree_view->model_columns[tree_view->n_model_columns++] = ...
 
268
   *
 
269
   * but combining the two lead to gcc miscompiling the function on ppc/ia64
 
270
   * (model_column_mask and model_column_mask_visible would have the same
 
271
   * value, probably due to bad instruction reordering). See bug #113144 for
 
272
   * more info.
 
273
   */
 
274
  view->model_column_mask = tree_view->n_model_columns;
 
275
  tree_view->model_columns[tree_view->n_model_columns] = GIMP_TYPE_VIEW_RENDERER;
 
276
  tree_view->n_model_columns++;
 
277
 
 
278
  view->model_column_mask_visible = tree_view->n_model_columns;
 
279
  tree_view->model_columns[tree_view->n_model_columns] = G_TYPE_BOOLEAN;
 
280
  tree_view->n_model_columns++;
 
281
 
 
282
  view->options_box = gtk_table_new (2, 3, FALSE);
 
283
  gtk_table_set_col_spacings (GTK_TABLE (view->options_box), 2);
 
284
  gtk_box_pack_start (GTK_BOX (view), view->options_box, FALSE, FALSE, 0);
 
285
  gtk_box_reorder_child (GTK_BOX (view), view->options_box, 0);
 
286
  gtk_widget_show (view->options_box);
 
287
 
 
288
  hbox = gtk_hbox_new (FALSE, 6);
 
289
 
 
290
  /*  Paint mode menu  */
 
291
 
 
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);
 
299
 
 
300
  gimp_help_set_help_data (view->paint_mode_menu, NULL,
 
301
                           GIMP_HELP_LAYER_DIALOG_PAINT_MODE_MENU);
 
302
 
 
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
  /*  Opacity scale  */
 
329
 
 
330
  view->opacity_adjustment =
 
331
    GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (view->options_box), 0, 1,
 
332
                                          _("Opacity:"), -1, -1,
 
333
                                          100.0, 0.0, 100.0, 1.0, 10.0, 1,
 
334
                                          TRUE, 0.0, 0.0,
 
335
                                          NULL,
 
336
                                          GIMP_HELP_LAYER_DIALOG_OPACITY_SCALE));
 
337
 
 
338
  g_signal_connect (view->opacity_adjustment, "value_changed",
 
339
                    G_CALLBACK (gimp_layer_tree_view_opacity_scale_changed),
 
340
                    view);
 
341
 
 
342
  gtk_widget_set_sensitive (view->options_box, FALSE);
 
343
 
 
344
  view->italic_attrs = pango_attr_list_new ();
 
345
  attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
 
346
  attr->start_index = 0;
 
347
  attr->end_index   = -1;
 
348
  pango_attr_list_insert (view->italic_attrs, attr);
 
349
 
 
350
  view->bold_attrs = pango_attr_list_new ();
 
351
  attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
 
352
  attr->start_index = 0;
 
353
  attr->end_index   = -1;
 
354
  pango_attr_list_insert (view->bold_attrs, attr);
 
355
 
 
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;
 
371
}
 
372
 
 
373
static GObject *
 
374
gimp_layer_tree_view_constructor (GType                  type,
 
375
                                  guint                  n_params,
 
376
                                  GObjectConstructParam *params)
 
377
{
 
378
  GimpContainerTreeView *tree_view;
 
379
  GimpLayerTreeView     *layer_view;
 
380
  GObject               *object;
 
381
 
 
382
  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
 
383
 
 
384
  tree_view  = GIMP_CONTAINER_TREE_VIEW (object);
 
385
  layer_view = GIMP_LAYER_TREE_VIEW (object);
 
386
 
 
387
  layer_view->mask_cell = gimp_cell_renderer_viewable_new ();
 
388
  gtk_tree_view_column_pack_start (tree_view->main_column,
 
389
                                   layer_view->mask_cell,
 
390
                                   FALSE);
 
391
  gtk_tree_view_column_set_attributes (tree_view->main_column,
 
392
                                       layer_view->mask_cell,
 
393
                                       "renderer",
 
394
                                       layer_view->model_column_mask,
 
395
                                       "visible",
 
396
                                       layer_view->model_column_mask_visible,
 
397
                                       NULL);
 
398
 
 
399
  tree_view->renderer_cells = g_list_prepend (tree_view->renderer_cells,
 
400
                                              layer_view->mask_cell);
 
401
 
 
402
  g_signal_connect (tree_view->renderer_cell, "clicked",
 
403
                    G_CALLBACK (gimp_layer_tree_view_layer_clicked),
 
404
                    layer_view);
 
405
  g_signal_connect (layer_view->mask_cell, "clicked",
 
406
                    G_CALLBACK (gimp_layer_tree_view_mask_clicked),
 
407
                    layer_view);
 
408
 
 
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);
 
415
 
 
416
  /*  hide basically useless edit button  */
 
417
  gtk_widget_hide (GIMP_ITEM_TREE_VIEW (layer_view)->edit_button);
 
418
 
 
419
  layer_view->anchor_button =
 
420
    gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
 
421
                                   "layers-anchor", NULL);
 
422
  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
 
423
                                  GTK_BUTTON (layer_view->anchor_button),
 
424
                                  GIMP_TYPE_LAYER);
 
425
  gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (layer_view)->button_box),
 
426
                         layer_view->anchor_button, 5);
 
427
 
 
428
 
 
429
  return object;
 
430
}
 
431
 
 
432
static void
 
433
gimp_layer_tree_view_finalize (GObject *object)
 
434
{
 
435
  GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (object);
 
436
 
 
437
  if (layer_view->italic_attrs)
 
438
    {
 
439
      pango_attr_list_unref (layer_view->italic_attrs);
 
440
      layer_view->italic_attrs = NULL;
 
441
    }
 
442
 
 
443
  if (layer_view->bold_attrs)
 
444
    {
 
445
      pango_attr_list_unref (layer_view->bold_attrs);
 
446
      layer_view->bold_attrs = NULL;
 
447
    }
 
448
 
 
449
  G_OBJECT_CLASS (parent_class)->finalize (object);
 
450
}
 
451
 
 
452
static void
 
453
gimp_layer_tree_view_unrealize (GtkWidget *widget)
 
454
{
 
455
  GimpContainerTreeView *tree_view  = GIMP_CONTAINER_TREE_VIEW (widget);
 
456
  GimpLayerTreeView     *layer_view = GIMP_LAYER_TREE_VIEW (widget);
 
457
  GtkTreeIter            iter;
 
458
  gboolean               iter_valid;
 
459
 
 
460
  for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model, &iter);
 
461
       iter_valid;
 
462
       iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter))
 
463
    {
 
464
      GimpViewRenderer *renderer;
 
465
 
 
466
      gtk_tree_model_get (tree_view->model, &iter,
 
467
                          layer_view->model_column_mask, &renderer,
 
468
                          -1);
 
469
 
 
470
      if (renderer)
 
471
        {
 
472
          gimp_view_renderer_unrealize (renderer);
 
473
          g_object_unref (renderer);
 
474
        }
 
475
    }
 
476
 
 
477
  GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 
478
}
 
479
 
 
480
static void
 
481
gimp_layer_tree_view_style_set (GtkWidget *widget,
 
482
                                GtkStyle  *prev_style)
 
483
{
 
484
  GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (widget);
 
485
  gint               content_spacing;
 
486
  gint               button_spacing;
 
487
 
 
488
  gtk_widget_style_get (widget,
 
489
                        "content_spacing", &content_spacing,
 
490
                        "button_spacing",  &button_spacing,
 
491
                        NULL);
 
492
 
 
493
  gtk_table_set_col_spacings (GTK_TABLE (layer_view->options_box),
 
494
                              button_spacing);
 
495
  gtk_table_set_row_spacings (GTK_TABLE (layer_view->options_box),
 
496
                              content_spacing);
 
497
 
 
498
  if (GTK_WIDGET_CLASS (parent_class)->style_set)
 
499
    GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
 
500
}
 
501
 
 
502
 
 
503
/*  GimpContainerView methods  */
 
504
 
 
505
static void
 
506
gimp_layer_tree_view_set_container (GimpContainerView *view,
 
507
                                    GimpContainer     *container)
 
508
{
 
509
  GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
 
510
  GimpContainer     *old_container;
 
511
 
 
512
  old_container = gimp_container_view_get_container (view);
 
513
 
 
514
  if (old_container)
 
515
    {
 
516
      gimp_container_remove_handler (old_container,
 
517
                                     layer_view->mode_changed_handler_id);
 
518
      gimp_container_remove_handler (old_container,
 
519
                                     layer_view->opacity_changed_handler_id);
 
520
      gimp_container_remove_handler (old_container,
 
521
                                     layer_view->preserve_trans_changed_handler_id);
 
522
      gimp_container_remove_handler (old_container,
 
523
                                     layer_view->mask_changed_handler_id);
 
524
      gimp_container_remove_handler (old_container,
 
525
                                     layer_view->alpha_changed_handler_id);
 
526
    }
 
527
 
 
528
  parent_view_iface->set_container (view, container);
 
529
 
 
530
  if (container)
 
531
    {
 
532
      layer_view->mode_changed_handler_id =
 
533
        gimp_container_add_handler (container, "mode_changed",
 
534
                                    G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
 
535
                                    view);
 
536
      layer_view->opacity_changed_handler_id =
 
537
        gimp_container_add_handler (container, "opacity_changed",
 
538
                                    G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
 
539
                                    view);
 
540
      layer_view->preserve_trans_changed_handler_id =
 
541
        gimp_container_add_handler (container, "preserve_trans_changed",
 
542
                                    G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
 
543
                                    view);
 
544
      layer_view->mask_changed_handler_id =
 
545
        gimp_container_add_handler (container, "mask_changed",
 
546
                                    G_CALLBACK (gimp_layer_tree_view_mask_changed),
 
547
                                    view);
 
548
      layer_view->alpha_changed_handler_id =
 
549
        gimp_container_add_handler (container, "alpha_changed",
 
550
                                    G_CALLBACK (gimp_layer_tree_view_alpha_changed),
 
551
                                    view);
 
552
    }
 
553
}
 
554
 
 
555
static gpointer
 
556
gimp_layer_tree_view_insert_item (GimpContainerView *view,
 
557
                                  GimpViewable      *viewable,
 
558
                                  gint               index)
 
559
{
 
560
  GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
 
561
  GimpLayer         *layer;
 
562
  GtkTreeIter       *iter;
 
563
 
 
564
  iter = parent_view_iface->insert_item (view, viewable, index);
 
565
 
 
566
  layer = GIMP_LAYER (viewable);
 
567
 
 
568
  if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
 
569
    gimp_layer_tree_view_alpha_update (layer_view, iter, layer);
 
570
 
 
571
  gimp_layer_tree_view_mask_update (layer_view, iter, layer);
 
572
 
 
573
  return iter;
 
574
}
 
575
 
 
576
static gboolean
 
577
gimp_layer_tree_view_select_item (GimpContainerView *view,
 
578
                                  GimpViewable      *item,
 
579
                                  gpointer           insert_data)
 
580
{
 
581
  GimpItemTreeView  *item_view         = GIMP_ITEM_TREE_VIEW (view);
 
582
  GimpLayerTreeView *layer_view        = GIMP_LAYER_TREE_VIEW (view);
 
583
  gboolean           options_sensitive = FALSE;
 
584
  gboolean           success;
 
585
 
 
586
  success = parent_view_iface->select_item (view, item, insert_data);
 
587
 
 
588
  if (item)
 
589
    {
 
590
      if (success)
 
591
        {
 
592
          gimp_layer_tree_view_update_borders (layer_view,
 
593
                                               (GtkTreeIter *) insert_data);
 
594
          gimp_layer_tree_view_update_options (layer_view, GIMP_LAYER (item));
 
595
          gimp_layer_tree_view_update_menu (layer_view, GIMP_LAYER (item));
 
596
        }
 
597
 
 
598
      options_sensitive = TRUE;
 
599
 
 
600
      if (! success || gimp_layer_is_floating_sel (GIMP_LAYER (item)))
 
601
        {
 
602
          gtk_widget_set_sensitive (item_view->edit_button,  FALSE);
 
603
        }
 
604
    }
 
605
 
 
606
  gtk_widget_set_sensitive (layer_view->options_box, options_sensitive);
 
607
 
 
608
  return success;
 
609
}
 
610
 
 
611
static void
 
612
gimp_layer_tree_view_set_preview_size (GimpContainerView *view)
 
613
{
 
614
  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))
 
626
    {
 
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)
 
634
        {
 
635
          gimp_view_renderer_set_size (renderer, preview_size, border_width);
 
636
          g_object_unref (renderer);
 
637
        }
 
638
    }
 
639
 
 
640
  parent_view_iface->set_preview_size (view);
 
641
}
 
642
 
 
643
 
 
644
/*  GimpContainerTreeView methods  */
 
645
 
 
646
static gboolean
 
647
gimp_layer_tree_view_drop_possible (GimpContainerTreeView   *tree_view,
 
648
                                    GimpDndType              src_type,
 
649
                                    GimpViewable            *src_viewable,
 
650
                                    GimpViewable            *dest_viewable,
 
651
                                    GtkTreeViewDropPosition  drop_pos,
 
652
                                    GtkTreeViewDropPosition *return_drop_pos,
 
653
                                    GdkDragAction           *return_drag_action)
 
654
{
 
655
  if  (src_type == GIMP_DND_TYPE_URI_LIST     ||
 
656
       src_type == GIMP_DND_TYPE_TEXT_PLAIN   ||
 
657
       src_type == GIMP_DND_TYPE_NETSCAPE_URL ||
 
658
       GIMP_IS_LAYER (src_viewable))
 
659
    {
 
660
      GimpLayer *dest_layer = GIMP_LAYER (dest_viewable);
 
661
      GimpImage *dest_image = gimp_item_get_image (GIMP_ITEM (dest_layer));
 
662
 
 
663
      if (gimp_image_floating_sel (dest_image))
 
664
        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);
 
728
}
 
729
 
 
730
static void
 
731
gimp_layer_tree_view_drop_color (GimpContainerTreeView   *view,
 
732
                                 const GimpRGB           *color,
 
733
                                 GimpViewable            *dest_viewable,
 
734
                                 GtkTreeViewDropPosition  drop_pos)
 
735
{
 
736
  if (gimp_drawable_is_text_layer (GIMP_DRAWABLE (dest_viewable)))
 
737
    {
 
738
      gimp_text_layer_set (GIMP_TEXT_LAYER (dest_viewable), NULL,
 
739
                           "color", color,
 
740
                           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);
 
751
    }
 
752
 
 
753
  gimp_image_flush (GIMP_ITEM_TREE_VIEW (view)->gimage);
 
754
}
 
755
 
 
756
static void
 
757
gimp_layer_tree_view_drop_uri_list (GimpContainerTreeView   *view,
 
758
                                    GList                   *uri_list,
 
759
                                    GimpViewable            *dest_viewable,
 
760
                                    GtkTreeViewDropPosition  drop_pos)
 
761
{
 
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++;
 
771
 
 
772
  for (list = uri_list; list; list = g_list_next (list))
 
773
    {
 
774
      const gchar       *uri   = list->data;
 
775
      GimpLayer         *new_layer;
 
776
      GimpPDBStatusType  status;
 
777
      GError            *error = NULL;
 
778
 
 
779
      new_layer = file_open_layer (gimage->gimp, item_view->context, NULL,
 
780
                                   gimage, uri, &status, &error);
 
781
 
 
782
      if (new_layer)
 
783
        {
 
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++);
 
799
        }
 
800
      else if (status != GIMP_PDB_CANCEL)
 
801
        {
 
802
          gchar *filename = file_utils_uri_to_utf8_filename (uri);
 
803
 
 
804
          g_message (_("Opening '%s' failed:\n\n%s"),
 
805
                     filename, error->message);
 
806
 
 
807
          g_clear_error (&error);
 
808
          g_free (filename);
 
809
        }
 
810
    }
 
811
 
 
812
  gimp_image_flush (gimage);
 
813
}
 
814
 
 
815
 
 
816
/*  GimpItemTreeView methods  */
 
817
 
 
818
static void
 
819
gimp_layer_tree_view_set_image (GimpItemTreeView *view,
 
820
                                GimpImage        *gimage)
 
821
{
 
822
  if (view->gimage)
 
823
    g_signal_handlers_disconnect_by_func (view->gimage,
 
824
                                          gimp_layer_tree_view_floating_selection_changed,
 
825
                                          view);
 
826
 
 
827
  GIMP_ITEM_TREE_VIEW_CLASS (parent_class)->set_image (view, gimage);
 
828
 
 
829
  if (view->gimage)
 
830
    g_signal_connect (view->gimage,
 
831
                      "floating_selection_changed",
 
832
                      G_CALLBACK (gimp_layer_tree_view_floating_selection_changed),
 
833
                      view);
 
834
}
 
835
 
 
836
static GimpItem *
 
837
gimp_layer_tree_view_item_new (GimpImage *image)
 
838
{
 
839
  GimpLayer *new_layer;
 
840
 
 
841
  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
 
842
                               _("New Layer"));
 
843
 
 
844
  new_layer = gimp_layer_new (image,
 
845
                              gimp_image_get_width (image),
 
846
                              gimp_image_get_height (image),
 
847
                              gimp_image_base_type_with_alpha (image),
 
848
                              _("Empty Layer"), 1.0, GIMP_NORMAL_MODE);
 
849
 
 
850
  gimp_image_add_layer (image, new_layer, -1);
 
851
 
 
852
  gimp_image_undo_group_end (image);
 
853
 
 
854
  return GIMP_ITEM (new_layer);
 
855
}
 
856
 
 
857
 
 
858
/*  callbacks  */
 
859
 
 
860
static void
 
861
gimp_layer_tree_view_floating_selection_changed (GimpImage         *gimage,
 
862
                                                 GimpLayerTreeView *layer_view)
 
863
{
 
864
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
 
865
  GimpContainerView     *view      = GIMP_CONTAINER_VIEW (layer_view);
 
866
  GimpLayer             *floating_sel;
 
867
  GtkTreeIter           *iter;
 
868
 
 
869
  floating_sel = gimp_image_floating_sel (gimage);
 
870
 
 
871
  if (floating_sel)
 
872
    {
 
873
      iter = gimp_container_view_lookup (view, (GimpViewable *) floating_sel);
 
874
 
 
875
      if (iter)
 
876
        gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
 
877
                            tree_view->model_column_name_attributes,
 
878
                            layer_view->italic_attrs,
 
879
                            -1);
 
880
    }
 
881
  else
 
882
    {
 
883
      GList *list;
 
884
 
 
885
      for (list = GIMP_LIST (gimage->layers)->list;
 
886
           list;
 
887
           list = g_list_next (list))
 
888
        {
 
889
          GimpDrawable *drawable = list->data;
 
890
 
 
891
          if (gimp_drawable_has_alpha (drawable))
 
892
            {
 
893
              iter = gimp_container_view_lookup (view,
 
894
                                                 (GimpViewable *) drawable);
 
895
 
 
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
            }
 
902
        }
 
903
    }
 
904
}
 
905
 
 
906
 
 
907
/*  Paint Mode, Opacity and Preserve trans. callbacks  */
 
908
 
 
909
#define BLOCK() \
 
910
        g_signal_handlers_block_by_func (layer, \
 
911
        gimp_layer_tree_view_layer_signal_handler, view)
 
912
 
 
913
#define UNBLOCK() \
 
914
        g_signal_handlers_unblock_by_func (layer, \
 
915
        gimp_layer_tree_view_layer_signal_handler, view)
 
916
 
 
917
 
 
918
static void
 
919
gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget         *widget,
 
920
                                               GimpLayerTreeView *view)
 
921
{
 
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);
 
929
 
 
930
  if (layer)
 
931
    {
 
932
      GimpLayerModeEffects mode =
 
933
        GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
 
934
                                            "gimp-item-data"));
 
935
 
 
936
      if (gimp_layer_get_mode (layer) != mode)
 
937
        {
 
938
          GimpUndo *undo;
 
939
          gboolean  push_undo = TRUE;
 
940
 
 
941
          /*  compress layer mode undos  */
 
942
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
943
                                               GIMP_UNDO_LAYER_MODE);
 
944
 
 
945
          if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
 
946
            push_undo = FALSE;
 
947
 
 
948
          BLOCK();
 
949
          gimp_layer_set_mode (layer, mode, push_undo);
 
950
          UNBLOCK();
 
951
 
 
952
          gimp_image_flush (gimage);
 
953
 
 
954
          if (!push_undo)
 
955
            gimp_undo_refresh_preview (undo);
 
956
        }
 
957
    }
 
958
}
 
959
 
 
960
static void
 
961
gimp_layer_tree_view_preserve_button_toggled (GtkWidget         *widget,
 
962
                                              GimpLayerTreeView *view)
 
963
{
 
964
  GimpImage *gimage;
 
965
  GimpLayer *layer;
 
966
 
 
967
  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
 
968
 
 
969
  layer = (GimpLayer *)
 
970
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
 
971
 
 
972
  if (layer)
 
973
    {
 
974
      gboolean preserve_trans;
 
975
 
 
976
      preserve_trans = GTK_TOGGLE_BUTTON (widget)->active;
 
977
 
 
978
      if (gimp_layer_get_preserve_trans (layer) != preserve_trans)
 
979
        {
 
980
          GimpUndo *undo;
 
981
          gboolean  push_undo = TRUE;
 
982
 
 
983
          /*  compress opacity undos  */
 
984
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
985
                                               GIMP_UNDO_LAYER_PRESERVE_TRANS);
 
986
 
 
987
          if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
 
988
            push_undo = FALSE;
 
989
 
 
990
          BLOCK();
 
991
          gimp_layer_set_preserve_trans (layer, preserve_trans, push_undo);
 
992
          UNBLOCK();
 
993
 
 
994
          gimp_image_flush (gimage);
 
995
        }
 
996
    }
 
997
}
 
998
 
 
999
static void
 
1000
gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment     *adjustment,
 
1001
                                            GimpLayerTreeView *view)
 
1002
{
 
1003
  GimpImage *gimage;
 
1004
  GimpLayer *layer;
 
1005
 
 
1006
  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
 
1007
 
 
1008
  layer = (GimpLayer *)
 
1009
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
 
1010
 
 
1011
  if (layer)
 
1012
    {
 
1013
      gdouble opacity = adjustment->value / 100.0;
 
1014
 
 
1015
      if (gimp_layer_get_opacity (layer) != opacity)
 
1016
        {
 
1017
          GimpUndo *undo;
 
1018
          gboolean  push_undo = TRUE;
 
1019
 
 
1020
          /*  compress opacity undos  */
 
1021
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
1022
                                               GIMP_UNDO_LAYER_OPACITY);
 
1023
 
 
1024
          if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
 
1025
            push_undo = FALSE;
 
1026
 
 
1027
          BLOCK();
 
1028
          gimp_layer_set_opacity (layer, opacity, push_undo);
 
1029
          UNBLOCK();
 
1030
 
 
1031
          gimp_image_flush (gimage);
 
1032
 
 
1033
          if (!push_undo)
 
1034
            gimp_undo_refresh_preview (undo);
 
1035
        }
 
1036
    }
 
1037
}
 
1038
 
 
1039
#undef BLOCK
 
1040
#undef UNBLOCK
 
1041
 
 
1042
 
 
1043
static void
 
1044
gimp_layer_tree_view_layer_signal_handler (GimpLayer         *layer,
 
1045
                                           GimpLayerTreeView *view)
 
1046
{
 
1047
  GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
 
1048
  GimpLayer        *active_layer;
 
1049
 
 
1050
  active_layer = (GimpLayer *)
 
1051
    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (item_view->gimage);
 
1052
 
 
1053
  if (active_layer == layer)
 
1054
    gimp_layer_tree_view_update_options (view, layer);
 
1055
}
 
1056
 
 
1057
 
 
1058
#define BLOCK(object,function) \
 
1059
        g_signal_handlers_block_by_func ((object), (function), view)
 
1060
 
 
1061
#define UNBLOCK(object,function) \
 
1062
        g_signal_handlers_unblock_by_func ((object), (function), view)
 
1063
 
 
1064
static void
 
1065
gimp_layer_tree_view_update_options (GimpLayerTreeView *view,
 
1066
                                     GimpLayer         *layer)
 
1067
{
 
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)
 
1073
    {
 
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);
 
1082
    }
 
1083
 
 
1084
  if (layer->opacity * 100.0 != view->opacity_adjustment->value)
 
1085
    {
 
1086
      BLOCK (view->opacity_adjustment,
 
1087
             gimp_layer_tree_view_opacity_scale_changed);
 
1088
 
 
1089
      gtk_adjustment_set_value (view->opacity_adjustment,
 
1090
                                layer->opacity * 100.0);
 
1091
 
 
1092
      UNBLOCK (view->opacity_adjustment,
 
1093
               gimp_layer_tree_view_opacity_scale_changed);
 
1094
    }
 
1095
}
 
1096
 
 
1097
#undef BLOCK
 
1098
#undef UNBLOCK
 
1099
 
 
1100
 
 
1101
static void
 
1102
gimp_layer_tree_view_update_menu (GimpLayerTreeView *layer_view,
 
1103
                                  GimpLayer         *layer)
 
1104
{
 
1105
  GimpUIManager   *ui_manager = GIMP_EDITOR (layer_view)->ui_manager;
 
1106
  GimpActionGroup *group;
 
1107
  GimpLayerMask   *mask;
 
1108
 
 
1109
  group = gimp_ui_manager_get_action_group (ui_manager, "layers");
 
1110
 
 
1111
  mask = gimp_layer_get_mask (layer);
 
1112
 
 
1113
  gimp_action_group_set_action_active (group, "layers-mask-show",
 
1114
                                       mask &&
 
1115
                                       gimp_layer_mask_get_show (mask));
 
1116
  gimp_action_group_set_action_active (group, "layers-mask-disable",
 
1117
                                       mask &&
 
1118
                                       ! gimp_layer_mask_get_apply (mask));
 
1119
  gimp_action_group_set_action_active (group, "layers-mask-edit",
 
1120
                                       mask &&
 
1121
                                       gimp_layer_mask_get_edit (mask));
 
1122
}
 
1123
 
 
1124
 
 
1125
/*  Layer Mask callbacks  */
 
1126
 
 
1127
static void
 
1128
gimp_layer_tree_view_mask_update (GimpLayerTreeView *layer_view,
 
1129
                                  GtkTreeIter       *iter,
 
1130
                                  GimpLayer         *layer)
 
1131
{
 
1132
  GimpContainerView     *view         = GIMP_CONTAINER_VIEW (layer_view);
 
1133
  GimpContainerTreeView *tree_view    = GIMP_CONTAINER_TREE_VIEW (layer_view);
 
1134
  GimpLayerMask         *mask;
 
1135
  GimpViewRenderer      *renderer     = NULL;
 
1136
  gboolean               mask_visible = FALSE;
 
1137
 
 
1138
  mask = gimp_layer_get_mask (layer);
 
1139
 
 
1140
  if (mask)
 
1141
    {
 
1142
      GClosure *closure;
 
1143
      gint      preview_size;
 
1144
      gint      border_width;
 
1145
 
 
1146
      preview_size = gimp_container_view_get_preview_size (view, &border_width);
 
1147
 
 
1148
      mask_visible = TRUE;
 
1149
 
 
1150
      renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (mask),
 
1151
                                         preview_size, border_width,
 
1152
                                         FALSE);
 
1153
      gimp_view_renderer_set_viewable (renderer, GIMP_VIEWABLE (mask));
 
1154
 
 
1155
      g_signal_connect (renderer, "update",
 
1156
                        G_CALLBACK (gimp_layer_tree_view_renderer_update),
 
1157
                        layer_view);
 
1158
 
 
1159
      closure = g_cclosure_new (G_CALLBACK (gimp_layer_tree_view_mask_callback),
 
1160
                                layer_view, NULL);
 
1161
      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);
 
1165
    }
 
1166
 
 
1167
  gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
 
1168
                      layer_view->model_column_mask,         renderer,
 
1169
                      layer_view->model_column_mask_visible, mask_visible,
 
1170
                      -1);
 
1171
 
 
1172
  if (renderer)
 
1173
    {
 
1174
      gimp_layer_tree_view_update_borders (layer_view, iter);
 
1175
      gimp_view_renderer_remove_idle (renderer);
 
1176
      g_object_unref (renderer);
 
1177
    }
 
1178
}
 
1179
 
 
1180
static void
 
1181
gimp_layer_tree_view_mask_changed (GimpLayer         *layer,
 
1182
                                   GimpLayerTreeView *layer_view)
 
1183
{
 
1184
  GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
 
1185
  GtkTreeIter       *iter;
 
1186
 
 
1187
  iter = gimp_container_view_lookup (view, GIMP_VIEWABLE (layer));
 
1188
 
 
1189
  if (iter)
 
1190
    gimp_layer_tree_view_mask_update (layer_view, iter, layer);
 
1191
}
 
1192
 
 
1193
static void
 
1194
gimp_layer_tree_view_renderer_update (GimpViewRenderer  *renderer,
 
1195
                                      GimpLayerTreeView *layer_view)
 
1196
{
 
1197
  GimpContainerView     *view      = GIMP_CONTAINER_VIEW (layer_view);
 
1198
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
 
1199
  GimpLayerMask         *mask;
 
1200
  GtkTreeIter           *iter;
 
1201
 
 
1202
  mask = GIMP_LAYER_MASK (renderer->viewable);
 
1203
 
 
1204
  iter = gimp_container_view_lookup (view, (GimpViewable *)
 
1205
                                     gimp_layer_mask_get_layer (mask));
 
1206
 
 
1207
  if (iter)
 
1208
    {
 
1209
      GtkTreePath *path;
 
1210
 
 
1211
      path = gtk_tree_model_get_path (tree_view->model, iter);
 
1212
 
 
1213
      gtk_tree_model_row_changed (tree_view->model, path, iter);
 
1214
 
 
1215
      gtk_tree_path_free (path);
 
1216
    }
 
1217
}
 
1218
 
 
1219
static void
 
1220
gimp_layer_tree_view_update_borders (GimpLayerTreeView *layer_view,
 
1221
                                     GtkTreeIter       *iter)
 
1222
{
 
1223
  GimpContainerTreeView *tree_view  = GIMP_CONTAINER_TREE_VIEW (layer_view);
 
1224
  GimpViewRenderer      *layer_renderer;
 
1225
  GimpViewRenderer      *mask_renderer;
 
1226
  GimpLayerMask         *mask       = NULL;
 
1227
  GimpViewBorderType     layer_type = GIMP_VIEW_BORDER_BLACK;
 
1228
 
 
1229
  gtk_tree_model_get (tree_view->model, iter,
 
1230
                      tree_view->model_column_renderer, &layer_renderer,
 
1231
                      layer_view->model_column_mask,    &mask_renderer,
 
1232
                      -1);
 
1233
 
 
1234
  if (mask_renderer)
 
1235
    mask = GIMP_LAYER_MASK (mask_renderer->viewable);
 
1236
 
 
1237
  if (! mask || (mask && ! gimp_layer_mask_get_edit (mask)))
 
1238
    layer_type = GIMP_VIEW_BORDER_WHITE;
 
1239
 
 
1240
  gimp_view_renderer_set_border_type (layer_renderer, layer_type);
 
1241
 
 
1242
  if (mask)
 
1243
    {
 
1244
      GimpViewBorderType mask_color = GIMP_VIEW_BORDER_BLACK;
 
1245
 
 
1246
      if (gimp_layer_mask_get_show (mask))
 
1247
        {
 
1248
          mask_color = GIMP_VIEW_BORDER_GREEN;
 
1249
        }
 
1250
      else if (! gimp_layer_mask_get_apply (mask))
 
1251
        {
 
1252
          mask_color = GIMP_VIEW_BORDER_RED;
 
1253
        }
 
1254
      else if (gimp_layer_mask_get_edit (mask))
 
1255
        {
 
1256
          mask_color = GIMP_VIEW_BORDER_WHITE;
 
1257
        }
 
1258
 
 
1259
      gimp_view_renderer_set_border_type (mask_renderer, mask_color);
 
1260
    }
 
1261
 
 
1262
  if (layer_renderer)
 
1263
    g_object_unref (layer_renderer);
 
1264
 
 
1265
  if (mask_renderer)
 
1266
    g_object_unref (mask_renderer);
 
1267
}
 
1268
 
 
1269
static void
 
1270
gimp_layer_tree_view_mask_callback (GimpLayerMask     *mask,
 
1271
                                    GimpLayerTreeView *layer_view)
 
1272
{
 
1273
  GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
 
1274
  GtkTreeIter       *iter;
 
1275
 
 
1276
  iter = gimp_container_view_lookup (view, (GimpViewable *)
 
1277
                                     gimp_layer_mask_get_layer (mask));
 
1278
 
 
1279
  gimp_layer_tree_view_update_borders (layer_view, iter);
 
1280
}
 
1281
 
 
1282
static void
 
1283
gimp_layer_tree_view_layer_clicked (GimpCellRendererViewable *cell,
 
1284
                                    const gchar              *path_str,
 
1285
                                    GdkModifierType           state,
 
1286
                                    GimpLayerTreeView        *layer_view)
 
1287
{
 
1288
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
 
1289
  GtkTreePath           *path;
 
1290
  GtkTreeIter            iter;
 
1291
 
 
1292
  path = gtk_tree_path_new_from_string (path_str);
 
1293
 
 
1294
  if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
 
1295
    {
 
1296
      GimpViewRenderer *renderer;
 
1297
      GimpUIManager    *ui_manager;
 
1298
      GimpActionGroup  *group;
 
1299
 
 
1300
      ui_manager = GIMP_EDITOR (tree_view)->ui_manager;
 
1301
      group      = gimp_ui_manager_get_action_group (ui_manager, "layers");
 
1302
 
 
1303
      gtk_tree_model_get (tree_view->model, &iter,
 
1304
                          layer_view->model_column_mask, &renderer,
 
1305
                          -1);
 
1306
 
 
1307
      if (renderer)
 
1308
        {
 
1309
          GimpLayerMask *mask = GIMP_LAYER_MASK (renderer->viewable);
 
1310
 
 
1311
          if (gimp_layer_mask_get_edit (mask))
 
1312
            gimp_action_group_set_action_active (group,
 
1313
                                                 "layers-mask-edit", FALSE);
 
1314
          g_object_unref (renderer);
 
1315
        }
 
1316
    }
 
1317
 
 
1318
  gtk_tree_path_free (path);
 
1319
}
 
1320
 
 
1321
static void
 
1322
gimp_layer_tree_view_mask_clicked (GimpCellRendererViewable *cell,
 
1323
                                   const gchar              *path_str,
 
1324
                                   GdkModifierType           state,
 
1325
                                   GimpLayerTreeView        *layer_view)
 
1326
{
 
1327
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
 
1328
  GtkTreePath           *path;
 
1329
  GtkTreeIter            iter;
 
1330
 
 
1331
  path = gtk_tree_path_new_from_string (path_str);
 
1332
 
 
1333
  if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
 
1334
    {
 
1335
      GimpViewRenderer *renderer;
 
1336
      GimpUIManager    *ui_manager;
 
1337
      GimpActionGroup  *group;
 
1338
 
 
1339
      ui_manager = GIMP_EDITOR (tree_view)->ui_manager;
 
1340
      group      = gimp_ui_manager_get_action_group (ui_manager, "layers");
 
1341
 
 
1342
      gtk_tree_model_get (tree_view->model, &iter,
 
1343
                          layer_view->model_column_mask, &renderer,
 
1344
                          -1);
 
1345
 
 
1346
      if (renderer)
 
1347
        {
 
1348
          GimpLayerMask *mask = GIMP_LAYER_MASK (renderer->viewable);
 
1349
 
 
1350
          if (state & GDK_MOD1_MASK)
 
1351
            gimp_action_group_set_action_active (group, "layers-mask-show",
 
1352
                                                 ! gimp_layer_mask_get_show (mask));
 
1353
          else if (state & GDK_CONTROL_MASK)
 
1354
            gimp_action_group_set_action_active (group, "layers-mask-disable",
 
1355
                                                 gimp_layer_mask_get_apply (mask));
 
1356
          else if (! gimp_layer_mask_get_edit (mask))
 
1357
            gimp_action_group_set_action_active (group,
 
1358
                                                 "layers-mask-edit", TRUE);
 
1359
 
 
1360
          g_object_unref (renderer);
 
1361
        }
 
1362
    }
 
1363
 
 
1364
  gtk_tree_path_free (path);
 
1365
}
 
1366
 
 
1367
 
 
1368
/*  GimpDrawable alpha callbacks  */
 
1369
 
 
1370
static void
 
1371
gimp_layer_tree_view_alpha_update (GimpLayerTreeView *view,
 
1372
                                   GtkTreeIter       *iter,
 
1373
                                   GimpLayer         *layer)
 
1374
{
 
1375
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
 
1376
 
 
1377
  gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
 
1378
                      tree_view->model_column_name_attributes,
 
1379
                      gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)) ?
 
1380
                      NULL : view->bold_attrs,
 
1381
                      -1);
 
1382
}
 
1383
 
 
1384
static void
 
1385
gimp_layer_tree_view_alpha_changed (GimpLayer         *layer,
 
1386
                                    GimpLayerTreeView *layer_view)
 
1387
{
 
1388
  GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
 
1389
  GtkTreeIter       *iter;
 
1390
 
 
1391
  iter = gimp_container_view_lookup (view, (GimpViewable *) layer);
 
1392
 
 
1393
  if (iter)
 
1394
    {
 
1395
      GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
 
1396
 
 
1397
      gimp_layer_tree_view_alpha_update (layer_view, iter, layer);
 
1398
 
 
1399
      /*  update button states  */
 
1400
      if (gimp_image_get_active_layer (item_view->gimage) == layer)
 
1401
        gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view),
 
1402
                                         GIMP_VIEWABLE (layer));
 
1403
    }
 
1404
}