1 /* GIMP - The GNU Image Manipulation Program
2 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3 *
4 * gimplayertreeview.c
5 * Copyright (C) 2001-2009 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 3 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, see <https://www.gnu.org/licenses/>.
19 */
20
21 #include "config.h"
22
23 #include <string.h>
24
25 #include <gegl.h>
26 #include <gtk/gtk.h>
27
28 #include "libgimpbase/gimpbase.h"
29 #include "libgimpmath/gimpmath.h"
30 #include "libgimpwidgets/gimpwidgets.h"
31
32 #include "widgets-types.h"
33
34 #include "core/gimp.h"
35 #include "core/gimpchannel.h"
36 #include "core/gimpcontainer.h"
37 #include "core/gimpimage-undo.h"
38 #include "core/gimpimage.h"
39 #include "core/gimpitemundo.h"
40 #include "core/gimplayer.h"
41 #include "core/gimplayer-floating-selection.h"
42 #include "core/gimplayer-new.h"
43 #include "core/gimplayermask.h"
44 #include "core/gimptreehandler.h"
45
46 #include "text/gimptextlayer.h"
47
48 #include "file/file-open.h"
49
50 #include "gimpactiongroup.h"
51 #include "gimpcellrendererviewable.h"
52 #include "gimpcontainertreestore.h"
53 #include "gimpcontainerview.h"
54 #include "gimpdnd.h"
55 #include "gimphelp-ids.h"
56 #include "gimphighlightablebutton.h"
57 #include "gimplayermodebox.h"
58 #include "gimplayertreeview.h"
59 #include "gimpspinscale.h"
60 #include "gimpuimanager.h"
61 #include "gimpviewrenderer.h"
62 #include "gimpwidgets-utils.h"
63
64 #include "gimp-intl.h"
65
66
67 struct _GimpLayerTreeViewPrivate
68 {
69 GtkWidget *layer_mode_box;
70 GtkAdjustment *opacity_adjustment;
71 GtkWidget *lock_alpha_toggle;
72 GtkWidget *anchor_button;
73
74 gint model_column_mask;
75 gint model_column_mask_visible;
76
77 GtkCellRenderer *mask_cell;
78
79 PangoAttrList *italic_attrs;
80 PangoAttrList *bold_attrs;
81
82 GimpTreeHandler *mode_changed_handler;
83 GimpTreeHandler *opacity_changed_handler;
84 GimpTreeHandler *lock_alpha_changed_handler;
85 GimpTreeHandler *mask_changed_handler;
86 GimpTreeHandler *alpha_changed_handler;
87 };
88
89
90 static void gimp_layer_tree_view_view_iface_init (GimpContainerViewInterface *iface);
91
92 static void gimp_layer_tree_view_constructed (GObject *object);
93 static void gimp_layer_tree_view_finalize (GObject *object);
94
95 static void gimp_layer_tree_view_set_container (GimpContainerView *view,
96 GimpContainer *container);
97 static void gimp_layer_tree_view_set_context (GimpContainerView *view,
98 GimpContext *context);
99 static gpointer gimp_layer_tree_view_insert_item (GimpContainerView *view,
100 GimpViewable *viewable,
101 gpointer parent_insert_data,
102 gint index);
103 static gboolean gimp_layer_tree_view_select_item (GimpContainerView *view,
104 GimpViewable *item,
105 gpointer insert_data);
106 static void gimp_layer_tree_view_set_view_size (GimpContainerView *view);
107 static gboolean gimp_layer_tree_view_drop_possible (GimpContainerTreeView *view,
108 GimpDndType src_type,
109 GimpViewable *src_viewable,
110 GimpViewable *dest_viewable,
111 GtkTreePath *drop_path,
112 GtkTreeViewDropPosition drop_pos,
113 GtkTreeViewDropPosition *return_drop_pos,
114 GdkDragAction *return_drag_action);
115 static void gimp_layer_tree_view_drop_color (GimpContainerTreeView *view,
116 const GimpRGB *color,
117 GimpViewable *dest_viewable,
118 GtkTreeViewDropPosition drop_pos);
119 static void gimp_layer_tree_view_drop_uri_list (GimpContainerTreeView *view,
120 GList *uri_list,
121 GimpViewable *dest_viewable,
122 GtkTreeViewDropPosition drop_pos);
123 static void gimp_layer_tree_view_drop_component (GimpContainerTreeView *tree_view,
124 GimpImage *image,
125 GimpChannelType component,
126 GimpViewable *dest_viewable,
127 GtkTreeViewDropPosition drop_pos);
128 static void gimp_layer_tree_view_drop_pixbuf (GimpContainerTreeView *tree_view,
129 GdkPixbuf *pixbuf,
130 GimpViewable *dest_viewable,
131 GtkTreeViewDropPosition drop_pos);
132 static void gimp_layer_tree_view_set_image (GimpItemTreeView *view,
133 GimpImage *image);
134 static GimpItem * gimp_layer_tree_view_item_new (GimpImage *image);
135 static void gimp_layer_tree_view_floating_selection_changed (GimpImage *image,
136 GimpLayerTreeView *view);
137 static void gimp_layer_tree_view_layer_mode_box_callback (GtkWidget *widget,
138 const GParamSpec *pspec,
139 GimpLayerTreeView *view);
140 static void gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adj,
141 GimpLayerTreeView *view);
142 static void gimp_layer_tree_view_lock_alpha_button_toggled (GtkWidget *widget,
143 GimpLayerTreeView *view);
144 static void gimp_layer_tree_view_layer_signal_handler (GimpLayer *layer,
145 GimpLayerTreeView *view);
146 static void gimp_layer_tree_view_update_options (GimpLayerTreeView *view,
147 GimpLayer *layer);
148 static void gimp_layer_tree_view_update_menu (GimpLayerTreeView *view,
149 GimpLayer *layer);
150 static void gimp_layer_tree_view_update_highlight (GimpLayerTreeView *view);
151 static void gimp_layer_tree_view_mask_update (GimpLayerTreeView *view,
152 GtkTreeIter *iter,
153 GimpLayer *layer);
154 static void gimp_layer_tree_view_mask_changed (GimpLayer *layer,
155 GimpLayerTreeView *view);
156 static void gimp_layer_tree_view_renderer_update (GimpViewRenderer *renderer,
157 GimpLayerTreeView *view);
158 static void gimp_layer_tree_view_update_borders (GimpLayerTreeView *view,
159 GtkTreeIter *iter);
160 static void gimp_layer_tree_view_mask_callback (GimpLayer *mask,
161 GimpLayerTreeView *view);
162 static void gimp_layer_tree_view_layer_clicked (GimpCellRendererViewable *cell,
163 const gchar *path,
164 GdkModifierType state,
165 GimpLayerTreeView *view);
166 static void gimp_layer_tree_view_mask_clicked (GimpCellRendererViewable *cell,
167 const gchar *path,
168 GdkModifierType state,
169 GimpLayerTreeView *view);
170 static void gimp_layer_tree_view_alpha_update (GimpLayerTreeView *view,
171 GtkTreeIter *iter,
172 GimpLayer *layer);
173 static void gimp_layer_tree_view_alpha_changed (GimpLayer *layer,
174 GimpLayerTreeView *view);
175
176
177 G_DEFINE_TYPE_WITH_CODE (GimpLayerTreeView, gimp_layer_tree_view,
178 GIMP_TYPE_DRAWABLE_TREE_VIEW,
179 G_ADD_PRIVATE (GimpLayerTreeView)
180 G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
181 gimp_layer_tree_view_view_iface_init))
182
183 #define parent_class gimp_layer_tree_view_parent_class
184
185 static GimpContainerViewInterface *parent_view_iface = NULL;
186
187
188 static void
gimp_layer_tree_view_class_init(GimpLayerTreeViewClass * klass)189 gimp_layer_tree_view_class_init (GimpLayerTreeViewClass *klass)
190 {
191 GObjectClass *object_class = G_OBJECT_CLASS (klass);
192 GimpContainerTreeViewClass *tree_view_class;
193 GimpItemTreeViewClass *item_view_class;
194
195 tree_view_class = GIMP_CONTAINER_TREE_VIEW_CLASS (klass);
196 item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
197
198 object_class->constructed = gimp_layer_tree_view_constructed;
199 object_class->finalize = gimp_layer_tree_view_finalize;
200
201 tree_view_class->drop_possible = gimp_layer_tree_view_drop_possible;
202 tree_view_class->drop_color = gimp_layer_tree_view_drop_color;
203 tree_view_class->drop_uri_list = gimp_layer_tree_view_drop_uri_list;
204 tree_view_class->drop_component = gimp_layer_tree_view_drop_component;
205 tree_view_class->drop_pixbuf = gimp_layer_tree_view_drop_pixbuf;
206
207 item_view_class->item_type = GIMP_TYPE_LAYER;
208 item_view_class->signal_name = "active-layer-changed";
209
210 item_view_class->set_image = gimp_layer_tree_view_set_image;
211 item_view_class->get_container = gimp_image_get_layers;
212 item_view_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_layer;
213 item_view_class->set_active_item = (GimpSetItemFunc) gimp_image_set_active_layer;
214 item_view_class->add_item = (GimpAddItemFunc) gimp_image_add_layer;
215 item_view_class->remove_item = (GimpRemoveItemFunc) gimp_image_remove_layer;
216 item_view_class->new_item = gimp_layer_tree_view_item_new;
217
218 item_view_class->action_group = "layers";
219 item_view_class->activate_action = "layers-edit";
220 item_view_class->new_action = "layers-new";
221 item_view_class->new_default_action = "layers-new-last-values";
222 item_view_class->raise_action = "layers-raise";
223 item_view_class->raise_top_action = "layers-raise-to-top";
224 item_view_class->lower_action = "layers-lower";
225 item_view_class->lower_bottom_action = "layers-lower-to-bottom";
226 item_view_class->duplicate_action = "layers-duplicate";
227 item_view_class->delete_action = "layers-delete";
228 item_view_class->lock_content_help_id = GIMP_HELP_LAYER_LOCK_PIXELS;
229 item_view_class->lock_position_help_id = GIMP_HELP_LAYER_LOCK_POSITION;
230 }
231
232 static void
gimp_layer_tree_view_view_iface_init(GimpContainerViewInterface * iface)233 gimp_layer_tree_view_view_iface_init (GimpContainerViewInterface *iface)
234 {
235 parent_view_iface = g_type_interface_peek_parent (iface);
236
237 iface->set_container = gimp_layer_tree_view_set_container;
238 iface->set_context = gimp_layer_tree_view_set_context;
239 iface->insert_item = gimp_layer_tree_view_insert_item;
240 iface->select_item = gimp_layer_tree_view_select_item;
241 iface->set_view_size = gimp_layer_tree_view_set_view_size;
242
243 iface->model_is_tree = TRUE;
244 }
245
246 static void
gimp_layer_tree_view_init(GimpLayerTreeView * view)247 gimp_layer_tree_view_init (GimpLayerTreeView *view)
248 {
249 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
250 GtkWidget *scale;
251 GtkWidget *hbox;
252 GtkWidget *image;
253 GtkIconSize icon_size;
254 PangoAttribute *attr;
255
256 view->priv = gimp_layer_tree_view_get_instance_private (view);
257
258 view->priv->model_column_mask =
259 gimp_container_tree_store_columns_add (tree_view->model_columns,
260 &tree_view->n_model_columns,
261 GIMP_TYPE_VIEW_RENDERER);
262
263 view->priv->model_column_mask_visible =
264 gimp_container_tree_store_columns_add (tree_view->model_columns,
265 &tree_view->n_model_columns,
266 G_TYPE_BOOLEAN);
267
268 /* Paint mode menu */
269
270 view->priv->layer_mode_box = gimp_layer_mode_box_new (GIMP_LAYER_MODE_CONTEXT_LAYER);
271 gimp_layer_mode_box_set_label (GIMP_LAYER_MODE_BOX (view->priv->layer_mode_box),
272 _("Mode"));
273 gimp_item_tree_view_add_options (GIMP_ITEM_TREE_VIEW (view), NULL,
274 view->priv->layer_mode_box);
275
276 g_signal_connect (view->priv->layer_mode_box, "notify::layer-mode",
277 G_CALLBACK (gimp_layer_tree_view_layer_mode_box_callback),
278 view);
279
280 gimp_help_set_help_data (view->priv->layer_mode_box, NULL,
281 GIMP_HELP_LAYER_DIALOG_PAINT_MODE_MENU);
282
283 /* Opacity scale */
284
285 view->priv->opacity_adjustment =
286 GTK_ADJUSTMENT (gtk_adjustment_new (100.0, 0.0, 100.0,
287 1.0, 10.0, 0.0));
288 scale = gimp_spin_scale_new (view->priv->opacity_adjustment, _("Opacity"), 1);
289 gimp_help_set_help_data (scale, NULL,
290 GIMP_HELP_LAYER_DIALOG_OPACITY_SCALE);
291 gimp_item_tree_view_add_options (GIMP_ITEM_TREE_VIEW (view),
292 NULL, scale);
293
294 g_signal_connect (view->priv->opacity_adjustment, "value-changed",
295 G_CALLBACK (gimp_layer_tree_view_opacity_scale_changed),
296 view);
297
298 /* Lock alpha toggle */
299
300 hbox = gimp_item_tree_view_get_lock_box (GIMP_ITEM_TREE_VIEW (view));
301
302 view->priv->lock_alpha_toggle = gtk_toggle_button_new ();
303 gtk_box_pack_start (GTK_BOX (hbox), view->priv->lock_alpha_toggle,
304 FALSE, FALSE, 0);
305 gtk_widget_show (view->priv->lock_alpha_toggle);
306
307 g_signal_connect (view->priv->lock_alpha_toggle, "toggled",
308 G_CALLBACK (gimp_layer_tree_view_lock_alpha_button_toggled),
309 view);
310
311 gimp_help_set_help_data (view->priv->lock_alpha_toggle,
312 _("Lock alpha channel"),
313 GIMP_HELP_LAYER_LOCK_ALPHA);
314
315 gtk_widget_style_get (GTK_WIDGET (view),
316 "button-icon-size", &icon_size,
317 NULL);
318
319 image = gtk_image_new_from_icon_name (GIMP_ICON_TRANSPARENCY, icon_size);
320 gtk_container_add (GTK_CONTAINER (view->priv->lock_alpha_toggle), image);
321 gtk_widget_show (image);
322
323 view->priv->italic_attrs = pango_attr_list_new ();
324 attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
325 attr->start_index = 0;
326 attr->end_index = -1;
327 pango_attr_list_insert (view->priv->italic_attrs, attr);
328
329 view->priv->bold_attrs = pango_attr_list_new ();
330 attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
331 attr->start_index = 0;
332 attr->end_index = -1;
333 pango_attr_list_insert (view->priv->bold_attrs, attr);
334 }
335
336 static void
gimp_layer_tree_view_constructed(GObject * object)337 gimp_layer_tree_view_constructed (GObject *object)
338 {
339 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (object);
340 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (object);
341 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (object);
342 GtkWidget *button;
343
344 G_OBJECT_CLASS (parent_class)->constructed (object);
345
346 gimp_highlightable_button_set_highlight_color (
347 GIMP_HIGHLIGHTABLE_BUTTON (gimp_item_tree_view_get_new_button (item_view)),
348 GIMP_HIGHLIGHTABLE_BUTTON_COLOR_AFFIRMATIVE);
349 gimp_highlightable_button_set_highlight_color (
350 GIMP_HIGHLIGHTABLE_BUTTON (gimp_item_tree_view_get_delete_button (item_view)),
351 GIMP_HIGHLIGHTABLE_BUTTON_COLOR_NEGATIVE);
352
353 layer_view->priv->mask_cell = gimp_cell_renderer_viewable_new ();
354 gtk_tree_view_column_pack_start (tree_view->main_column,
355 layer_view->priv->mask_cell,
356 FALSE);
357 gtk_tree_view_column_set_attributes (tree_view->main_column,
358 layer_view->priv->mask_cell,
359 "renderer",
360 layer_view->priv->model_column_mask,
361 "visible",
362 layer_view->priv->model_column_mask_visible,
363 NULL);
364
365 gimp_container_tree_view_add_renderer_cell (tree_view,
366 layer_view->priv->mask_cell);
367
368 g_signal_connect (tree_view->renderer_cell, "clicked",
369 G_CALLBACK (gimp_layer_tree_view_layer_clicked),
370 layer_view);
371 g_signal_connect (layer_view->priv->mask_cell, "clicked",
372 G_CALLBACK (gimp_layer_tree_view_mask_clicked),
373 layer_view);
374
375 gimp_dnd_component_dest_add (GTK_WIDGET (tree_view->view),
376 NULL, tree_view);
377 gimp_dnd_viewable_dest_add (GTK_WIDGET (tree_view->view), GIMP_TYPE_CHANNEL,
378 NULL, tree_view);
379 gimp_dnd_viewable_dest_add (GTK_WIDGET (tree_view->view), GIMP_TYPE_LAYER_MASK,
380 NULL, tree_view);
381 gimp_dnd_uri_list_dest_add (GTK_WIDGET (tree_view->view),
382 NULL, tree_view);
383 gimp_dnd_pixbuf_dest_add (GTK_WIDGET (tree_view->view),
384 NULL, tree_view);
385
386 button = gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
387 "layers-new-group", NULL);
388 gtk_box_reorder_child (gimp_editor_get_button_box (GIMP_EDITOR (layer_view)),
389 button, 1);
390
391 button = gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
392 "layers-anchor", NULL);
393 layer_view->priv->anchor_button = button;
394 gimp_highlightable_button_set_highlight_color (
395 GIMP_HIGHLIGHTABLE_BUTTON (button),
396 GIMP_HIGHLIGHTABLE_BUTTON_COLOR_AFFIRMATIVE);
397 gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
398 GTK_BUTTON (button),
399 GIMP_TYPE_LAYER);
400 gtk_box_reorder_child (gimp_editor_get_button_box (GIMP_EDITOR (layer_view)),
401 button, 5);
402
403 button = gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
404 "layers-merge-down-button",
405 "layers-merge-group",
406 GDK_SHIFT_MASK,
407 "layers-merge-layers",
408 GDK_CONTROL_MASK,
409 "layers-merge-layers-last-values",
410 GDK_CONTROL_MASK |
411 GDK_SHIFT_MASK,
412 NULL);
413 gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
414 GTK_BUTTON (button),
415 GIMP_TYPE_LAYER);
416 gtk_box_reorder_child (gimp_editor_get_button_box (GIMP_EDITOR (layer_view)),
417 button, 6);
418
419 button = gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
420 "layers-mask-add-button",
421 "layers-mask-add-last-values",
422 gimp_get_extend_selection_mask (),
423 "layers-mask-delete",
424 gimp_get_modify_selection_mask (),
425 "layers-mask-apply",
426 gimp_get_extend_selection_mask () |
427 gimp_get_modify_selection_mask (),
428 NULL);
429 gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
430 GTK_BUTTON (button),
431 GIMP_TYPE_LAYER);
432 gtk_box_reorder_child (gimp_editor_get_button_box (GIMP_EDITOR (layer_view)),
433 button, 7);
434 }
435
436 static void
gimp_layer_tree_view_finalize(GObject * object)437 gimp_layer_tree_view_finalize (GObject *object)
438 {
439 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (object);
440
441 if (layer_view->priv->italic_attrs)
442 {
443 pango_attr_list_unref (layer_view->priv->italic_attrs);
444 layer_view->priv->italic_attrs = NULL;
445 }
446
447 if (layer_view->priv->bold_attrs)
448 {
449 pango_attr_list_unref (layer_view->priv->bold_attrs);
450 layer_view->priv->bold_attrs = NULL;
451 }
452
453 G_OBJECT_CLASS (parent_class)->finalize (object);
454 }
455
456
457 /* GimpContainerView methods */
458
459 static void
gimp_layer_tree_view_set_container(GimpContainerView * view,GimpContainer * container)460 gimp_layer_tree_view_set_container (GimpContainerView *view,
461 GimpContainer *container)
462 {
463 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
464 GimpContainer *old_container;
465
466 old_container = gimp_container_view_get_container (view);
467
468 if (old_container)
469 {
470 gimp_tree_handler_disconnect (layer_view->priv->mode_changed_handler);
471 layer_view->priv->mode_changed_handler = NULL;
472
473 gimp_tree_handler_disconnect (layer_view->priv->opacity_changed_handler);
474 layer_view->priv->opacity_changed_handler = NULL;
475
476 gimp_tree_handler_disconnect (layer_view->priv->lock_alpha_changed_handler);
477 layer_view->priv->lock_alpha_changed_handler = NULL;
478
479 gimp_tree_handler_disconnect (layer_view->priv->mask_changed_handler);
480 layer_view->priv->mask_changed_handler = NULL;
481
482 gimp_tree_handler_disconnect (layer_view->priv->alpha_changed_handler);
483 layer_view->priv->alpha_changed_handler = NULL;
484 }
485
486 parent_view_iface->set_container (view, container);
487
488 if (container)
489 {
490 layer_view->priv->mode_changed_handler =
491 gimp_tree_handler_connect (container, "mode-changed",
492 G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
493 view);
494
495 layer_view->priv->opacity_changed_handler =
496 gimp_tree_handler_connect (container, "opacity-changed",
497 G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
498 view);
499
500 layer_view->priv->lock_alpha_changed_handler =
501 gimp_tree_handler_connect (container, "lock-alpha-changed",
502 G_CALLBACK (gimp_layer_tree_view_layer_signal_handler),
503 view);
504
505 layer_view->priv->mask_changed_handler =
506 gimp_tree_handler_connect (container, "mask-changed",
507 G_CALLBACK (gimp_layer_tree_view_mask_changed),
508 view);
509
510 layer_view->priv->alpha_changed_handler =
511 gimp_tree_handler_connect (container, "alpha-changed",
512 G_CALLBACK (gimp_layer_tree_view_alpha_changed),
513 view);
514 }
515 }
516
517 typedef struct
518 {
519 gint mask_column;
520 GimpContext *context;
521 } SetContextForeachData;
522
523 static gboolean
gimp_layer_tree_view_set_context_foreach(GtkTreeModel * model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)524 gimp_layer_tree_view_set_context_foreach (GtkTreeModel *model,
525 GtkTreePath *path,
526 GtkTreeIter *iter,
527 gpointer data)
528 {
529 SetContextForeachData *context_data = data;
530 GimpViewRenderer *renderer;
531
532 gtk_tree_model_get (model, iter,
533 context_data->mask_column, &renderer,
534 -1);
535
536 if (renderer)
537 {
538 gimp_view_renderer_set_context (renderer, context_data->context);
539
540 g_object_unref (renderer);
541 }
542
543 return FALSE;
544 }
545
546 static void
gimp_layer_tree_view_set_context(GimpContainerView * view,GimpContext * context)547 gimp_layer_tree_view_set_context (GimpContainerView *view,
548 GimpContext *context)
549 {
550 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
551 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
552
553 parent_view_iface->set_context (view, context);
554
555 if (tree_view->model)
556 {
557 SetContextForeachData context_data = { layer_view->priv->model_column_mask,
558 context };
559
560 gtk_tree_model_foreach (tree_view->model,
561 gimp_layer_tree_view_set_context_foreach,
562 &context_data);
563 }
564 }
565
566 static gpointer
gimp_layer_tree_view_insert_item(GimpContainerView * view,GimpViewable * viewable,gpointer parent_insert_data,gint index)567 gimp_layer_tree_view_insert_item (GimpContainerView *view,
568 GimpViewable *viewable,
569 gpointer parent_insert_data,
570 gint index)
571 {
572 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
573 GimpLayer *layer;
574 GtkTreeIter *iter;
575
576 iter = parent_view_iface->insert_item (view, viewable,
577 parent_insert_data, index);
578
579 layer = GIMP_LAYER (viewable);
580
581 if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
582 gimp_layer_tree_view_alpha_update (layer_view, iter, layer);
583
584 gimp_layer_tree_view_mask_update (layer_view, iter, layer);
585
586 return iter;
587 }
588
589 static gboolean
gimp_layer_tree_view_select_item(GimpContainerView * view,GimpViewable * item,gpointer insert_data)590 gimp_layer_tree_view_select_item (GimpContainerView *view,
591 GimpViewable *item,
592 gpointer insert_data)
593 {
594 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
595 gboolean success;
596
597 success = parent_view_iface->select_item (view, item, insert_data);
598
599 if (item)
600 {
601 if (success)
602 {
603 gimp_layer_tree_view_update_borders (layer_view,
604 (GtkTreeIter *) insert_data);
605 gimp_layer_tree_view_update_options (layer_view, GIMP_LAYER (item));
606 gimp_layer_tree_view_update_menu (layer_view, GIMP_LAYER (item));
607 }
608 }
609
610 if (! success)
611 {
612 GimpEditor *editor = GIMP_EDITOR (view);
613
614 /* currently, select_item() only ever fails when there is a floating
615 * selection, which can be committed/canceled through the editor buttons.
616 */
617 gimp_widget_blink (GTK_WIDGET (gimp_editor_get_button_box (editor)));
618 }
619
620 return success;
621 }
622
623 typedef struct
624 {
625 gint mask_column;
626 gint view_size;
627 gint border_width;
628 } SetSizeForeachData;
629
630 static gboolean
gimp_layer_tree_view_set_view_size_foreach(GtkTreeModel * model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)631 gimp_layer_tree_view_set_view_size_foreach (GtkTreeModel *model,
632 GtkTreePath *path,
633 GtkTreeIter *iter,
634 gpointer data)
635 {
636 SetSizeForeachData *size_data = data;
637 GimpViewRenderer *renderer;
638
639 gtk_tree_model_get (model, iter,
640 size_data->mask_column, &renderer,
641 -1);
642
643 if (renderer)
644 {
645 gimp_view_renderer_set_size (renderer,
646 size_data->view_size,
647 size_data->border_width);
648
649 g_object_unref (renderer);
650 }
651
652 return FALSE;
653 }
654
655 static void
gimp_layer_tree_view_set_view_size(GimpContainerView * view)656 gimp_layer_tree_view_set_view_size (GimpContainerView *view)
657 {
658 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
659
660 if (tree_view->model)
661 {
662 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
663 SetSizeForeachData size_data;
664
665 size_data.mask_column = layer_view->priv->model_column_mask;
666
667 size_data.view_size =
668 gimp_container_view_get_view_size (view, &size_data.border_width);
669
670 gtk_tree_model_foreach (tree_view->model,
671 gimp_layer_tree_view_set_view_size_foreach,
672 &size_data);
673 }
674
675 parent_view_iface->set_view_size (view);
676 }
677
678
679 /* GimpContainerTreeView methods */
680
681 static gboolean
gimp_layer_tree_view_drop_possible(GimpContainerTreeView * tree_view,GimpDndType src_type,GimpViewable * src_viewable,GimpViewable * dest_viewable,GtkTreePath * drop_path,GtkTreeViewDropPosition drop_pos,GtkTreeViewDropPosition * return_drop_pos,GdkDragAction * return_drag_action)682 gimp_layer_tree_view_drop_possible (GimpContainerTreeView *tree_view,
683 GimpDndType src_type,
684 GimpViewable *src_viewable,
685 GimpViewable *dest_viewable,
686 GtkTreePath *drop_path,
687 GtkTreeViewDropPosition drop_pos,
688 GtkTreeViewDropPosition *return_drop_pos,
689 GdkDragAction *return_drag_action)
690 {
691 /* If we are dropping a new layer, check if the destination image
692 * has a floating selection.
693 */
694 if (src_type == GIMP_DND_TYPE_URI_LIST ||
695 src_type == GIMP_DND_TYPE_TEXT_PLAIN ||
696 src_type == GIMP_DND_TYPE_NETSCAPE_URL ||
697 src_type == GIMP_DND_TYPE_COMPONENT ||
698 src_type == GIMP_DND_TYPE_PIXBUF ||
699 GIMP_IS_DRAWABLE (src_viewable))
700 {
701 GimpImage *dest_image = gimp_item_tree_view_get_image (GIMP_ITEM_TREE_VIEW (tree_view));
702
703 if (gimp_image_get_floating_selection (dest_image))
704 return FALSE;
705 }
706
707 return GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_possible (tree_view,
708 src_type,
709 src_viewable,
710 dest_viewable,
711 drop_path,
712 drop_pos,
713 return_drop_pos,
714 return_drag_action);
715 }
716
717 static void
gimp_layer_tree_view_drop_color(GimpContainerTreeView * view,const GimpRGB * color,GimpViewable * dest_viewable,GtkTreeViewDropPosition drop_pos)718 gimp_layer_tree_view_drop_color (GimpContainerTreeView *view,
719 const GimpRGB *color,
720 GimpViewable *dest_viewable,
721 GtkTreeViewDropPosition drop_pos)
722 {
723 if (gimp_item_is_text_layer (GIMP_ITEM (dest_viewable)))
724 {
725 gimp_text_layer_set (GIMP_TEXT_LAYER (dest_viewable), NULL,
726 "color", color,
727 NULL);
728 gimp_image_flush (gimp_item_tree_view_get_image (GIMP_ITEM_TREE_VIEW (view)));
729 return;
730 }
731
732 GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_color (view, color,
733 dest_viewable,
734 drop_pos);
735 }
736
737 static void
gimp_layer_tree_view_drop_uri_list(GimpContainerTreeView * view,GList * uri_list,GimpViewable * dest_viewable,GtkTreeViewDropPosition drop_pos)738 gimp_layer_tree_view_drop_uri_list (GimpContainerTreeView *view,
739 GList *uri_list,
740 GimpViewable *dest_viewable,
741 GtkTreeViewDropPosition drop_pos)
742 {
743 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
744 GimpContainerView *cont_view = GIMP_CONTAINER_VIEW (view);
745 GimpImage *image = gimp_item_tree_view_get_image (item_view);
746 GimpLayer *parent;
747 gint index;
748 GList *list;
749
750 index = gimp_item_tree_view_get_drop_index (item_view, dest_viewable,
751 drop_pos,
752 (GimpViewable **) &parent);
753
754 g_object_ref (image);
755
756 for (list = uri_list; list; list = g_list_next (list))
757 {
758 const gchar *uri = list->data;
759 GFile *file = g_file_new_for_uri (uri);
760 GList *new_layers;
761 GimpPDBStatusType status;
762 GError *error = NULL;
763
764 new_layers = file_open_layers (image->gimp,
765 gimp_container_view_get_context (cont_view),
766 NULL,
767 image, FALSE,
768 file, GIMP_RUN_INTERACTIVE, NULL,
769 &status, &error);
770
771 if (new_layers)
772 {
773 gimp_image_add_layers (image, new_layers, parent, index,
774 0, 0,
775 gimp_image_get_width (image),
776 gimp_image_get_height (image),
777 _("Drop layers"));
778
779 index += g_list_length (new_layers);
780
781 g_list_free (new_layers);
782 }
783 else if (status != GIMP_PDB_CANCEL)
784 {
785 gimp_message (image->gimp, G_OBJECT (view), GIMP_MESSAGE_ERROR,
786 _("Opening '%s' failed:\n\n%s"),
787 gimp_file_get_utf8_name (file), error->message);
788 g_clear_error (&error);
789 }
790
791 g_object_unref (file);
792 }
793
794 gimp_image_flush (image);
795
796 g_object_unref (image);
797 }
798
799 static void
gimp_layer_tree_view_drop_component(GimpContainerTreeView * tree_view,GimpImage * src_image,GimpChannelType component,GimpViewable * dest_viewable,GtkTreeViewDropPosition drop_pos)800 gimp_layer_tree_view_drop_component (GimpContainerTreeView *tree_view,
801 GimpImage *src_image,
802 GimpChannelType component,
803 GimpViewable *dest_viewable,
804 GtkTreeViewDropPosition drop_pos)
805 {
806 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (tree_view);
807 GimpImage *image = gimp_item_tree_view_get_image (item_view);
808 GimpChannel *channel;
809 GimpItem *new_item;
810 GimpLayer *parent;
811 gint index;
812 const gchar *desc;
813
814 index = gimp_item_tree_view_get_drop_index (item_view, dest_viewable,
815 drop_pos,
816 (GimpViewable **) &parent);
817
818 channel = gimp_channel_new_from_component (src_image, component, NULL, NULL);
819
820 new_item = gimp_item_convert (GIMP_ITEM (channel), image,
821 GIMP_TYPE_LAYER);
822
823 g_object_unref (channel);
824
825 gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component,
826 NULL, NULL, &desc, NULL);
827 gimp_object_take_name (GIMP_OBJECT (new_item),
828 g_strdup_printf (_("%s Channel Copy"), desc));
829
830 gimp_image_add_layer (image, GIMP_LAYER (new_item), parent, index, TRUE);
831
832 gimp_image_flush (image);
833 }
834
835 static void
gimp_layer_tree_view_drop_pixbuf(GimpContainerTreeView * tree_view,GdkPixbuf * pixbuf,GimpViewable * dest_viewable,GtkTreeViewDropPosition drop_pos)836 gimp_layer_tree_view_drop_pixbuf (GimpContainerTreeView *tree_view,
837 GdkPixbuf *pixbuf,
838 GimpViewable *dest_viewable,
839 GtkTreeViewDropPosition drop_pos)
840 {
841 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (tree_view);
842 GimpImage *image = gimp_item_tree_view_get_image (item_view);
843 GimpLayer *new_layer;
844 GimpLayer *parent;
845 gint index;
846
847 index = gimp_item_tree_view_get_drop_index (item_view, dest_viewable,
848 drop_pos,
849 (GimpViewable **) &parent);
850
851 new_layer =
852 gimp_layer_new_from_pixbuf (pixbuf, image,
853 gimp_image_get_layer_format (image, TRUE),
854 _("Dropped Buffer"),
855 GIMP_OPACITY_OPAQUE,
856 gimp_image_get_default_new_layer_mode (image));
857
858 gimp_image_add_layer (image, new_layer, parent, index, TRUE);
859
860 gimp_image_flush (image);
861 }
862
863
864 /* GimpItemTreeView methods */
865
866 static void
gimp_layer_tree_view_set_image(GimpItemTreeView * view,GimpImage * image)867 gimp_layer_tree_view_set_image (GimpItemTreeView *view,
868 GimpImage *image)
869 {
870 GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view);
871
872 if (gimp_item_tree_view_get_image (view))
873 {
874 g_signal_handlers_disconnect_by_func (gimp_item_tree_view_get_image (view),
875 gimp_layer_tree_view_floating_selection_changed,
876 view);
877 }
878
879 GIMP_ITEM_TREE_VIEW_CLASS (parent_class)->set_image (view, image);
880
881 if (gimp_item_tree_view_get_image (view))
882 {
883 g_signal_connect (gimp_item_tree_view_get_image (view),
884 "floating-selection-changed",
885 G_CALLBACK (gimp_layer_tree_view_floating_selection_changed),
886 view);
887
888 /* call gimp_layer_tree_view_floating_selection_changed() now, to update
889 * the floating selection's row attributes.
890 */
891 gimp_layer_tree_view_floating_selection_changed (
892 gimp_item_tree_view_get_image (view),
893 layer_view);
894 }
895
896 gimp_layer_tree_view_update_highlight (layer_view);
897 }
898
899 static GimpItem *
gimp_layer_tree_view_item_new(GimpImage * image)900 gimp_layer_tree_view_item_new (GimpImage *image)
901 {
902 GimpLayer *new_layer;
903
904 gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
905 _("New Layer"));
906
907 new_layer = gimp_layer_new (image,
908 gimp_image_get_width (image),
909 gimp_image_get_height (image),
910 gimp_image_get_layer_format (image, TRUE),
911 NULL,
912 GIMP_OPACITY_OPAQUE,
913 gimp_image_get_default_new_layer_mode (image));
914
915 gimp_image_add_layer (image, new_layer,
916 GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
917
918 gimp_image_undo_group_end (image);
919
920 return GIMP_ITEM (new_layer);
921 }
922
923
924 /* callbacks */
925
926 static void
gimp_layer_tree_view_floating_selection_changed(GimpImage * image,GimpLayerTreeView * layer_view)927 gimp_layer_tree_view_floating_selection_changed (GimpImage *image,
928 GimpLayerTreeView *layer_view)
929 {
930 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
931 GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
932 GimpLayer *floating_sel;
933 GtkTreeIter *iter;
934
935 floating_sel = gimp_image_get_floating_selection (image);
936
937 if (floating_sel)
938 {
939 iter = gimp_container_view_lookup (view, (GimpViewable *) floating_sel);
940
941 if (iter)
942 gtk_tree_store_set (GTK_TREE_STORE (tree_view->model), iter,
943 GIMP_CONTAINER_TREE_STORE_COLUMN_NAME_ATTRIBUTES,
944 layer_view->priv->italic_attrs,
945 -1);
946 }
947 else
948 {
949 GList *all_layers;
950 GList *list;
951
952 all_layers = gimp_image_get_layer_list (image);
953
954 for (list = all_layers; list; list = g_list_next (list))
955 {
956 GimpDrawable *drawable = list->data;
957
958 iter = gimp_container_view_lookup (view, (GimpViewable *) drawable);
959
960 if (iter)
961 gtk_tree_store_set (GTK_TREE_STORE (tree_view->model), iter,
962 GIMP_CONTAINER_TREE_STORE_COLUMN_NAME_ATTRIBUTES,
963 gimp_drawable_has_alpha (drawable) ?
964 NULL : layer_view->priv->bold_attrs,
965 -1);
966 }
967
968 g_list_free (all_layers);
969 }
970
971 gimp_layer_tree_view_update_highlight (layer_view);
972 }
973
974
975 /* Paint Mode, Opacity and Lock alpha callbacks */
976
977 #define BLOCK() \
978 g_signal_handlers_block_by_func (layer, \
979 gimp_layer_tree_view_layer_signal_handler, view)
980
981 #define UNBLOCK() \
982 g_signal_handlers_unblock_by_func (layer, \
983 gimp_layer_tree_view_layer_signal_handler, view)
984
985
986 static void
gimp_layer_tree_view_layer_mode_box_callback(GtkWidget * widget,const GParamSpec * pspec,GimpLayerTreeView * view)987 gimp_layer_tree_view_layer_mode_box_callback (GtkWidget *widget,
988 const GParamSpec *pspec,
989 GimpLayerTreeView *view)
990 {
991 GimpImage *image;
992 GimpLayer *layer = NULL;
993
994 image = gimp_item_tree_view_get_image (GIMP_ITEM_TREE_VIEW (view));
995
996 if (image)
997 layer = (GimpLayer *)
998 GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
999
1000 if (layer)
1001 {
1002 GimpLayerMode mode =
1003 gimp_layer_mode_box_get_mode (GIMP_LAYER_MODE_BOX (widget));
1004
1005 if (gimp_layer_get_mode (layer) != mode)
1006 {
1007 GimpUndo *undo;
1008 gboolean push_undo = TRUE;
1009
1010 /* compress layer mode undos */
1011 undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
1012 GIMP_UNDO_LAYER_MODE);
1013
1014 if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
1015 push_undo = FALSE;
1016
1017 BLOCK();
1018 gimp_layer_set_mode (layer, (GimpLayerMode) mode, push_undo);
1019 UNBLOCK();
1020
1021 gimp_image_flush (image);
1022
1023 if (! push_undo)
1024 gimp_undo_refresh_preview (undo, gimp_container_view_get_context (GIMP_CONTAINER_VIEW (view)));
1025 }
1026 }
1027 }
1028
1029 static void
gimp_layer_tree_view_lock_alpha_button_toggled(GtkWidget * widget,GimpLayerTreeView * view)1030 gimp_layer_tree_view_lock_alpha_button_toggled (GtkWidget *widget,
1031 GimpLayerTreeView *view)
1032 {
1033 GimpImage *image;
1034 GimpLayer *layer;
1035
1036 image = gimp_item_tree_view_get_image (GIMP_ITEM_TREE_VIEW (view));
1037
1038 layer = (GimpLayer *)
1039 GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
1040
1041 if (layer)
1042 {
1043 gboolean lock_alpha;
1044
1045 lock_alpha = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
1046
1047 if (gimp_layer_get_lock_alpha (layer) != lock_alpha)
1048 {
1049 GimpUndo *undo;
1050 gboolean push_undo = TRUE;
1051
1052 /* compress lock alpha undos */
1053 undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
1054 GIMP_UNDO_LAYER_LOCK_ALPHA);
1055
1056 if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
1057 push_undo = FALSE;
1058
1059 BLOCK();
1060 gimp_layer_set_lock_alpha (layer, lock_alpha, push_undo);
1061 UNBLOCK();
1062
1063 gimp_image_flush (image);
1064 }
1065 }
1066 }
1067
1068 static void
gimp_layer_tree_view_opacity_scale_changed(GtkAdjustment * adjustment,GimpLayerTreeView * view)1069 gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adjustment,
1070 GimpLayerTreeView *view)
1071 {
1072 GimpImage *image;
1073 GimpLayer *layer;
1074
1075 image = gimp_item_tree_view_get_image (GIMP_ITEM_TREE_VIEW (view));
1076
1077 layer = (GimpLayer *)
1078 GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
1079
1080 if (layer)
1081 {
1082 gdouble opacity = gtk_adjustment_get_value (adjustment) / 100.0;
1083
1084 if (gimp_layer_get_opacity (layer) != opacity)
1085 {
1086 GimpUndo *undo;
1087 gboolean push_undo = TRUE;
1088
1089 /* compress opacity undos */
1090 undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
1091 GIMP_UNDO_LAYER_OPACITY);
1092
1093 if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
1094 push_undo = FALSE;
1095
1096 BLOCK();
1097 gimp_layer_set_opacity (layer, opacity, push_undo);
1098 UNBLOCK();
1099
1100 gimp_image_flush (image);
1101
1102 if (! push_undo)
1103 gimp_undo_refresh_preview (undo, gimp_container_view_get_context (GIMP_CONTAINER_VIEW (view)));
1104 }
1105 }
1106 }
1107
1108 #undef BLOCK
1109 #undef UNBLOCK
1110
1111
1112 static void
gimp_layer_tree_view_layer_signal_handler(GimpLayer * layer,GimpLayerTreeView * view)1113 gimp_layer_tree_view_layer_signal_handler (GimpLayer *layer,
1114 GimpLayerTreeView *view)
1115 {
1116 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
1117 GimpLayer *active_layer;
1118
1119 active_layer = (GimpLayer *)
1120 GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimp_item_tree_view_get_image (item_view));
1121
1122 if (active_layer == layer)
1123 gimp_layer_tree_view_update_options (view, layer);
1124 }
1125
1126
1127 #define BLOCK(object,function) \
1128 g_signal_handlers_block_by_func ((object), (function), view)
1129
1130 #define UNBLOCK(object,function) \
1131 g_signal_handlers_unblock_by_func ((object), (function), view)
1132
1133 static void
gimp_layer_tree_view_update_options(GimpLayerTreeView * view,GimpLayer * layer)1134 gimp_layer_tree_view_update_options (GimpLayerTreeView *view,
1135 GimpLayer *layer)
1136 {
1137 BLOCK (view->priv->layer_mode_box,
1138 gimp_layer_tree_view_layer_mode_box_callback);
1139
1140 if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)) == NULL)
1141 {
1142 gimp_layer_mode_box_set_context (GIMP_LAYER_MODE_BOX (view->priv->layer_mode_box),
1143 GIMP_LAYER_MODE_CONTEXT_LAYER);
1144 }
1145 else
1146 {
1147 gimp_layer_mode_box_set_context (GIMP_LAYER_MODE_BOX (view->priv->layer_mode_box),
1148 GIMP_LAYER_MODE_CONTEXT_GROUP);
1149 }
1150
1151 gimp_layer_mode_box_set_mode (GIMP_LAYER_MODE_BOX (view->priv->layer_mode_box),
1152 gimp_layer_get_mode (layer));
1153
1154 UNBLOCK (view->priv->layer_mode_box,
1155 gimp_layer_tree_view_layer_mode_box_callback);
1156
1157 if (gimp_layer_get_lock_alpha (layer) !=
1158 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view->priv->lock_alpha_toggle)))
1159 {
1160 BLOCK (view->priv->lock_alpha_toggle,
1161 gimp_layer_tree_view_lock_alpha_button_toggled);
1162
1163 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->priv->lock_alpha_toggle),
1164 gimp_layer_get_lock_alpha (layer));
1165
1166 UNBLOCK (view->priv->lock_alpha_toggle,
1167 gimp_layer_tree_view_lock_alpha_button_toggled);
1168 }
1169
1170 gtk_widget_set_sensitive (view->priv->lock_alpha_toggle,
1171 gimp_layer_can_lock_alpha (layer));
1172
1173 if (gimp_layer_get_opacity (layer) * 100.0 !=
1174 gtk_adjustment_get_value (view->priv->opacity_adjustment))
1175 {
1176 BLOCK (view->priv->opacity_adjustment,
1177 gimp_layer_tree_view_opacity_scale_changed);
1178
1179 gtk_adjustment_set_value (view->priv->opacity_adjustment,
1180 gimp_layer_get_opacity (layer) * 100.0);
1181
1182 UNBLOCK (view->priv->opacity_adjustment,
1183 gimp_layer_tree_view_opacity_scale_changed);
1184 }
1185 }
1186
1187 #undef BLOCK
1188 #undef UNBLOCK
1189
1190
1191 static void
gimp_layer_tree_view_update_menu(GimpLayerTreeView * layer_view,GimpLayer * layer)1192 gimp_layer_tree_view_update_menu (GimpLayerTreeView *layer_view,
1193 GimpLayer *layer)
1194 {
1195 GimpUIManager *ui_manager = gimp_editor_get_ui_manager (GIMP_EDITOR (layer_view));
1196 GimpActionGroup *group;
1197 GimpLayerMask *mask;
1198
1199 group = gimp_ui_manager_get_action_group (ui_manager, "layers");
1200
1201 mask = gimp_layer_get_mask (layer);
1202
1203 gimp_action_group_set_action_active (group, "layers-mask-show",
1204 mask &&
1205 gimp_layer_get_show_mask (layer));
1206 gimp_action_group_set_action_active (group, "layers-mask-disable",
1207 mask &&
1208 ! gimp_layer_get_apply_mask (layer));
1209 gimp_action_group_set_action_active (group, "layers-mask-edit",
1210 mask &&
1211 gimp_layer_get_edit_mask (layer));
1212 }
1213
1214 static void
gimp_layer_tree_view_update_highlight(GimpLayerTreeView * layer_view)1215 gimp_layer_tree_view_update_highlight (GimpLayerTreeView *layer_view)
1216 {
1217 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (layer_view);
1218 GimpImage *image = gimp_item_tree_view_get_image (item_view);
1219 GimpLayer *floating_sel = NULL;
1220
1221 if (image)
1222 floating_sel = gimp_image_get_floating_selection (image);
1223
1224 gimp_highlightable_button_set_highlight (
1225 GIMP_HIGHLIGHTABLE_BUTTON (gimp_item_tree_view_get_new_button (item_view)),
1226 floating_sel != NULL &&
1227 ! GIMP_IS_CHANNEL (gimp_layer_get_floating_sel_drawable (floating_sel)));
1228
1229 gimp_highlightable_button_set_highlight (
1230 GIMP_HIGHLIGHTABLE_BUTTON (gimp_item_tree_view_get_delete_button (item_view)),
1231 floating_sel != NULL);
1232
1233 gimp_highlightable_button_set_highlight (
1234 GIMP_HIGHLIGHTABLE_BUTTON (layer_view->priv->anchor_button),
1235 floating_sel != NULL);
1236 }
1237
1238
1239 /* Layer Mask callbacks */
1240
1241 static void
gimp_layer_tree_view_mask_update(GimpLayerTreeView * layer_view,GtkTreeIter * iter,GimpLayer * layer)1242 gimp_layer_tree_view_mask_update (GimpLayerTreeView *layer_view,
1243 GtkTreeIter *iter,
1244 GimpLayer *layer)
1245 {
1246 GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
1247 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
1248 GimpLayerMask *mask;
1249 GimpViewRenderer *renderer = NULL;
1250 gboolean mask_visible = FALSE;
1251
1252 mask = gimp_layer_get_mask (layer);
1253
1254 if (mask)
1255 {
1256 GClosure *closure;
1257 gint view_size;
1258 gint border_width;
1259
1260 view_size = gimp_container_view_get_view_size (view, &border_width);
1261
1262 mask_visible = TRUE;
1263
1264 renderer = gimp_view_renderer_new (gimp_container_view_get_context (view),
1265 G_TYPE_FROM_INSTANCE (mask),
1266 view_size, border_width,
1267 FALSE);
1268 gimp_view_renderer_set_viewable (renderer, GIMP_VIEWABLE (mask));
1269
1270 g_signal_connect (renderer, "update",
1271 G_CALLBACK (gimp_layer_tree_view_renderer_update),
1272 layer_view);
1273
1274 closure = g_cclosure_new (G_CALLBACK (gimp_layer_tree_view_mask_callback),
1275 layer_view, NULL);
1276 g_object_watch_closure (G_OBJECT (renderer), closure);
1277 g_signal_connect_closure (layer, "apply-mask-changed", closure, FALSE);
1278 g_signal_connect_closure (layer, "edit-mask-changed", closure, FALSE);
1279 g_signal_connect_closure (layer, "show-mask-changed", closure, FALSE);
1280 }
1281
1282 gtk_tree_store_set (GTK_TREE_STORE (tree_view->model), iter,
1283 layer_view->priv->model_column_mask, renderer,
1284 layer_view->priv->model_column_mask_visible, mask_visible,
1285 -1);
1286
1287 gimp_layer_tree_view_update_borders (layer_view, iter);
1288
1289 if (renderer)
1290 {
1291 gimp_view_renderer_remove_idle (renderer);
1292 g_object_unref (renderer);
1293 }
1294 }
1295
1296 static void
gimp_layer_tree_view_mask_changed(GimpLayer * layer,GimpLayerTreeView * layer_view)1297 gimp_layer_tree_view_mask_changed (GimpLayer *layer,
1298 GimpLayerTreeView *layer_view)
1299 {
1300 GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
1301 GtkTreeIter *iter;
1302
1303 iter = gimp_container_view_lookup (view, GIMP_VIEWABLE (layer));
1304
1305 if (iter)
1306 gimp_layer_tree_view_mask_update (layer_view, iter, layer);
1307 }
1308
1309 static void
gimp_layer_tree_view_renderer_update(GimpViewRenderer * renderer,GimpLayerTreeView * layer_view)1310 gimp_layer_tree_view_renderer_update (GimpViewRenderer *renderer,
1311 GimpLayerTreeView *layer_view)
1312 {
1313 GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
1314 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
1315 GimpLayerMask *mask;
1316 GtkTreeIter *iter;
1317
1318 mask = GIMP_LAYER_MASK (renderer->viewable);
1319
1320 iter = gimp_container_view_lookup (view, (GimpViewable *)
1321 gimp_layer_mask_get_layer (mask));
1322
1323 if (iter)
1324 {
1325 GtkTreePath *path;
1326
1327 path = gtk_tree_model_get_path (tree_view->model, iter);
1328
1329 gtk_tree_model_row_changed (tree_view->model, path, iter);
1330
1331 gtk_tree_path_free (path);
1332 }
1333 }
1334
1335 static void
gimp_layer_tree_view_update_borders(GimpLayerTreeView * layer_view,GtkTreeIter * iter)1336 gimp_layer_tree_view_update_borders (GimpLayerTreeView *layer_view,
1337 GtkTreeIter *iter)
1338 {
1339 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
1340 GimpViewRenderer *layer_renderer;
1341 GimpViewRenderer *mask_renderer;
1342 GimpLayer *layer;
1343 GimpLayerMask *mask = NULL;
1344 GimpViewBorderType layer_type = GIMP_VIEW_BORDER_BLACK;
1345
1346 gtk_tree_model_get (tree_view->model, iter,
1347 GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &layer_renderer,
1348 layer_view->priv->model_column_mask, &mask_renderer,
1349 -1);
1350
1351 layer = GIMP_LAYER (layer_renderer->viewable);
1352
1353 if (mask_renderer)
1354 mask = GIMP_LAYER_MASK (mask_renderer->viewable);
1355
1356 if (! mask || (mask && ! gimp_layer_get_edit_mask (layer)))
1357 layer_type = GIMP_VIEW_BORDER_WHITE;
1358
1359 gimp_view_renderer_set_border_type (layer_renderer, layer_type);
1360
1361 if (mask)
1362 {
1363 GimpViewBorderType mask_color = GIMP_VIEW_BORDER_BLACK;
1364
1365 if (gimp_layer_get_show_mask (layer))
1366 {
1367 mask_color = GIMP_VIEW_BORDER_GREEN;
1368 }
1369 else if (! gimp_layer_get_apply_mask (layer))
1370 {
1371 mask_color = GIMP_VIEW_BORDER_RED;
1372 }
1373 else if (gimp_layer_get_edit_mask (layer))
1374 {
1375 mask_color = GIMP_VIEW_BORDER_WHITE;
1376 }
1377
1378 gimp_view_renderer_set_border_type (mask_renderer, mask_color);
1379 }
1380
1381 if (layer_renderer)
1382 g_object_unref (layer_renderer);
1383
1384 if (mask_renderer)
1385 g_object_unref (mask_renderer);
1386 }
1387
1388 static void
gimp_layer_tree_view_mask_callback(GimpLayer * layer,GimpLayerTreeView * layer_view)1389 gimp_layer_tree_view_mask_callback (GimpLayer *layer,
1390 GimpLayerTreeView *layer_view)
1391 {
1392 GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
1393 GtkTreeIter *iter;
1394
1395 iter = gimp_container_view_lookup (view, (GimpViewable *) layer);
1396
1397 gimp_layer_tree_view_update_borders (layer_view, iter);
1398 }
1399
1400 static void
gimp_layer_tree_view_layer_clicked(GimpCellRendererViewable * cell,const gchar * path_str,GdkModifierType state,GimpLayerTreeView * layer_view)1401 gimp_layer_tree_view_layer_clicked (GimpCellRendererViewable *cell,
1402 const gchar *path_str,
1403 GdkModifierType state,
1404 GimpLayerTreeView *layer_view)
1405 {
1406 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
1407 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
1408 GtkTreeIter iter;
1409
1410 if (gtk_tree_model_get_iter (tree_view->model, &iter, path) &&
1411 ! (state & GDK_MOD1_MASK))
1412 {
1413 GimpUIManager *ui_manager;
1414 GimpActionGroup *group;
1415 GimpViewRenderer *renderer;
1416
1417 ui_manager = gimp_editor_get_ui_manager (GIMP_EDITOR (tree_view));
1418 group = gimp_ui_manager_get_action_group (ui_manager, "layers");
1419
1420 gtk_tree_model_get (tree_view->model, &iter,
1421 GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer,
1422 -1);
1423
1424 if (renderer)
1425 {
1426 GimpLayer *layer = GIMP_LAYER (renderer->viewable);
1427 GimpLayerMask *mask = gimp_layer_get_mask (layer);
1428
1429 if (state & gimp_get_extend_selection_mask ())
1430 {
1431 if (state & gimp_get_modify_selection_mask ())
1432 {
1433 /* Shift-Control-click apply a layer mask */
1434
1435 if (mask)
1436 gimp_ui_manager_activate_action (ui_manager, "layers",
1437 "layers-mask-apply");
1438 }
1439 else
1440 {
1441 /* Shift-click add a layer mask with last values */
1442
1443 if (! mask)
1444 gimp_ui_manager_activate_action (ui_manager, "layers",
1445 "layers-mask-add-last-values");
1446 }
1447 }
1448 else if (state & gimp_get_modify_selection_mask ())
1449 {
1450 /* Control-click remove a layer mask */
1451
1452 if (mask)
1453 gimp_ui_manager_activate_action (ui_manager, "layers",
1454 "layers-mask-delete");
1455 }
1456 else if (mask && gimp_layer_get_edit_mask (layer))
1457 {
1458 /* other clicks activate the layer */
1459
1460 if (mask)
1461 gimp_action_group_set_action_active (group,
1462 "layers-mask-edit", FALSE);
1463 }
1464
1465 g_object_unref (renderer);
1466 }
1467 }
1468
1469 gtk_tree_path_free (path);
1470 }
1471
1472 static void
gimp_layer_tree_view_mask_clicked(GimpCellRendererViewable * cell,const gchar * path_str,GdkModifierType state,GimpLayerTreeView * layer_view)1473 gimp_layer_tree_view_mask_clicked (GimpCellRendererViewable *cell,
1474 const gchar *path_str,
1475 GdkModifierType state,
1476 GimpLayerTreeView *layer_view)
1477 {
1478 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view);
1479 GtkTreePath *path;
1480 GtkTreeIter iter;
1481
1482 path = gtk_tree_path_new_from_string (path_str);
1483
1484 if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
1485 {
1486 GimpViewRenderer *renderer;
1487 GimpUIManager *ui_manager;
1488 GimpActionGroup *group;
1489
1490 ui_manager = gimp_editor_get_ui_manager (GIMP_EDITOR (tree_view));
1491 group = gimp_ui_manager_get_action_group (ui_manager, "layers");
1492
1493 gtk_tree_model_get (tree_view->model, &iter,
1494 GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer,
1495 -1);
1496
1497 if (renderer)
1498 {
1499 GimpLayer *layer = GIMP_LAYER (renderer->viewable);
1500
1501 if (state & GDK_MOD1_MASK)
1502 gimp_action_group_set_action_active (group, "layers-mask-show",
1503 ! gimp_layer_get_show_mask (layer));
1504 else if (state & gimp_get_toggle_behavior_mask ())
1505 gimp_action_group_set_action_active (group, "layers-mask-disable",
1506 gimp_layer_get_apply_mask (layer));
1507 else if (! gimp_layer_get_edit_mask (layer))
1508 gimp_action_group_set_action_active (group,
1509 "layers-mask-edit", TRUE);
1510
1511 g_object_unref (renderer);
1512 }
1513 }
1514
1515 gtk_tree_path_free (path);
1516 }
1517
1518
1519 /* GimpDrawable alpha callbacks */
1520
1521 static void
gimp_layer_tree_view_alpha_update(GimpLayerTreeView * view,GtkTreeIter * iter,GimpLayer * layer)1522 gimp_layer_tree_view_alpha_update (GimpLayerTreeView *view,
1523 GtkTreeIter *iter,
1524 GimpLayer *layer)
1525 {
1526 GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
1527
1528 gtk_tree_store_set (GTK_TREE_STORE (tree_view->model), iter,
1529 GIMP_CONTAINER_TREE_STORE_COLUMN_NAME_ATTRIBUTES,
1530 gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)) ?
1531 NULL : view->priv->bold_attrs,
1532 -1);
1533 }
1534
1535 static void
gimp_layer_tree_view_alpha_changed(GimpLayer * layer,GimpLayerTreeView * layer_view)1536 gimp_layer_tree_view_alpha_changed (GimpLayer *layer,
1537 GimpLayerTreeView *layer_view)
1538 {
1539 GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view);
1540 GtkTreeIter *iter;
1541
1542 iter = gimp_container_view_lookup (view, (GimpViewable *) layer);
1543
1544 if (iter)
1545 {
1546 GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view);
1547
1548 gimp_layer_tree_view_alpha_update (layer_view, iter, layer);
1549
1550 /* update button states */
1551 if (gimp_image_get_active_layer (gimp_item_tree_view_get_image (item_view)) == layer)
1552 gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view),
1553 GIMP_VIEWABLE (layer));
1554 }
1555 }
1556