1 /* GIMP - The GNU Image Manipulation Program
2 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 */
17
18 #include "config.h"
19
20 #include <string.h>
21 #include <time.h>
22
23 #include <cairo.h>
24 #include <gdk-pixbuf/gdk-pixbuf.h>
25 #include <gegl.h>
26 #include <gexiv2/gexiv2.h>
27
28 #include "libgimpcolor/gimpcolor.h"
29 #include "libgimpmath/gimpmath.h"
30 #include "libgimpbase/gimpbase.h"
31 #include "libgimpconfig/gimpconfig.h"
32
33 #include "core-types.h"
34
35 #include "config/gimpcoreconfig.h"
36
37 #include "operations/layer-modes/gimp-layer-modes.h"
38
39 #include "gegl/gimp-babl.h"
40 #include "gegl/gimp-gegl-loops.h"
41
42 #include "gimp.h"
43 #include "gimp-memsize.h"
44 #include "gimp-parasites.h"
45 #include "gimp-utils.h"
46 #include "gimpcontext.h"
47 #include "gimpdrawable-floating-selection.h"
48 #include "gimpdrawablestack.h"
49 #include "gimpgrid.h"
50 #include "gimperror.h"
51 #include "gimpguide.h"
52 #include "gimpidtable.h"
53 #include "gimpimage.h"
54 #include "gimpimage-color-profile.h"
55 #include "gimpimage-colormap.h"
56 #include "gimpimage-guides.h"
57 #include "gimpimage-item-list.h"
58 #include "gimpimage-metadata.h"
59 #include "gimpimage-sample-points.h"
60 #include "gimpimage-preview.h"
61 #include "gimpimage-private.h"
62 #include "gimpimage-quick-mask.h"
63 #include "gimpimage-symmetry.h"
64 #include "gimpimage-undo.h"
65 #include "gimpimage-undo-push.h"
66 #include "gimpitemtree.h"
67 #include "gimplayer.h"
68 #include "gimplayer-floating-selection.h"
69 #include "gimplayermask.h"
70 #include "gimplayerstack.h"
71 #include "gimpmarshal.h"
72 #include "gimpparasitelist.h"
73 #include "gimppickable.h"
74 #include "gimpprojectable.h"
75 #include "gimpprojection.h"
76 #include "gimpsamplepoint.h"
77 #include "gimpselection.h"
78 #include "gimpsymmetry.h"
79 #include "gimptempbuf.h"
80 #include "gimptemplate.h"
81 #include "gimpundostack.h"
82
83 #include "vectors/gimpvectors.h"
84
85 #include "gimp-log.h"
86 #include "gimp-intl.h"
87
88
89 #ifdef DEBUG
90 #define TRC(x) g_printerr x
91 #else
92 #define TRC(x)
93 #endif
94
95
96 enum
97 {
98 MODE_CHANGED,
99 PRECISION_CHANGED,
100 ALPHA_CHANGED,
101 FLOATING_SELECTION_CHANGED,
102 ACTIVE_LAYER_CHANGED,
103 ACTIVE_CHANNEL_CHANGED,
104 ACTIVE_VECTORS_CHANGED,
105 LINKED_ITEMS_CHANGED,
106 COMPONENT_VISIBILITY_CHANGED,
107 COMPONENT_ACTIVE_CHANGED,
108 MASK_CHANGED,
109 RESOLUTION_CHANGED,
110 SIZE_CHANGED_DETAILED,
111 UNIT_CHANGED,
112 QUICK_MASK_CHANGED,
113 SELECTION_INVALIDATE,
114 CLEAN,
115 DIRTY,
116 SAVING,
117 SAVED,
118 EXPORTED,
119 GUIDE_ADDED,
120 GUIDE_REMOVED,
121 GUIDE_MOVED,
122 SAMPLE_POINT_ADDED,
123 SAMPLE_POINT_REMOVED,
124 SAMPLE_POINT_MOVED,
125 PARASITE_ATTACHED,
126 PARASITE_DETACHED,
127 COLORMAP_CHANGED,
128 UNDO_EVENT,
129 LAST_SIGNAL
130 };
131
132 enum
133 {
134 PROP_0,
135 PROP_GIMP,
136 PROP_ID,
137 PROP_WIDTH,
138 PROP_HEIGHT,
139 PROP_BASE_TYPE,
140 PROP_PRECISION,
141 PROP_METADATA,
142 PROP_BUFFER,
143 PROP_SYMMETRY
144 };
145
146
147 /* local function prototypes */
148
149 static void gimp_color_managed_iface_init (GimpColorManagedInterface *iface);
150 static void gimp_projectable_iface_init (GimpProjectableInterface *iface);
151 static void gimp_pickable_iface_init (GimpPickableInterface *iface);
152
153 static void gimp_image_constructed (GObject *object);
154 static void gimp_image_set_property (GObject *object,
155 guint property_id,
156 const GValue *value,
157 GParamSpec *pspec);
158 static void gimp_image_get_property (GObject *object,
159 guint property_id,
160 GValue *value,
161 GParamSpec *pspec);
162 static void gimp_image_dispose (GObject *object);
163 static void gimp_image_finalize (GObject *object);
164
165 static void gimp_image_name_changed (GimpObject *object);
166 static gint64 gimp_image_get_memsize (GimpObject *object,
167 gint64 *gui_size);
168
169 static gboolean gimp_image_get_size (GimpViewable *viewable,
170 gint *width,
171 gint *height);
172 static void gimp_image_size_changed (GimpViewable *viewable);
173 static gchar * gimp_image_get_description (GimpViewable *viewable,
174 gchar **tooltip);
175
176 static void gimp_image_real_mode_changed (GimpImage *image);
177 static void gimp_image_real_precision_changed(GimpImage *image);
178 static void gimp_image_real_resolution_changed(GimpImage *image);
179 static void gimp_image_real_size_changed_detailed
180 (GimpImage *image,
181 gint previous_origin_x,
182 gint previous_origin_y,
183 gint previous_width,
184 gint previous_height);
185 static void gimp_image_real_unit_changed (GimpImage *image);
186 static void gimp_image_real_colormap_changed (GimpImage *image,
187 gint color_index);
188
189 static const guint8 *
190 gimp_image_color_managed_get_icc_profile (GimpColorManaged *managed,
191 gsize *len);
192 static GimpColorProfile *
193 gimp_image_color_managed_get_color_profile (GimpColorManaged *managed);
194 static void
195 gimp_image_color_managed_profile_changed (GimpColorManaged *managed);
196
197 static void gimp_image_projectable_flush (GimpProjectable *projectable,
198 gboolean invalidate_preview);
199 static GeglRectangle gimp_image_get_bounding_box (GimpProjectable *projectable);
200 static GeglNode * gimp_image_get_graph (GimpProjectable *projectable);
201 static GimpImage * gimp_image_get_image (GimpProjectable *projectable);
202 static const Babl * gimp_image_get_proj_format (GimpProjectable *projectable);
203
204 static void gimp_image_pickable_flush (GimpPickable *pickable);
205 static GeglBuffer * gimp_image_get_buffer (GimpPickable *pickable);
206 static gboolean gimp_image_get_pixel_at (GimpPickable *pickable,
207 gint x,
208 gint y,
209 const Babl *format,
210 gpointer pixel);
211 static gdouble gimp_image_get_opacity_at (GimpPickable *pickable,
212 gint x,
213 gint y);
214 static void gimp_image_get_pixel_average (GimpPickable *pickable,
215 const GeglRectangle *rect,
216 const Babl *format,
217 gpointer pixel);
218 static void gimp_image_pixel_to_srgb (GimpPickable *pickable,
219 const Babl *format,
220 gpointer pixel,
221 GimpRGB *color);
222 static void gimp_image_srgb_to_pixel (GimpPickable *pickable,
223 const GimpRGB *color,
224 const Babl *format,
225 gpointer pixel);
226
227 static void gimp_image_projection_buffer_notify
228 (GimpProjection *projection,
229 const GParamSpec *pspec,
230 GimpImage *image);
231 static void gimp_image_mask_update (GimpDrawable *drawable,
232 gint x,
233 gint y,
234 gint width,
235 gint height,
236 GimpImage *image);
237 static void gimp_image_layers_changed (GimpContainer *container,
238 GimpChannel *channel,
239 GimpImage *image);
240 static void gimp_image_layer_offset_changed (GimpDrawable *drawable,
241 const GParamSpec *pspec,
242 GimpImage *image);
243 static void gimp_image_layer_bounding_box_changed
244 (GimpDrawable *drawable,
245 GimpImage *image);
246 static void gimp_image_layer_alpha_changed (GimpDrawable *drawable,
247 GimpImage *image);
248 static void gimp_image_channel_add (GimpContainer *container,
249 GimpChannel *channel,
250 GimpImage *image);
251 static void gimp_image_channel_remove (GimpContainer *container,
252 GimpChannel *channel,
253 GimpImage *image);
254 static void gimp_image_channel_name_changed (GimpChannel *channel,
255 GimpImage *image);
256 static void gimp_image_channel_color_changed (GimpChannel *channel,
257 GimpImage *image);
258 static void gimp_image_active_layer_notify (GimpItemTree *tree,
259 const GParamSpec *pspec,
260 GimpImage *image);
261 static void gimp_image_active_channel_notify (GimpItemTree *tree,
262 const GParamSpec *pspec,
263 GimpImage *image);
264 static void gimp_image_active_vectors_notify (GimpItemTree *tree,
265 const GParamSpec *pspec,
266 GimpImage *image);
267
268 static void gimp_image_freeze_bounding_box (GimpImage *image);
269 static void gimp_image_thaw_bounding_box (GimpImage *image);
270 static void gimp_image_update_bounding_box (GimpImage *image);
271
272
273 G_DEFINE_TYPE_WITH_CODE (GimpImage, gimp_image, GIMP_TYPE_VIEWABLE,
274 G_ADD_PRIVATE (GimpImage)
275 G_IMPLEMENT_INTERFACE (GIMP_TYPE_COLOR_MANAGED,
276 gimp_color_managed_iface_init)
277 G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROJECTABLE,
278 gimp_projectable_iface_init)
279 G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
280 gimp_pickable_iface_init))
281
282 #define parent_class gimp_image_parent_class
283
284 static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
285
286
287 static void
gimp_image_class_init(GimpImageClass * klass)288 gimp_image_class_init (GimpImageClass *klass)
289 {
290 GObjectClass *object_class = G_OBJECT_CLASS (klass);
291 GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
292 GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass);
293
294 gimp_image_signals[MODE_CHANGED] =
295 g_signal_new ("mode-changed",
296 G_TYPE_FROM_CLASS (klass),
297 G_SIGNAL_RUN_FIRST,
298 G_STRUCT_OFFSET (GimpImageClass, mode_changed),
299 NULL, NULL,
300 gimp_marshal_VOID__VOID,
301 G_TYPE_NONE, 0);
302
303 gimp_image_signals[PRECISION_CHANGED] =
304 g_signal_new ("precision-changed",
305 G_TYPE_FROM_CLASS (klass),
306 G_SIGNAL_RUN_FIRST,
307 G_STRUCT_OFFSET (GimpImageClass, precision_changed),
308 NULL, NULL,
309 gimp_marshal_VOID__VOID,
310 G_TYPE_NONE, 0);
311
312 gimp_image_signals[ALPHA_CHANGED] =
313 g_signal_new ("alpha-changed",
314 G_TYPE_FROM_CLASS (klass),
315 G_SIGNAL_RUN_FIRST,
316 G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
317 NULL, NULL,
318 gimp_marshal_VOID__VOID,
319 G_TYPE_NONE, 0);
320
321 gimp_image_signals[FLOATING_SELECTION_CHANGED] =
322 g_signal_new ("floating-selection-changed",
323 G_TYPE_FROM_CLASS (klass),
324 G_SIGNAL_RUN_FIRST,
325 G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
326 NULL, NULL,
327 gimp_marshal_VOID__VOID,
328 G_TYPE_NONE, 0);
329
330 gimp_image_signals[ACTIVE_LAYER_CHANGED] =
331 g_signal_new ("active-layer-changed",
332 G_TYPE_FROM_CLASS (klass),
333 G_SIGNAL_RUN_FIRST,
334 G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
335 NULL, NULL,
336 gimp_marshal_VOID__VOID,
337 G_TYPE_NONE, 0);
338
339 gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
340 g_signal_new ("active-channel-changed",
341 G_TYPE_FROM_CLASS (klass),
342 G_SIGNAL_RUN_FIRST,
343 G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
344 NULL, NULL,
345 gimp_marshal_VOID__VOID,
346 G_TYPE_NONE, 0);
347
348 gimp_image_signals[ACTIVE_VECTORS_CHANGED] =
349 g_signal_new ("active-vectors-changed",
350 G_TYPE_FROM_CLASS (klass),
351 G_SIGNAL_RUN_FIRST,
352 G_STRUCT_OFFSET (GimpImageClass, active_vectors_changed),
353 NULL, NULL,
354 gimp_marshal_VOID__VOID,
355 G_TYPE_NONE, 0);
356
357 gimp_image_signals[LINKED_ITEMS_CHANGED] =
358 g_signal_new ("linked-items-changed",
359 G_TYPE_FROM_CLASS (klass),
360 G_SIGNAL_RUN_FIRST,
361 G_STRUCT_OFFSET (GimpImageClass, linked_items_changed),
362 NULL, NULL,
363 gimp_marshal_VOID__VOID,
364 G_TYPE_NONE, 0);
365
366 gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
367 g_signal_new ("component-visibility-changed",
368 G_TYPE_FROM_CLASS (klass),
369 G_SIGNAL_RUN_FIRST,
370 G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
371 NULL, NULL,
372 gimp_marshal_VOID__ENUM,
373 G_TYPE_NONE, 1,
374 GIMP_TYPE_CHANNEL_TYPE);
375
376 gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
377 g_signal_new ("component-active-changed",
378 G_TYPE_FROM_CLASS (klass),
379 G_SIGNAL_RUN_FIRST,
380 G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
381 NULL, NULL,
382 gimp_marshal_VOID__ENUM,
383 G_TYPE_NONE, 1,
384 GIMP_TYPE_CHANNEL_TYPE);
385
386 gimp_image_signals[MASK_CHANGED] =
387 g_signal_new ("mask-changed",
388 G_TYPE_FROM_CLASS (klass),
389 G_SIGNAL_RUN_FIRST,
390 G_STRUCT_OFFSET (GimpImageClass, mask_changed),
391 NULL, NULL,
392 gimp_marshal_VOID__VOID,
393 G_TYPE_NONE, 0);
394
395 gimp_image_signals[RESOLUTION_CHANGED] =
396 g_signal_new ("resolution-changed",
397 G_TYPE_FROM_CLASS (klass),
398 G_SIGNAL_RUN_FIRST,
399 G_STRUCT_OFFSET (GimpImageClass, resolution_changed),
400 NULL, NULL,
401 gimp_marshal_VOID__VOID,
402 G_TYPE_NONE, 0);
403
404 gimp_image_signals[SIZE_CHANGED_DETAILED] =
405 g_signal_new ("size-changed-detailed",
406 G_TYPE_FROM_CLASS (klass),
407 G_SIGNAL_RUN_FIRST,
408 G_STRUCT_OFFSET (GimpImageClass, size_changed_detailed),
409 NULL, NULL,
410 gimp_marshal_VOID__INT_INT_INT_INT,
411 G_TYPE_NONE, 4,
412 G_TYPE_INT,
413 G_TYPE_INT,
414 G_TYPE_INT,
415 G_TYPE_INT);
416
417 gimp_image_signals[UNIT_CHANGED] =
418 g_signal_new ("unit-changed",
419 G_TYPE_FROM_CLASS (klass),
420 G_SIGNAL_RUN_FIRST,
421 G_STRUCT_OFFSET (GimpImageClass, unit_changed),
422 NULL, NULL,
423 gimp_marshal_VOID__VOID,
424 G_TYPE_NONE, 0);
425
426 gimp_image_signals[QUICK_MASK_CHANGED] =
427 g_signal_new ("quick-mask-changed",
428 G_TYPE_FROM_CLASS (klass),
429 G_SIGNAL_RUN_FIRST,
430 G_STRUCT_OFFSET (GimpImageClass, quick_mask_changed),
431 NULL, NULL,
432 gimp_marshal_VOID__VOID,
433 G_TYPE_NONE, 0);
434
435 gimp_image_signals[SELECTION_INVALIDATE] =
436 g_signal_new ("selection-invalidate",
437 G_TYPE_FROM_CLASS (klass),
438 G_SIGNAL_RUN_FIRST,
439 G_STRUCT_OFFSET (GimpImageClass, selection_invalidate),
440 NULL, NULL,
441 gimp_marshal_VOID__VOID,
442 G_TYPE_NONE, 0);
443
444 gimp_image_signals[CLEAN] =
445 g_signal_new ("clean",
446 G_TYPE_FROM_CLASS (klass),
447 G_SIGNAL_RUN_FIRST,
448 G_STRUCT_OFFSET (GimpImageClass, clean),
449 NULL, NULL,
450 gimp_marshal_VOID__FLAGS,
451 G_TYPE_NONE, 1,
452 GIMP_TYPE_DIRTY_MASK);
453
454 gimp_image_signals[DIRTY] =
455 g_signal_new ("dirty",
456 G_TYPE_FROM_CLASS (klass),
457 G_SIGNAL_RUN_FIRST,
458 G_STRUCT_OFFSET (GimpImageClass, dirty),
459 NULL, NULL,
460 gimp_marshal_VOID__FLAGS,
461 G_TYPE_NONE, 1,
462 GIMP_TYPE_DIRTY_MASK);
463
464 gimp_image_signals[SAVING] =
465 g_signal_new ("saving",
466 G_TYPE_FROM_CLASS (klass),
467 G_SIGNAL_RUN_FIRST,
468 G_STRUCT_OFFSET (GimpImageClass, saving),
469 NULL, NULL,
470 gimp_marshal_VOID__VOID,
471 G_TYPE_NONE, 0);
472
473 gimp_image_signals[SAVED] =
474 g_signal_new ("saved",
475 G_TYPE_FROM_CLASS (klass),
476 G_SIGNAL_RUN_FIRST,
477 G_STRUCT_OFFSET (GimpImageClass, saved),
478 NULL, NULL,
479 gimp_marshal_VOID__OBJECT,
480 G_TYPE_NONE, 1,
481 G_TYPE_FILE);
482
483 gimp_image_signals[EXPORTED] =
484 g_signal_new ("exported",
485 G_TYPE_FROM_CLASS (klass),
486 G_SIGNAL_RUN_FIRST,
487 G_STRUCT_OFFSET (GimpImageClass, exported),
488 NULL, NULL,
489 gimp_marshal_VOID__OBJECT,
490 G_TYPE_NONE, 1,
491 G_TYPE_FILE);
492
493 gimp_image_signals[GUIDE_ADDED] =
494 g_signal_new ("guide-added",
495 G_TYPE_FROM_CLASS (klass),
496 G_SIGNAL_RUN_FIRST,
497 G_STRUCT_OFFSET (GimpImageClass, guide_added),
498 NULL, NULL,
499 gimp_marshal_VOID__OBJECT,
500 G_TYPE_NONE, 1,
501 GIMP_TYPE_GUIDE);
502
503 gimp_image_signals[GUIDE_REMOVED] =
504 g_signal_new ("guide-removed",
505 G_TYPE_FROM_CLASS (klass),
506 G_SIGNAL_RUN_FIRST,
507 G_STRUCT_OFFSET (GimpImageClass, guide_removed),
508 NULL, NULL,
509 gimp_marshal_VOID__OBJECT,
510 G_TYPE_NONE, 1,
511 GIMP_TYPE_GUIDE);
512
513 gimp_image_signals[GUIDE_MOVED] =
514 g_signal_new ("guide-moved",
515 G_TYPE_FROM_CLASS (klass),
516 G_SIGNAL_RUN_FIRST,
517 G_STRUCT_OFFSET (GimpImageClass, guide_moved),
518 NULL, NULL,
519 gimp_marshal_VOID__OBJECT,
520 G_TYPE_NONE, 1,
521 GIMP_TYPE_GUIDE);
522
523 gimp_image_signals[SAMPLE_POINT_ADDED] =
524 g_signal_new ("sample-point-added",
525 G_TYPE_FROM_CLASS (klass),
526 G_SIGNAL_RUN_FIRST,
527 G_STRUCT_OFFSET (GimpImageClass, sample_point_added),
528 NULL, NULL,
529 gimp_marshal_VOID__OBJECT,
530 G_TYPE_NONE, 1,
531 GIMP_TYPE_SAMPLE_POINT);
532
533 gimp_image_signals[SAMPLE_POINT_REMOVED] =
534 g_signal_new ("sample-point-removed",
535 G_TYPE_FROM_CLASS (klass),
536 G_SIGNAL_RUN_FIRST,
537 G_STRUCT_OFFSET (GimpImageClass, sample_point_removed),
538 NULL, NULL,
539 gimp_marshal_VOID__OBJECT,
540 G_TYPE_NONE, 1,
541 GIMP_TYPE_SAMPLE_POINT);
542
543 gimp_image_signals[SAMPLE_POINT_MOVED] =
544 g_signal_new ("sample-point-moved",
545 G_TYPE_FROM_CLASS (klass),
546 G_SIGNAL_RUN_FIRST,
547 G_STRUCT_OFFSET (GimpImageClass, sample_point_moved),
548 NULL, NULL,
549 gimp_marshal_VOID__OBJECT,
550 G_TYPE_NONE, 1,
551 GIMP_TYPE_SAMPLE_POINT);
552
553 gimp_image_signals[PARASITE_ATTACHED] =
554 g_signal_new ("parasite-attached",
555 G_TYPE_FROM_CLASS (klass),
556 G_SIGNAL_RUN_FIRST,
557 G_STRUCT_OFFSET (GimpImageClass, parasite_attached),
558 NULL, NULL,
559 g_cclosure_marshal_VOID__STRING,
560 G_TYPE_NONE, 1,
561 G_TYPE_STRING);
562
563 gimp_image_signals[PARASITE_DETACHED] =
564 g_signal_new ("parasite-detached",
565 G_TYPE_FROM_CLASS (klass),
566 G_SIGNAL_RUN_FIRST,
567 G_STRUCT_OFFSET (GimpImageClass, parasite_detached),
568 NULL, NULL,
569 g_cclosure_marshal_VOID__STRING,
570 G_TYPE_NONE, 1,
571 G_TYPE_STRING);
572
573 gimp_image_signals[COLORMAP_CHANGED] =
574 g_signal_new ("colormap-changed",
575 G_TYPE_FROM_CLASS (klass),
576 G_SIGNAL_RUN_FIRST,
577 G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
578 NULL, NULL,
579 gimp_marshal_VOID__INT,
580 G_TYPE_NONE, 1,
581 G_TYPE_INT);
582
583 gimp_image_signals[UNDO_EVENT] =
584 g_signal_new ("undo-event",
585 G_TYPE_FROM_CLASS (klass),
586 G_SIGNAL_RUN_FIRST,
587 G_STRUCT_OFFSET (GimpImageClass, undo_event),
588 NULL, NULL,
589 gimp_marshal_VOID__ENUM_OBJECT,
590 G_TYPE_NONE, 2,
591 GIMP_TYPE_UNDO_EVENT,
592 GIMP_TYPE_UNDO);
593
594 object_class->constructed = gimp_image_constructed;
595 object_class->set_property = gimp_image_set_property;
596 object_class->get_property = gimp_image_get_property;
597 object_class->dispose = gimp_image_dispose;
598 object_class->finalize = gimp_image_finalize;
599
600 gimp_object_class->name_changed = gimp_image_name_changed;
601 gimp_object_class->get_memsize = gimp_image_get_memsize;
602
603 viewable_class->default_icon_name = "gimp-image";
604 viewable_class->get_size = gimp_image_get_size;
605 viewable_class->size_changed = gimp_image_size_changed;
606 viewable_class->get_preview_size = gimp_image_get_preview_size;
607 viewable_class->get_popup_size = gimp_image_get_popup_size;
608 viewable_class->get_new_preview = gimp_image_get_new_preview;
609 viewable_class->get_new_pixbuf = gimp_image_get_new_pixbuf;
610 viewable_class->get_description = gimp_image_get_description;
611
612 klass->mode_changed = gimp_image_real_mode_changed;
613 klass->precision_changed = gimp_image_real_precision_changed;
614 klass->alpha_changed = NULL;
615 klass->floating_selection_changed = NULL;
616 klass->active_layer_changed = NULL;
617 klass->active_channel_changed = NULL;
618 klass->active_vectors_changed = NULL;
619 klass->linked_items_changed = NULL;
620 klass->component_visibility_changed = NULL;
621 klass->component_active_changed = NULL;
622 klass->mask_changed = NULL;
623 klass->resolution_changed = gimp_image_real_resolution_changed;
624 klass->size_changed_detailed = gimp_image_real_size_changed_detailed;
625 klass->unit_changed = gimp_image_real_unit_changed;
626 klass->quick_mask_changed = NULL;
627 klass->selection_invalidate = NULL;
628
629 klass->clean = NULL;
630 klass->dirty = NULL;
631 klass->saving = NULL;
632 klass->saved = NULL;
633 klass->exported = NULL;
634 klass->guide_added = NULL;
635 klass->guide_removed = NULL;
636 klass->guide_moved = NULL;
637 klass->sample_point_added = NULL;
638 klass->sample_point_removed = NULL;
639 klass->sample_point_moved = NULL;
640 klass->parasite_attached = NULL;
641 klass->parasite_detached = NULL;
642 klass->colormap_changed = gimp_image_real_colormap_changed;
643 klass->undo_event = NULL;
644
645 g_object_class_install_property (object_class, PROP_GIMP,
646 g_param_spec_object ("gimp", NULL, NULL,
647 GIMP_TYPE_GIMP,
648 GIMP_PARAM_READWRITE |
649 G_PARAM_CONSTRUCT_ONLY));
650
651 g_object_class_install_property (object_class, PROP_ID,
652 g_param_spec_int ("id", NULL, NULL,
653 0, G_MAXINT, 0,
654 GIMP_PARAM_READABLE));
655
656 g_object_class_install_property (object_class, PROP_WIDTH,
657 g_param_spec_int ("width", NULL, NULL,
658 1, GIMP_MAX_IMAGE_SIZE, 1,
659 GIMP_PARAM_READWRITE |
660 G_PARAM_CONSTRUCT));
661
662 g_object_class_install_property (object_class, PROP_HEIGHT,
663 g_param_spec_int ("height", NULL, NULL,
664 1, GIMP_MAX_IMAGE_SIZE, 1,
665 GIMP_PARAM_READWRITE |
666 G_PARAM_CONSTRUCT));
667
668 g_object_class_install_property (object_class, PROP_BASE_TYPE,
669 g_param_spec_enum ("base-type", NULL, NULL,
670 GIMP_TYPE_IMAGE_BASE_TYPE,
671 GIMP_RGB,
672 GIMP_PARAM_READWRITE |
673 G_PARAM_CONSTRUCT));
674
675 g_object_class_install_property (object_class, PROP_PRECISION,
676 g_param_spec_enum ("precision", NULL, NULL,
677 GIMP_TYPE_PRECISION,
678 GIMP_PRECISION_U8_GAMMA,
679 GIMP_PARAM_READWRITE |
680 G_PARAM_CONSTRUCT));
681
682 g_object_class_install_property (object_class, PROP_METADATA,
683 g_param_spec_object ("metadata", NULL, NULL,
684 GEXIV2_TYPE_METADATA,
685 GIMP_PARAM_READABLE));
686
687 g_object_class_override_property (object_class, PROP_BUFFER, "buffer");
688
689 g_object_class_install_property (object_class, PROP_SYMMETRY,
690 g_param_spec_gtype ("symmetry",
691 NULL, _("Symmetry"),
692 GIMP_TYPE_SYMMETRY,
693 GIMP_PARAM_READWRITE |
694 G_PARAM_CONSTRUCT));
695 }
696
697 static void
gimp_color_managed_iface_init(GimpColorManagedInterface * iface)698 gimp_color_managed_iface_init (GimpColorManagedInterface *iface)
699 {
700 iface->get_icc_profile = gimp_image_color_managed_get_icc_profile;
701 iface->get_color_profile = gimp_image_color_managed_get_color_profile;
702 iface->profile_changed = gimp_image_color_managed_profile_changed;
703 }
704
705 static void
gimp_projectable_iface_init(GimpProjectableInterface * iface)706 gimp_projectable_iface_init (GimpProjectableInterface *iface)
707 {
708 iface->flush = gimp_image_projectable_flush;
709 iface->get_image = gimp_image_get_image;
710 iface->get_format = gimp_image_get_proj_format;
711 iface->get_bounding_box = gimp_image_get_bounding_box;
712 iface->get_graph = gimp_image_get_graph;
713 iface->invalidate_preview = (void (*) (GimpProjectable*)) gimp_viewable_invalidate_preview;
714 }
715
716 static void
gimp_pickable_iface_init(GimpPickableInterface * iface)717 gimp_pickable_iface_init (GimpPickableInterface *iface)
718 {
719 iface->flush = gimp_image_pickable_flush;
720 iface->get_image = (GimpImage * (*) (GimpPickable *pickable)) gimp_image_get_image;
721 iface->get_format = (const Babl * (*) (GimpPickable *pickable)) gimp_image_get_proj_format;
722 iface->get_format_with_alpha = (const Babl * (*) (GimpPickable *pickable)) gimp_image_get_proj_format;
723 iface->get_buffer = gimp_image_get_buffer;
724 iface->get_pixel_at = gimp_image_get_pixel_at;
725 iface->get_opacity_at = gimp_image_get_opacity_at;
726 iface->get_pixel_average = gimp_image_get_pixel_average;
727 iface->pixel_to_srgb = gimp_image_pixel_to_srgb;
728 iface->srgb_to_pixel = gimp_image_srgb_to_pixel;
729 }
730
731 static void
gimp_image_init(GimpImage * image)732 gimp_image_init (GimpImage *image)
733 {
734 GimpImagePrivate *private = gimp_image_get_instance_private (image);
735 gint i;
736
737 image->priv = private;
738
739 private->ID = 0;
740
741 private->load_proc = NULL;
742 private->save_proc = NULL;
743
744 private->width = 0;
745 private->height = 0;
746 private->xresolution = 1.0;
747 private->yresolution = 1.0;
748 private->resolution_set = FALSE;
749 private->resolution_unit = GIMP_UNIT_INCH;
750 private->base_type = GIMP_RGB;
751 private->precision = GIMP_PRECISION_U8_GAMMA;
752 private->new_layer_mode = -1;
753
754 private->show_all = 0;
755 private->bounding_box.x = 0;
756 private->bounding_box.y = 0;
757 private->bounding_box.width = 0;
758 private->bounding_box.height = 0;
759 private->pickable_buffer = NULL;
760
761 private->colormap = NULL;
762 private->n_colors = 0;
763 private->palette = NULL;
764
765 private->is_color_managed = TRUE;
766
767 private->metadata = NULL;
768
769 private->dirty = 1;
770 private->dirty_time = 0;
771 private->undo_freeze_count = 0;
772
773 private->export_dirty = 1;
774
775 private->instance_count = 0;
776 private->disp_count = 0;
777
778 private->tattoo_state = 0;
779
780 private->projection = gimp_projection_new (GIMP_PROJECTABLE (image));
781
782 private->symmetries = NULL;
783 private->active_symmetry = NULL;
784
785 private->guides = NULL;
786 private->grid = NULL;
787 private->sample_points = NULL;
788
789 private->layers = gimp_item_tree_new (image,
790 GIMP_TYPE_LAYER_STACK,
791 GIMP_TYPE_LAYER);
792 private->channels = gimp_item_tree_new (image,
793 GIMP_TYPE_DRAWABLE_STACK,
794 GIMP_TYPE_CHANNEL);
795 private->vectors = gimp_item_tree_new (image,
796 GIMP_TYPE_ITEM_STACK,
797 GIMP_TYPE_VECTORS);
798 private->layer_stack = NULL;
799
800 g_signal_connect (private->projection, "notify::buffer",
801 G_CALLBACK (gimp_image_projection_buffer_notify),
802 image);
803
804 g_signal_connect (private->layers, "notify::active-item",
805 G_CALLBACK (gimp_image_active_layer_notify),
806 image);
807 g_signal_connect (private->channels, "notify::active-item",
808 G_CALLBACK (gimp_image_active_channel_notify),
809 image);
810 g_signal_connect (private->vectors, "notify::active-item",
811 G_CALLBACK (gimp_image_active_vectors_notify),
812 image);
813
814 g_signal_connect_swapped (private->layers->container, "update",
815 G_CALLBACK (gimp_image_invalidate),
816 image);
817
818 private->layer_offset_x_handler =
819 gimp_container_add_handler (private->layers->container, "notify::offset-x",
820 G_CALLBACK (gimp_image_layer_offset_changed),
821 image);
822 private->layer_offset_y_handler =
823 gimp_container_add_handler (private->layers->container, "notify::offset-y",
824 G_CALLBACK (gimp_image_layer_offset_changed),
825 image);
826 private->layer_bounding_box_handler =
827 gimp_container_add_handler (private->layers->container, "bounding-box-changed",
828 G_CALLBACK (gimp_image_layer_bounding_box_changed),
829 image);
830 private->layer_alpha_handler =
831 gimp_container_add_handler (private->layers->container, "alpha-changed",
832 G_CALLBACK (gimp_image_layer_alpha_changed),
833 image);
834
835 g_signal_connect (private->layers->container, "add",
836 G_CALLBACK (gimp_image_layers_changed),
837 image);
838 g_signal_connect (private->layers->container, "remove",
839 G_CALLBACK (gimp_image_layers_changed),
840 image);
841
842 g_signal_connect_swapped (private->channels->container, "update",
843 G_CALLBACK (gimp_image_invalidate),
844 image);
845
846 private->channel_name_changed_handler =
847 gimp_container_add_handler (private->channels->container, "name-changed",
848 G_CALLBACK (gimp_image_channel_name_changed),
849 image);
850 private->channel_color_changed_handler =
851 gimp_container_add_handler (private->channels->container, "color-changed",
852 G_CALLBACK (gimp_image_channel_color_changed),
853 image);
854
855 g_signal_connect (private->channels->container, "add",
856 G_CALLBACK (gimp_image_channel_add),
857 image);
858 g_signal_connect (private->channels->container, "remove",
859 G_CALLBACK (gimp_image_channel_remove),
860 image);
861
862 private->floating_sel = NULL;
863 private->selection_mask = NULL;
864
865 private->parasites = gimp_parasite_list_new ();
866
867 for (i = 0; i < MAX_CHANNELS; i++)
868 {
869 private->visible[i] = TRUE;
870 private->active[i] = TRUE;
871 }
872
873 private->quick_mask_state = FALSE;
874 private->quick_mask_inverted = FALSE;
875 gimp_rgba_set (&private->quick_mask_color, 1.0, 0.0, 0.0, 0.5);
876
877 private->undo_stack = gimp_undo_stack_new (image);
878 private->redo_stack = gimp_undo_stack_new (image);
879 private->group_count = 0;
880 private->pushing_undo_group = GIMP_UNDO_GROUP_NONE;
881
882 private->flush_accum.alpha_changed = FALSE;
883 private->flush_accum.mask_changed = FALSE;
884 private->flush_accum.floating_selection_changed = FALSE;
885 private->flush_accum.preview_invalidated = FALSE;
886 }
887
888 static void
gimp_image_constructed(GObject * object)889 gimp_image_constructed (GObject *object)
890 {
891 GimpImage *image = GIMP_IMAGE (object);
892 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
893 GimpChannel *selection;
894 GimpCoreConfig *config;
895 GimpTemplate *template;
896
897 G_OBJECT_CLASS (parent_class)->constructed (object);
898
899 gimp_assert (GIMP_IS_GIMP (image->gimp));
900
901 config = image->gimp->config;
902
903 private->ID = gimp_id_table_insert (image->gimp->image_table, image);
904
905 template = config->default_image;
906
907 private->xresolution = gimp_template_get_resolution_x (template);
908 private->yresolution = gimp_template_get_resolution_y (template);
909 private->resolution_unit = gimp_template_get_resolution_unit (template);
910
911 private->grid = gimp_config_duplicate (GIMP_CONFIG (config->default_grid));
912
913 private->quick_mask_color = config->quick_mask_color;
914
915 gimp_image_update_bounding_box (image);
916
917 if (private->base_type == GIMP_INDEXED)
918 gimp_image_colormap_init (image);
919
920 selection = gimp_selection_new (image,
921 gimp_image_get_width (image),
922 gimp_image_get_height (image));
923 gimp_image_take_mask (image, selection);
924
925 g_signal_connect_object (config, "notify::transparency-type",
926 G_CALLBACK (gimp_item_stack_invalidate_previews),
927 private->layers->container, G_CONNECT_SWAPPED);
928 g_signal_connect_object (config, "notify::transparency-size",
929 G_CALLBACK (gimp_item_stack_invalidate_previews),
930 private->layers->container, G_CONNECT_SWAPPED);
931 g_signal_connect_object (config, "notify::layer-previews",
932 G_CALLBACK (gimp_viewable_size_changed),
933 image, G_CONNECT_SWAPPED);
934 g_signal_connect_object (config, "notify::group-layer-previews",
935 G_CALLBACK (gimp_viewable_size_changed),
936 image, G_CONNECT_SWAPPED);
937
938 gimp_container_add (image->gimp->images, GIMP_OBJECT (image));
939 }
940
941 static void
gimp_image_set_property(GObject * object,guint property_id,const GValue * value,GParamSpec * pspec)942 gimp_image_set_property (GObject *object,
943 guint property_id,
944 const GValue *value,
945 GParamSpec *pspec)
946 {
947 GimpImage *image = GIMP_IMAGE (object);
948 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
949
950 switch (property_id)
951 {
952 case PROP_GIMP:
953 image->gimp = g_value_get_object (value);
954 break;
955
956 case PROP_WIDTH:
957 private->width = g_value_get_int (value);
958 break;
959 case PROP_HEIGHT:
960 private->height = g_value_get_int (value);
961 break;
962
963 case PROP_BASE_TYPE:
964 private->base_type = g_value_get_enum (value);
965 _gimp_image_free_color_transforms (image);
966 break;
967
968 case PROP_PRECISION:
969 private->precision = g_value_get_enum (value);
970 _gimp_image_free_color_transforms (image);
971 break;
972
973 case PROP_SYMMETRY:
974 {
975 GList *iter;
976 GType type = g_value_get_gtype (value);
977
978 if (private->active_symmetry)
979 g_object_set (private->active_symmetry,
980 "active", FALSE,
981 NULL);
982 private->active_symmetry = NULL;
983
984 for (iter = private->symmetries; iter; iter = g_list_next (iter))
985 {
986 GimpSymmetry *sym = iter->data;
987
988 if (type == G_TYPE_FROM_INSTANCE (sym))
989 private->active_symmetry = iter->data;
990 }
991
992 if (! private->active_symmetry &&
993 g_type_is_a (type, GIMP_TYPE_SYMMETRY))
994 {
995 GimpSymmetry *sym = gimp_image_symmetry_new (image, type);
996
997 gimp_image_symmetry_add (image, sym);
998 g_object_unref (sym);
999
1000 private->active_symmetry = sym;
1001 }
1002
1003 if (private->active_symmetry)
1004 g_object_set (private->active_symmetry,
1005 "active", TRUE,
1006 NULL);
1007 }
1008 break;
1009
1010 case PROP_ID:
1011 case PROP_METADATA:
1012 case PROP_BUFFER:
1013 default:
1014 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1015 break;
1016 }
1017 }
1018
1019 static void
gimp_image_get_property(GObject * object,guint property_id,GValue * value,GParamSpec * pspec)1020 gimp_image_get_property (GObject *object,
1021 guint property_id,
1022 GValue *value,
1023 GParamSpec *pspec)
1024 {
1025 GimpImage *image = GIMP_IMAGE (object);
1026 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1027
1028 switch (property_id)
1029 {
1030 case PROP_GIMP:
1031 g_value_set_object (value, image->gimp);
1032 break;
1033 case PROP_ID:
1034 g_value_set_int (value, private->ID);
1035 break;
1036 case PROP_WIDTH:
1037 g_value_set_int (value, private->width);
1038 break;
1039 case PROP_HEIGHT:
1040 g_value_set_int (value, private->height);
1041 break;
1042 case PROP_BASE_TYPE:
1043 g_value_set_enum (value, private->base_type);
1044 break;
1045 case PROP_PRECISION:
1046 g_value_set_enum (value, private->precision);
1047 break;
1048 case PROP_METADATA:
1049 g_value_set_object (value, gimp_image_get_metadata (image));
1050 break;
1051 case PROP_BUFFER:
1052 g_value_set_object (value, gimp_image_get_buffer (GIMP_PICKABLE (image)));
1053 break;
1054 case PROP_SYMMETRY:
1055 g_value_set_gtype (value,
1056 private->active_symmetry ?
1057 G_TYPE_FROM_INSTANCE (private->active_symmetry) :
1058 G_TYPE_NONE);
1059 break;
1060 default:
1061 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1062 break;
1063 }
1064 }
1065
1066 static void
gimp_image_dispose(GObject * object)1067 gimp_image_dispose (GObject *object)
1068 {
1069 GimpImage *image = GIMP_IMAGE (object);
1070 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1071
1072 if (private->colormap)
1073 gimp_image_colormap_dispose (image);
1074
1075 gimp_image_undo_free (image);
1076
1077 g_signal_handlers_disconnect_by_func (private->layers->container,
1078 gimp_image_invalidate,
1079 image);
1080
1081 gimp_container_remove_handler (private->layers->container,
1082 private->layer_offset_x_handler);
1083 gimp_container_remove_handler (private->layers->container,
1084 private->layer_offset_y_handler);
1085 gimp_container_remove_handler (private->layers->container,
1086 private->layer_bounding_box_handler);
1087 gimp_container_remove_handler (private->layers->container,
1088 private->layer_alpha_handler);
1089
1090 g_signal_handlers_disconnect_by_func (private->layers->container,
1091 gimp_image_layers_changed,
1092 image);
1093
1094 g_signal_handlers_disconnect_by_func (private->channels->container,
1095 gimp_image_invalidate,
1096 image);
1097
1098 gimp_container_remove_handler (private->channels->container,
1099 private->channel_name_changed_handler);
1100 gimp_container_remove_handler (private->channels->container,
1101 private->channel_color_changed_handler);
1102
1103 g_signal_handlers_disconnect_by_func (private->channels->container,
1104 gimp_image_channel_add,
1105 image);
1106 g_signal_handlers_disconnect_by_func (private->channels->container,
1107 gimp_image_channel_remove,
1108 image);
1109
1110 g_object_run_dispose (G_OBJECT (private->layers));
1111 g_object_run_dispose (G_OBJECT (private->channels));
1112 g_object_run_dispose (G_OBJECT (private->vectors));
1113
1114 G_OBJECT_CLASS (parent_class)->dispose (object);
1115 }
1116
1117 static void
gimp_image_finalize(GObject * object)1118 gimp_image_finalize (GObject *object)
1119 {
1120 GimpImage *image = GIMP_IMAGE (object);
1121 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1122
1123 g_clear_object (&private->projection);
1124 g_clear_object (&private->graph);
1125 private->visible_mask = NULL;
1126
1127 if (private->colormap)
1128 gimp_image_colormap_free (image);
1129
1130 if (private->color_profile)
1131 _gimp_image_free_color_profile (image);
1132
1133 g_clear_object (&private->pickable_buffer);
1134 g_clear_object (&private->metadata);
1135 g_clear_object (&private->file);
1136 g_clear_object (&private->imported_file);
1137 g_clear_object (&private->exported_file);
1138 g_clear_object (&private->save_a_copy_file);
1139 g_clear_object (&private->untitled_file);
1140 g_clear_object (&private->layers);
1141 g_clear_object (&private->channels);
1142 g_clear_object (&private->vectors);
1143
1144 if (private->layer_stack)
1145 {
1146 g_slist_free (private->layer_stack);
1147 private->layer_stack = NULL;
1148 }
1149
1150 g_clear_object (&private->selection_mask);
1151 g_clear_object (&private->parasites);
1152
1153 if (private->guides)
1154 {
1155 g_list_free_full (private->guides, (GDestroyNotify) g_object_unref);
1156 private->guides = NULL;
1157 }
1158
1159 if (private->symmetries)
1160 {
1161 g_list_free_full (private->symmetries, g_object_unref);
1162 private->symmetries = NULL;
1163 }
1164
1165 g_clear_object (&private->grid);
1166
1167 if (private->sample_points)
1168 {
1169 g_list_free_full (private->sample_points,
1170 (GDestroyNotify) g_object_unref);
1171 private->sample_points = NULL;
1172 }
1173
1174 g_clear_object (&private->undo_stack);
1175 g_clear_object (&private->redo_stack);
1176
1177 if (image->gimp && image->gimp->image_table)
1178 {
1179 gimp_id_table_remove (image->gimp->image_table, private->ID);
1180 image->gimp = NULL;
1181 }
1182
1183 g_clear_pointer (&private->display_name, g_free);
1184 g_clear_pointer (&private->display_path, g_free);
1185
1186 G_OBJECT_CLASS (parent_class)->finalize (object);
1187 }
1188
1189 static void
gimp_image_name_changed(GimpObject * object)1190 gimp_image_name_changed (GimpObject *object)
1191 {
1192 GimpImage *image = GIMP_IMAGE (object);
1193 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1194 const gchar *name;
1195
1196 if (GIMP_OBJECT_CLASS (parent_class)->name_changed)
1197 GIMP_OBJECT_CLASS (parent_class)->name_changed (object);
1198
1199 g_clear_pointer (&private->display_name, g_free);
1200 g_clear_pointer (&private->display_path, g_free);
1201
1202 /* We never want the empty string as a name, so change empty strings
1203 * to NULL strings (without emitting the "name-changed" signal
1204 * again)
1205 */
1206 name = gimp_object_get_name (object);
1207 if (name && strlen (name) == 0)
1208 {
1209 gimp_object_name_free (object);
1210 name = NULL;
1211 }
1212
1213 g_clear_object (&private->file);
1214
1215 if (name)
1216 private->file = g_file_new_for_uri (name);
1217 }
1218
1219 static gint64
gimp_image_get_memsize(GimpObject * object,gint64 * gui_size)1220 gimp_image_get_memsize (GimpObject *object,
1221 gint64 *gui_size)
1222 {
1223 GimpImage *image = GIMP_IMAGE (object);
1224 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1225 gint64 memsize = 0;
1226
1227 if (gimp_image_get_colormap (image))
1228 memsize += GIMP_IMAGE_COLORMAP_SIZE;
1229
1230 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->palette),
1231 gui_size);
1232
1233 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->projection),
1234 gui_size);
1235
1236 memsize += gimp_g_list_get_memsize (gimp_image_get_guides (image),
1237 sizeof (GimpGuide));
1238
1239 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->grid), gui_size);
1240
1241 memsize += gimp_g_list_get_memsize (gimp_image_get_sample_points (image),
1242 sizeof (GimpSamplePoint));
1243
1244 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->layers),
1245 gui_size);
1246 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->channels),
1247 gui_size);
1248 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->vectors),
1249 gui_size);
1250
1251 memsize += gimp_g_slist_get_memsize (private->layer_stack, 0);
1252
1253 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->selection_mask),
1254 gui_size);
1255
1256 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->parasites),
1257 gui_size);
1258
1259 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->undo_stack),
1260 gui_size);
1261 memsize += gimp_object_get_memsize (GIMP_OBJECT (private->redo_stack),
1262 gui_size);
1263
1264 return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
1265 gui_size);
1266 }
1267
1268 static gboolean
gimp_image_get_size(GimpViewable * viewable,gint * width,gint * height)1269 gimp_image_get_size (GimpViewable *viewable,
1270 gint *width,
1271 gint *height)
1272 {
1273 GimpImage *image = GIMP_IMAGE (viewable);
1274
1275 *width = gimp_image_get_width (image);
1276 *height = gimp_image_get_height (image);
1277
1278 return TRUE;
1279 }
1280
1281 static void
gimp_image_size_changed(GimpViewable * viewable)1282 gimp_image_size_changed (GimpViewable *viewable)
1283 {
1284 GimpImage *image = GIMP_IMAGE (viewable);
1285 GList *all_items;
1286 GList *list;
1287
1288 if (GIMP_VIEWABLE_CLASS (parent_class)->size_changed)
1289 GIMP_VIEWABLE_CLASS (parent_class)->size_changed (viewable);
1290
1291 all_items = gimp_image_get_layer_list (image);
1292 for (list = all_items; list; list = g_list_next (list))
1293 {
1294 GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (list->data));
1295
1296 gimp_viewable_size_changed (GIMP_VIEWABLE (list->data));
1297
1298 if (mask)
1299 gimp_viewable_size_changed (GIMP_VIEWABLE (mask));
1300 }
1301 g_list_free (all_items);
1302
1303 all_items = gimp_image_get_channel_list (image);
1304 g_list_free_full (all_items, (GDestroyNotify) gimp_viewable_size_changed);
1305
1306 all_items = gimp_image_get_vectors_list (image);
1307 g_list_free_full (all_items, (GDestroyNotify) gimp_viewable_size_changed);
1308
1309 gimp_viewable_size_changed (GIMP_VIEWABLE (gimp_image_get_mask (image)));
1310
1311 gimp_image_metadata_update_pixel_size (image);
1312
1313 g_clear_object (&GIMP_IMAGE_GET_PRIVATE (image)->pickable_buffer);
1314
1315 gimp_image_update_bounding_box (image);
1316 }
1317
1318 static gchar *
gimp_image_get_description(GimpViewable * viewable,gchar ** tooltip)1319 gimp_image_get_description (GimpViewable *viewable,
1320 gchar **tooltip)
1321 {
1322 GimpImage *image = GIMP_IMAGE (viewable);
1323
1324 if (tooltip)
1325 *tooltip = g_strdup (gimp_image_get_display_path (image));
1326
1327 return g_strdup_printf ("%s-%d",
1328 gimp_image_get_display_name (image),
1329 gimp_image_get_ID (image));
1330 }
1331
1332 static void
gimp_image_real_mode_changed(GimpImage * image)1333 gimp_image_real_mode_changed (GimpImage *image)
1334 {
1335 gimp_projectable_structure_changed (GIMP_PROJECTABLE (image));
1336 }
1337
1338 static void
gimp_image_real_precision_changed(GimpImage * image)1339 gimp_image_real_precision_changed (GimpImage *image)
1340 {
1341 gimp_image_metadata_update_bits_per_sample (image);
1342
1343 gimp_projectable_structure_changed (GIMP_PROJECTABLE (image));
1344 }
1345
1346 static void
gimp_image_real_resolution_changed(GimpImage * image)1347 gimp_image_real_resolution_changed (GimpImage *image)
1348 {
1349 gimp_image_metadata_update_resolution (image);
1350 }
1351
1352 static void
gimp_image_real_size_changed_detailed(GimpImage * image,gint previous_origin_x,gint previous_origin_y,gint previous_width,gint previous_height)1353 gimp_image_real_size_changed_detailed (GimpImage *image,
1354 gint previous_origin_x,
1355 gint previous_origin_y,
1356 gint previous_width,
1357 gint previous_height)
1358 {
1359 /* Whenever GimpImage::size-changed-detailed is emitted, so is
1360 * GimpViewable::size-changed. Clients choose what signal to listen
1361 * to depending on how much info they need.
1362 */
1363 gimp_viewable_size_changed (GIMP_VIEWABLE (image));
1364 }
1365
1366 static void
gimp_image_real_unit_changed(GimpImage * image)1367 gimp_image_real_unit_changed (GimpImage *image)
1368 {
1369 gimp_image_metadata_update_resolution (image);
1370 }
1371
1372 static void
gimp_image_real_colormap_changed(GimpImage * image,gint color_index)1373 gimp_image_real_colormap_changed (GimpImage *image,
1374 gint color_index)
1375 {
1376 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1377
1378 if (private->colormap && private->n_colors > 0)
1379 {
1380 babl_palette_set_palette (private->babl_palette_rgb,
1381 gimp_babl_format (GIMP_RGB,
1382 private->precision, FALSE),
1383 private->colormap,
1384 private->n_colors);
1385 babl_palette_set_palette (private->babl_palette_rgba,
1386 gimp_babl_format (GIMP_RGB,
1387 private->precision, FALSE),
1388 private->colormap,
1389 private->n_colors);
1390 }
1391
1392 if (gimp_image_get_base_type (image) == GIMP_INDEXED)
1393 {
1394 /* A colormap alteration affects the whole image */
1395 gimp_image_invalidate_all (image);
1396
1397 gimp_item_stack_invalidate_previews (GIMP_ITEM_STACK (private->layers->container));
1398 }
1399 }
1400
1401 static const guint8 *
gimp_image_color_managed_get_icc_profile(GimpColorManaged * managed,gsize * len)1402 gimp_image_color_managed_get_icc_profile (GimpColorManaged *managed,
1403 gsize *len)
1404 {
1405 return gimp_image_get_icc_profile (GIMP_IMAGE (managed), len);
1406 }
1407
1408 static GimpColorProfile *
gimp_image_color_managed_get_color_profile(GimpColorManaged * managed)1409 gimp_image_color_managed_get_color_profile (GimpColorManaged *managed)
1410 {
1411 GimpImage *image = GIMP_IMAGE (managed);
1412 GimpColorProfile *profile = NULL;
1413
1414 if (gimp_image_get_is_color_managed (image))
1415 profile = gimp_image_get_color_profile (image);
1416
1417 if (! profile)
1418 profile = gimp_image_get_builtin_color_profile (image);
1419
1420 return profile;
1421 }
1422
1423 static void
gimp_image_color_managed_profile_changed(GimpColorManaged * managed)1424 gimp_image_color_managed_profile_changed (GimpColorManaged *managed)
1425 {
1426 GimpImage *image = GIMP_IMAGE (managed);
1427 GimpItemStack *layers = GIMP_ITEM_STACK (gimp_image_get_layers (image));
1428
1429 gimp_image_metadata_update_colorspace (image);
1430
1431 gimp_projectable_structure_changed (GIMP_PROJECTABLE (image));
1432 gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image));
1433 gimp_item_stack_profile_changed (layers);
1434 }
1435
1436 static void
gimp_image_projectable_flush(GimpProjectable * projectable,gboolean invalidate_preview)1437 gimp_image_projectable_flush (GimpProjectable *projectable,
1438 gboolean invalidate_preview)
1439 {
1440 GimpImage *image = GIMP_IMAGE (projectable);
1441 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1442
1443 if (private->flush_accum.alpha_changed)
1444 {
1445 gimp_image_alpha_changed (image);
1446 private->flush_accum.alpha_changed = FALSE;
1447 }
1448
1449 if (private->flush_accum.mask_changed)
1450 {
1451 gimp_image_mask_changed (image);
1452 private->flush_accum.mask_changed = FALSE;
1453 }
1454
1455 if (private->flush_accum.floating_selection_changed)
1456 {
1457 gimp_image_floating_selection_changed (image);
1458 private->flush_accum.floating_selection_changed = FALSE;
1459 }
1460
1461 if (private->flush_accum.preview_invalidated)
1462 {
1463 /* don't invalidate the preview here, the projection does this when
1464 * it is completely constructed.
1465 */
1466 private->flush_accum.preview_invalidated = FALSE;
1467 }
1468 }
1469
1470 static GimpImage *
gimp_image_get_image(GimpProjectable * projectable)1471 gimp_image_get_image (GimpProjectable *projectable)
1472 {
1473 return GIMP_IMAGE (projectable);
1474 }
1475
1476 static const Babl *
gimp_image_get_proj_format(GimpProjectable * projectable)1477 gimp_image_get_proj_format (GimpProjectable *projectable)
1478 {
1479 GimpImage *image = GIMP_IMAGE (projectable);
1480 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1481
1482 switch (private->base_type)
1483 {
1484 case GIMP_RGB:
1485 case GIMP_INDEXED:
1486 return gimp_image_get_format (image, GIMP_RGB,
1487 gimp_image_get_precision (image), TRUE);
1488
1489 case GIMP_GRAY:
1490 return gimp_image_get_format (image, GIMP_GRAY,
1491 gimp_image_get_precision (image), TRUE);
1492 }
1493
1494 g_return_val_if_reached (NULL);
1495 }
1496
1497 static void
gimp_image_pickable_flush(GimpPickable * pickable)1498 gimp_image_pickable_flush (GimpPickable *pickable)
1499 {
1500 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (pickable);
1501
1502 return gimp_pickable_flush (GIMP_PICKABLE (private->projection));
1503 }
1504
1505 static GeglBuffer *
gimp_image_get_buffer(GimpPickable * pickable)1506 gimp_image_get_buffer (GimpPickable *pickable)
1507 {
1508 GimpImage *image = GIMP_IMAGE (pickable);
1509 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1510
1511 if (! private->pickable_buffer)
1512 {
1513 GeglBuffer *buffer;
1514
1515 buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (private->projection));
1516
1517 if (! private->show_all)
1518 {
1519 private->pickable_buffer = g_object_ref (buffer);
1520 }
1521 else
1522 {
1523 private->pickable_buffer = gegl_buffer_create_sub_buffer (
1524 buffer,
1525 GEGL_RECTANGLE (0, 0,
1526 gimp_image_get_width (image),
1527 gimp_image_get_height (image)));
1528 }
1529 }
1530
1531 return private->pickable_buffer;
1532 }
1533
1534 static gboolean
gimp_image_get_pixel_at(GimpPickable * pickable,gint x,gint y,const Babl * format,gpointer pixel)1535 gimp_image_get_pixel_at (GimpPickable *pickable,
1536 gint x,
1537 gint y,
1538 const Babl *format,
1539 gpointer pixel)
1540 {
1541 GimpImage *image = GIMP_IMAGE (pickable);
1542 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1543
1544 if (x >= 0 &&
1545 y >= 0 &&
1546 x < gimp_image_get_width (image) &&
1547 y < gimp_image_get_height (image))
1548 {
1549 return gimp_pickable_get_pixel_at (GIMP_PICKABLE (private->projection),
1550 x, y, format, pixel);
1551 }
1552
1553 return FALSE;
1554 }
1555
1556 static gdouble
gimp_image_get_opacity_at(GimpPickable * pickable,gint x,gint y)1557 gimp_image_get_opacity_at (GimpPickable *pickable,
1558 gint x,
1559 gint y)
1560 {
1561 GimpImage *image = GIMP_IMAGE (pickable);
1562 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1563
1564 if (x >= 0 &&
1565 y >= 0 &&
1566 x < gimp_image_get_width (image) &&
1567 y < gimp_image_get_height (image))
1568 {
1569 return gimp_pickable_get_opacity_at (GIMP_PICKABLE (private->projection),
1570 x, y);
1571 }
1572
1573 return FALSE;
1574 }
1575
1576 static void
gimp_image_get_pixel_average(GimpPickable * pickable,const GeglRectangle * rect,const Babl * format,gpointer pixel)1577 gimp_image_get_pixel_average (GimpPickable *pickable,
1578 const GeglRectangle *rect,
1579 const Babl *format,
1580 gpointer pixel)
1581 {
1582 GeglBuffer *buffer = gimp_pickable_get_buffer (pickable);
1583
1584 return gimp_gegl_average_color (buffer, rect, TRUE, GEGL_ABYSS_NONE, format,
1585 pixel);
1586 }
1587
1588 static void
gimp_image_pixel_to_srgb(GimpPickable * pickable,const Babl * format,gpointer pixel,GimpRGB * color)1589 gimp_image_pixel_to_srgb (GimpPickable *pickable,
1590 const Babl *format,
1591 gpointer pixel,
1592 GimpRGB *color)
1593 {
1594 gimp_image_color_profile_pixel_to_srgb (GIMP_IMAGE (pickable),
1595 format, pixel, color);
1596 }
1597
1598 static void
gimp_image_srgb_to_pixel(GimpPickable * pickable,const GimpRGB * color,const Babl * format,gpointer pixel)1599 gimp_image_srgb_to_pixel (GimpPickable *pickable,
1600 const GimpRGB *color,
1601 const Babl *format,
1602 gpointer pixel)
1603 {
1604 gimp_image_color_profile_srgb_to_pixel (GIMP_IMAGE (pickable),
1605 color, format, pixel);
1606 }
1607
1608 static GeglRectangle
gimp_image_get_bounding_box(GimpProjectable * projectable)1609 gimp_image_get_bounding_box (GimpProjectable *projectable)
1610 {
1611 GimpImage *image = GIMP_IMAGE (projectable);
1612
1613 return GIMP_IMAGE_GET_PRIVATE (image)->bounding_box;
1614 }
1615
1616 static GeglNode *
gimp_image_get_graph(GimpProjectable * projectable)1617 gimp_image_get_graph (GimpProjectable *projectable)
1618 {
1619 GimpImage *image = GIMP_IMAGE (projectable);
1620 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1621 GeglNode *layers_node;
1622 GeglNode *channels_node;
1623 GeglNode *output;
1624 GimpComponentMask mask;
1625
1626 if (private->graph)
1627 return private->graph;
1628
1629 private->graph = gegl_node_new ();
1630
1631 layers_node =
1632 gimp_filter_stack_get_graph (GIMP_FILTER_STACK (private->layers->container));
1633
1634 gegl_node_add_child (private->graph, layers_node);
1635
1636 mask = ~gimp_image_get_visible_mask (image) & GIMP_COMPONENT_MASK_ALL;
1637
1638 private->visible_mask =
1639 gegl_node_new_child (private->graph,
1640 "operation", "gimp:mask-components",
1641 "mask", mask,
1642 "alpha", 1.0,
1643 NULL);
1644
1645 gegl_node_connect_to (layers_node, "output",
1646 private->visible_mask, "input");
1647
1648 channels_node =
1649 gimp_filter_stack_get_graph (GIMP_FILTER_STACK (private->channels->container));
1650
1651 gegl_node_add_child (private->graph, channels_node);
1652
1653 gegl_node_connect_to (private->visible_mask, "output",
1654 channels_node, "input");
1655
1656 output = gegl_node_get_output_proxy (private->graph, "output");
1657
1658 gegl_node_connect_to (channels_node, "output",
1659 output, "input");
1660
1661 return private->graph;
1662 }
1663
1664 static void
gimp_image_projection_buffer_notify(GimpProjection * projection,const GParamSpec * pspec,GimpImage * image)1665 gimp_image_projection_buffer_notify (GimpProjection *projection,
1666 const GParamSpec *pspec,
1667 GimpImage *image)
1668 {
1669 g_clear_object (&GIMP_IMAGE_GET_PRIVATE (image)->pickable_buffer);
1670 }
1671
1672 static void
gimp_image_mask_update(GimpDrawable * drawable,gint x,gint y,gint width,gint height,GimpImage * image)1673 gimp_image_mask_update (GimpDrawable *drawable,
1674 gint x,
1675 gint y,
1676 gint width,
1677 gint height,
1678 GimpImage *image)
1679 {
1680 GIMP_IMAGE_GET_PRIVATE (image)->flush_accum.mask_changed = TRUE;
1681 }
1682
1683 static void
gimp_image_layers_changed(GimpContainer * container,GimpChannel * channel,GimpImage * image)1684 gimp_image_layers_changed (GimpContainer *container,
1685 GimpChannel *channel,
1686 GimpImage *image)
1687 {
1688 gimp_image_update_bounding_box (image);
1689 }
1690
1691 static void
gimp_image_layer_offset_changed(GimpDrawable * drawable,const GParamSpec * pspec,GimpImage * image)1692 gimp_image_layer_offset_changed (GimpDrawable *drawable,
1693 const GParamSpec *pspec,
1694 GimpImage *image)
1695 {
1696 gimp_image_update_bounding_box (image);
1697 }
1698
1699 static void
gimp_image_layer_bounding_box_changed(GimpDrawable * drawable,GimpImage * image)1700 gimp_image_layer_bounding_box_changed (GimpDrawable *drawable,
1701 GimpImage *image)
1702 {
1703 gimp_image_update_bounding_box (image);
1704 }
1705
1706 static void
gimp_image_layer_alpha_changed(GimpDrawable * drawable,GimpImage * image)1707 gimp_image_layer_alpha_changed (GimpDrawable *drawable,
1708 GimpImage *image)
1709 {
1710 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1711
1712 if (gimp_container_get_n_children (private->layers->container) == 1)
1713 private->flush_accum.alpha_changed = TRUE;
1714 }
1715
1716 static void
gimp_image_channel_add(GimpContainer * container,GimpChannel * channel,GimpImage * image)1717 gimp_image_channel_add (GimpContainer *container,
1718 GimpChannel *channel,
1719 GimpImage *image)
1720 {
1721 if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1722 gimp_object_get_name (channel)))
1723 {
1724 gimp_image_set_quick_mask_state (image, TRUE);
1725 }
1726 }
1727
1728 static void
gimp_image_channel_remove(GimpContainer * container,GimpChannel * channel,GimpImage * image)1729 gimp_image_channel_remove (GimpContainer *container,
1730 GimpChannel *channel,
1731 GimpImage *image)
1732 {
1733 if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1734 gimp_object_get_name (channel)))
1735 {
1736 gimp_image_set_quick_mask_state (image, FALSE);
1737 }
1738 }
1739
1740 static void
gimp_image_channel_name_changed(GimpChannel * channel,GimpImage * image)1741 gimp_image_channel_name_changed (GimpChannel *channel,
1742 GimpImage *image)
1743 {
1744 if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1745 gimp_object_get_name (channel)))
1746 {
1747 gimp_image_set_quick_mask_state (image, TRUE);
1748 }
1749 else if (gimp_image_get_quick_mask_state (image) &&
1750 ! gimp_image_get_quick_mask (image))
1751 {
1752 gimp_image_set_quick_mask_state (image, FALSE);
1753 }
1754 }
1755
1756 static void
gimp_image_channel_color_changed(GimpChannel * channel,GimpImage * image)1757 gimp_image_channel_color_changed (GimpChannel *channel,
1758 GimpImage *image)
1759 {
1760 if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
1761 gimp_object_get_name (channel)))
1762 {
1763 GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = channel->color;
1764 }
1765 }
1766
1767 static void
gimp_image_active_layer_notify(GimpItemTree * tree,const GParamSpec * pspec,GimpImage * image)1768 gimp_image_active_layer_notify (GimpItemTree *tree,
1769 const GParamSpec *pspec,
1770 GimpImage *image)
1771 {
1772 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1773 GimpLayer *layer = gimp_image_get_active_layer (image);
1774
1775 if (layer)
1776 {
1777 /* Configure the layer stack to reflect this change */
1778 private->layer_stack = g_slist_remove (private->layer_stack, layer);
1779 private->layer_stack = g_slist_prepend (private->layer_stack, layer);
1780 }
1781
1782 g_signal_emit (image, gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
1783
1784 if (layer && gimp_image_get_active_channel (image))
1785 gimp_image_set_active_channel (image, NULL);
1786 }
1787
1788 static void
gimp_image_active_channel_notify(GimpItemTree * tree,const GParamSpec * pspec,GimpImage * image)1789 gimp_image_active_channel_notify (GimpItemTree *tree,
1790 const GParamSpec *pspec,
1791 GimpImage *image)
1792 {
1793 GimpChannel *channel = gimp_image_get_active_channel (image);
1794
1795 g_signal_emit (image, gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
1796
1797 if (channel && gimp_image_get_active_layer (image))
1798 gimp_image_set_active_layer (image, NULL);
1799 }
1800
1801 static void
gimp_image_active_vectors_notify(GimpItemTree * tree,const GParamSpec * pspec,GimpImage * image)1802 gimp_image_active_vectors_notify (GimpItemTree *tree,
1803 const GParamSpec *pspec,
1804 GimpImage *image)
1805 {
1806 g_signal_emit (image, gimp_image_signals[ACTIVE_VECTORS_CHANGED], 0);
1807 }
1808
1809 static void
gimp_image_freeze_bounding_box(GimpImage * image)1810 gimp_image_freeze_bounding_box (GimpImage *image)
1811 {
1812 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1813
1814 private->bounding_box_freeze_count++;
1815 }
1816
1817 static void
gimp_image_thaw_bounding_box(GimpImage * image)1818 gimp_image_thaw_bounding_box (GimpImage *image)
1819 {
1820 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1821
1822 private->bounding_box_freeze_count--;
1823
1824 if (private->bounding_box_freeze_count == 0 &&
1825 private->bounding_box_update_pending)
1826 {
1827 private->bounding_box_update_pending = FALSE;
1828
1829 gimp_image_update_bounding_box (image);
1830 }
1831 }
1832
1833 static void
gimp_image_update_bounding_box(GimpImage * image)1834 gimp_image_update_bounding_box (GimpImage *image)
1835 {
1836 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
1837 GeglRectangle bounding_box;
1838
1839 if (private->bounding_box_freeze_count > 0)
1840 {
1841 private->bounding_box_update_pending = TRUE;
1842
1843 return;
1844 }
1845
1846 bounding_box.x = 0;
1847 bounding_box.y = 0;
1848 bounding_box.width = gimp_image_get_width (image);
1849 bounding_box.height = gimp_image_get_height (image);
1850
1851 if (private->show_all)
1852 {
1853 GList *iter;
1854
1855 for (iter = gimp_image_get_layer_iter (image);
1856 iter;
1857 iter = g_list_next (iter))
1858 {
1859 GimpLayer *layer = iter->data;
1860 GeglRectangle layer_bounding_box;
1861 gint offset_x;
1862 gint offset_y;
1863
1864 gimp_item_get_offset (GIMP_ITEM (layer), &offset_x, &offset_y);
1865
1866 layer_bounding_box = gimp_drawable_get_bounding_box (
1867 GIMP_DRAWABLE (layer));
1868
1869 layer_bounding_box.x += offset_x;
1870 layer_bounding_box.y += offset_y;
1871
1872 gegl_rectangle_bounding_box (&bounding_box,
1873 &bounding_box, &layer_bounding_box);
1874 }
1875 }
1876
1877 if (! gegl_rectangle_equal (&bounding_box, &private->bounding_box))
1878 {
1879 private->bounding_box = bounding_box;
1880
1881 gimp_projectable_bounds_changed (GIMP_PROJECTABLE (image), 0, 0);
1882 }
1883 }
1884
1885
1886 /* public functions */
1887
1888 GimpImage *
gimp_image_new(Gimp * gimp,gint width,gint height,GimpImageBaseType base_type,GimpPrecision precision)1889 gimp_image_new (Gimp *gimp,
1890 gint width,
1891 gint height,
1892 GimpImageBaseType base_type,
1893 GimpPrecision precision)
1894 {
1895 g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
1896 g_return_val_if_fail (gimp_babl_is_valid (base_type, precision), NULL);
1897
1898 return g_object_new (GIMP_TYPE_IMAGE,
1899 "gimp", gimp,
1900 "width", width,
1901 "height", height,
1902 "base-type", base_type,
1903 "precision", precision,
1904 NULL);
1905 }
1906
1907 gint64
gimp_image_estimate_memsize(GimpImage * image,GimpComponentType component_type,gint width,gint height)1908 gimp_image_estimate_memsize (GimpImage *image,
1909 GimpComponentType component_type,
1910 gint width,
1911 gint height)
1912 {
1913 GList *drawables;
1914 GList *list;
1915 gint current_width;
1916 gint current_height;
1917 gint64 current_size;
1918 gint64 scalable_size = 0;
1919 gint64 scaled_size = 0;
1920 gint64 new_size;
1921
1922 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
1923
1924 current_width = gimp_image_get_width (image);
1925 current_height = gimp_image_get_height (image);
1926 current_size = gimp_object_get_memsize (GIMP_OBJECT (image), NULL);
1927
1928 /* the part of the image's memsize that scales linearly with the image */
1929 drawables = gimp_image_item_list_get_list (image,
1930 GIMP_ITEM_TYPE_LAYERS |
1931 GIMP_ITEM_TYPE_CHANNELS,
1932 GIMP_ITEM_SET_ALL);
1933
1934 gimp_image_item_list_filter (drawables);
1935
1936 drawables = g_list_prepend (drawables, gimp_image_get_mask (image));
1937
1938 for (list = drawables; list; list = g_list_next (list))
1939 {
1940 GimpDrawable *drawable = list->data;
1941 gdouble drawable_width;
1942 gdouble drawable_height;
1943
1944 drawable_width = gimp_item_get_width (GIMP_ITEM (drawable));
1945 drawable_height = gimp_item_get_height (GIMP_ITEM (drawable));
1946
1947 scalable_size += gimp_drawable_estimate_memsize (drawable,
1948 gimp_drawable_get_component_type (drawable),
1949 drawable_width,
1950 drawable_height);
1951
1952 scaled_size += gimp_drawable_estimate_memsize (drawable,
1953 component_type,
1954 drawable_width * width /
1955 current_width,
1956 drawable_height * height /
1957 current_height);
1958 }
1959
1960 g_list_free (drawables);
1961
1962 scalable_size +=
1963 gimp_projection_estimate_memsize (gimp_image_get_base_type (image),
1964 gimp_image_get_component_type (image),
1965 gimp_image_get_width (image),
1966 gimp_image_get_height (image));
1967
1968 scaled_size +=
1969 gimp_projection_estimate_memsize (gimp_image_get_base_type (image),
1970 component_type,
1971 width, height);
1972
1973 GIMP_LOG (IMAGE_SCALE,
1974 "scalable_size = %"G_GINT64_FORMAT" scaled_size = %"G_GINT64_FORMAT,
1975 scalable_size, scaled_size);
1976
1977 new_size = current_size - scalable_size + scaled_size;
1978
1979 return new_size;
1980 }
1981
1982 GimpImageBaseType
gimp_image_get_base_type(GimpImage * image)1983 gimp_image_get_base_type (GimpImage *image)
1984 {
1985 g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
1986
1987 return GIMP_IMAGE_GET_PRIVATE (image)->base_type;
1988 }
1989
1990 GimpComponentType
gimp_image_get_component_type(GimpImage * image)1991 gimp_image_get_component_type (GimpImage *image)
1992 {
1993 g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
1994
1995 return gimp_babl_component_type (GIMP_IMAGE_GET_PRIVATE (image)->precision);
1996 }
1997
1998 GimpPrecision
gimp_image_get_precision(GimpImage * image)1999 gimp_image_get_precision (GimpImage *image)
2000 {
2001 g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
2002
2003 return GIMP_IMAGE_GET_PRIVATE (image)->precision;
2004 }
2005
2006 const Babl *
gimp_image_get_format(GimpImage * image,GimpImageBaseType base_type,GimpPrecision precision,gboolean with_alpha)2007 gimp_image_get_format (GimpImage *image,
2008 GimpImageBaseType base_type,
2009 GimpPrecision precision,
2010 gboolean with_alpha)
2011 {
2012 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2013
2014 switch (base_type)
2015 {
2016 case GIMP_RGB:
2017 case GIMP_GRAY:
2018 return gimp_babl_format (base_type, precision, with_alpha);
2019
2020 case GIMP_INDEXED:
2021 if (precision == GIMP_PRECISION_U8_GAMMA)
2022 {
2023 if (with_alpha)
2024 return gimp_image_colormap_get_rgba_format (image);
2025 else
2026 return gimp_image_colormap_get_rgb_format (image);
2027 }
2028 }
2029
2030 g_return_val_if_reached (NULL);
2031 }
2032
2033 const Babl *
gimp_image_get_layer_format(GimpImage * image,gboolean with_alpha)2034 gimp_image_get_layer_format (GimpImage *image,
2035 gboolean with_alpha)
2036 {
2037 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2038
2039 return gimp_image_get_format (image,
2040 gimp_image_get_base_type (image),
2041 gimp_image_get_precision (image),
2042 with_alpha);
2043 }
2044
2045 const Babl *
gimp_image_get_channel_format(GimpImage * image)2046 gimp_image_get_channel_format (GimpImage *image)
2047 {
2048 GimpPrecision precision;
2049
2050 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2051
2052 precision = gimp_image_get_precision (image);
2053
2054 if (precision == GIMP_PRECISION_U8_GAMMA)
2055 return gimp_image_get_format (image, GIMP_GRAY,
2056 gimp_image_get_precision (image),
2057 FALSE);
2058
2059 return gimp_babl_mask_format (precision);
2060 }
2061
2062 const Babl *
gimp_image_get_mask_format(GimpImage * image)2063 gimp_image_get_mask_format (GimpImage *image)
2064 {
2065 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2066
2067 return gimp_babl_mask_format (gimp_image_get_precision (image));
2068 }
2069
2070 GimpLayerMode
gimp_image_get_default_new_layer_mode(GimpImage * image)2071 gimp_image_get_default_new_layer_mode (GimpImage *image)
2072 {
2073 GimpImagePrivate *private;
2074
2075 g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_LAYER_MODE_NORMAL);
2076
2077 private = GIMP_IMAGE_GET_PRIVATE (image);
2078
2079 if (private->new_layer_mode == -1)
2080 {
2081 GList *layers = gimp_image_get_layer_list (image);
2082
2083 if (layers)
2084 {
2085 GList *list;
2086
2087 for (list = layers; list; list = g_list_next (list))
2088 {
2089 GimpLayer *layer = list->data;
2090 GimpLayerMode mode = gimp_layer_get_mode (layer);
2091
2092 if (! gimp_layer_mode_is_legacy (mode))
2093 {
2094 /* any non-legacy layer switches the mode to non-legacy
2095 */
2096 private->new_layer_mode = GIMP_LAYER_MODE_NORMAL;
2097 break;
2098 }
2099 }
2100
2101 /* only if all layers are legacy, the mode is also legacy
2102 */
2103 if (! list)
2104 private->new_layer_mode = GIMP_LAYER_MODE_NORMAL_LEGACY;
2105
2106 g_list_free (layers);
2107 }
2108 else
2109 {
2110 /* empty images are never considered legacy
2111 */
2112 private->new_layer_mode = GIMP_LAYER_MODE_NORMAL;
2113 }
2114 }
2115
2116 return private->new_layer_mode;
2117 }
2118
2119 void
gimp_image_unset_default_new_layer_mode(GimpImage * image)2120 gimp_image_unset_default_new_layer_mode (GimpImage *image)
2121 {
2122 g_return_if_fail (GIMP_IS_IMAGE (image));
2123
2124 GIMP_IMAGE_GET_PRIVATE (image)->new_layer_mode = -1;
2125 }
2126
2127 gint
gimp_image_get_ID(GimpImage * image)2128 gimp_image_get_ID (GimpImage *image)
2129 {
2130 g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
2131
2132 return GIMP_IMAGE_GET_PRIVATE (image)->ID;
2133 }
2134
2135 GimpImage *
gimp_image_get_by_ID(Gimp * gimp,gint image_id)2136 gimp_image_get_by_ID (Gimp *gimp,
2137 gint image_id)
2138 {
2139 g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
2140
2141 if (gimp->image_table == NULL)
2142 return NULL;
2143
2144 return (GimpImage *) gimp_id_table_lookup (gimp->image_table, image_id);
2145 }
2146
2147 void
gimp_image_set_file(GimpImage * image,GFile * file)2148 gimp_image_set_file (GimpImage *image,
2149 GFile *file)
2150 {
2151 GimpImagePrivate *private;
2152
2153 g_return_if_fail (GIMP_IS_IMAGE (image));
2154 g_return_if_fail (file == NULL || G_IS_FILE (file));
2155
2156 private = GIMP_IMAGE_GET_PRIVATE (image);
2157
2158 if (private->file != file)
2159 {
2160 gimp_object_take_name (GIMP_OBJECT (image),
2161 file ? g_file_get_uri (file) : NULL);
2162 }
2163 }
2164
2165 /**
2166 * gimp_image_get_untitled_file:
2167 *
2168 * Returns: A #GFile saying "Untitled" for newly created images.
2169 **/
2170 GFile *
gimp_image_get_untitled_file(GimpImage * image)2171 gimp_image_get_untitled_file (GimpImage *image)
2172 {
2173 GimpImagePrivate *private;
2174
2175 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2176
2177 private = GIMP_IMAGE_GET_PRIVATE (image);
2178
2179 if (! private->untitled_file)
2180 private->untitled_file = g_file_new_for_uri (_("Untitled"));
2181
2182 return private->untitled_file;
2183 }
2184
2185 /**
2186 * gimp_image_get_file_or_untitled:
2187 * @image: A #GimpImage.
2188 *
2189 * Get the file of the XCF image, or the "Untitled" file if there is no file.
2190 *
2191 * Returns: A #GFile.
2192 **/
2193 GFile *
gimp_image_get_file_or_untitled(GimpImage * image)2194 gimp_image_get_file_or_untitled (GimpImage *image)
2195 {
2196 GFile *file;
2197
2198 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2199
2200 file = gimp_image_get_file (image);
2201
2202 if (! file)
2203 file = gimp_image_get_untitled_file (image);
2204
2205 return file;
2206 }
2207
2208 /**
2209 * gimp_image_get_file:
2210 * @image: A #GimpImage.
2211 *
2212 * Get the file of the XCF image, or NULL if there is no file.
2213 *
2214 * Returns: The file, or NULL.
2215 **/
2216 GFile *
gimp_image_get_file(GimpImage * image)2217 gimp_image_get_file (GimpImage *image)
2218 {
2219 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2220
2221 return GIMP_IMAGE_GET_PRIVATE (image)->file;
2222 }
2223
2224 /**
2225 * gimp_image_get_imported_file:
2226 * @image: A #GimpImage.
2227 *
2228 * Returns: The file of the imported image, or NULL if the image has
2229 * been saved as XCF after it was imported.
2230 **/
2231 GFile *
gimp_image_get_imported_file(GimpImage * image)2232 gimp_image_get_imported_file (GimpImage *image)
2233 {
2234 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2235
2236 return GIMP_IMAGE_GET_PRIVATE (image)->imported_file;
2237 }
2238
2239 /**
2240 * gimp_image_get_exported_file:
2241 * @image: A #GimpImage.
2242 *
2243 * Returns: The file of the image last exported from this XCF file, or
2244 * NULL if the image has never been exported.
2245 **/
2246 GFile *
gimp_image_get_exported_file(GimpImage * image)2247 gimp_image_get_exported_file (GimpImage *image)
2248 {
2249 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2250
2251 return GIMP_IMAGE_GET_PRIVATE (image)->exported_file;
2252 }
2253
2254 /**
2255 * gimp_image_get_save_a_copy_file:
2256 * @image: A #GimpImage.
2257 *
2258 * Returns: The URI of the last copy that was saved of this XCF file.
2259 **/
2260 GFile *
gimp_image_get_save_a_copy_file(GimpImage * image)2261 gimp_image_get_save_a_copy_file (GimpImage *image)
2262 {
2263 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2264
2265 return GIMP_IMAGE_GET_PRIVATE (image)->save_a_copy_file;
2266 }
2267
2268 /**
2269 * gimp_image_get_any_file:
2270 * @image: A #GimpImage.
2271 *
2272 * Returns: The XCF file, the imported file, or the exported file, in
2273 * that order of precedence.
2274 **/
2275 GFile *
gimp_image_get_any_file(GimpImage * image)2276 gimp_image_get_any_file (GimpImage *image)
2277 {
2278 GFile *file;
2279
2280 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2281
2282 file = gimp_image_get_file (image);
2283 if (! file)
2284 {
2285 file = gimp_image_get_imported_file (image);
2286 if (! file)
2287 {
2288 file = gimp_image_get_exported_file (image);
2289 }
2290 }
2291
2292 return file;
2293 }
2294
2295 /**
2296 * gimp_image_set_imported_uri:
2297 * @image: A #GimpImage.
2298 * @file:
2299 *
2300 * Sets the URI this file was imported from.
2301 **/
2302 void
gimp_image_set_imported_file(GimpImage * image,GFile * file)2303 gimp_image_set_imported_file (GimpImage *image,
2304 GFile *file)
2305 {
2306 GimpImagePrivate *private;
2307
2308 g_return_if_fail (GIMP_IS_IMAGE (image));
2309 g_return_if_fail (file == NULL || G_IS_FILE (file));
2310
2311 private = GIMP_IMAGE_GET_PRIVATE (image);
2312
2313 if (g_set_object (&private->imported_file, file))
2314 {
2315 gimp_object_name_changed (GIMP_OBJECT (image));
2316 }
2317
2318 if (! private->resolution_set && file != NULL)
2319 {
2320 /* Unlike new files (which follow technological progress and will
2321 * use higher default resolution, or explicitly chosen templates),
2322 * imported files have a more backward-compatible value.
2323 *
2324 * 72 PPI is traditionnally the default value when none other had
2325 * been explicitly set (for instance it is the default when no
2326 * resolution metadata was set in Exif version 2.32, and below,
2327 * standard). This historical value will only ever apply to loaded
2328 * images. New images will continue having more modern or
2329 * templated defaults.
2330 */
2331 private->xresolution = 72.0;
2332 private->yresolution = 72.0;
2333 private->resolution_unit = GIMP_UNIT_INCH;
2334 }
2335 }
2336
2337 /**
2338 * gimp_image_set_exported_file:
2339 * @image: A #GimpImage.
2340 * @file:
2341 *
2342 * Sets the file this image was last exported to. Note that saving as
2343 * XCF is not "exporting".
2344 **/
2345 void
gimp_image_set_exported_file(GimpImage * image,GFile * file)2346 gimp_image_set_exported_file (GimpImage *image,
2347 GFile *file)
2348 {
2349 GimpImagePrivate *private;
2350
2351 g_return_if_fail (GIMP_IS_IMAGE (image));
2352 g_return_if_fail (file == NULL || G_IS_FILE (file));
2353
2354 private = GIMP_IMAGE_GET_PRIVATE (image);
2355
2356 if (g_set_object (&private->exported_file, file))
2357 {
2358 gimp_object_name_changed (GIMP_OBJECT (image));
2359 }
2360 }
2361
2362 /**
2363 * gimp_image_set_save_a_copy_file:
2364 * @image: A #GimpImage.
2365 * @uri:
2366 *
2367 * Set the URI to the last copy this XCF file was saved to through the
2368 * "save a copy" action.
2369 **/
2370 void
gimp_image_set_save_a_copy_file(GimpImage * image,GFile * file)2371 gimp_image_set_save_a_copy_file (GimpImage *image,
2372 GFile *file)
2373 {
2374 GimpImagePrivate *private;
2375
2376 g_return_if_fail (GIMP_IS_IMAGE (image));
2377 g_return_if_fail (file == NULL || G_IS_FILE (file));
2378
2379 private = GIMP_IMAGE_GET_PRIVATE (image);
2380
2381 g_set_object (&private->save_a_copy_file, file);
2382 }
2383
2384 static gchar *
gimp_image_format_display_uri(GimpImage * image,gboolean basename)2385 gimp_image_format_display_uri (GimpImage *image,
2386 gboolean basename)
2387 {
2388 const gchar *uri_format = NULL;
2389 const gchar *export_status = NULL;
2390 GFile *file = NULL;
2391 GFile *source = NULL;
2392 GFile *dest = NULL;
2393 GFile *display_file = NULL;
2394 gboolean is_imported;
2395 gboolean is_exported;
2396 gchar *display_uri = NULL;
2397 gchar *format_string;
2398 gchar *tmp;
2399
2400 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2401
2402 file = gimp_image_get_file (image);
2403 source = gimp_image_get_imported_file (image);
2404 dest = gimp_image_get_exported_file (image);
2405
2406 is_imported = (source != NULL);
2407 is_exported = (dest != NULL);
2408
2409 if (file)
2410 {
2411 display_file = g_object_ref (file);
2412 uri_format = "%s";
2413 }
2414 else
2415 {
2416 if (is_imported)
2417 display_file = source;
2418
2419 /* Calculate filename suffix */
2420 if (! gimp_image_is_export_dirty (image))
2421 {
2422 if (is_exported)
2423 {
2424 display_file = dest;
2425 export_status = _(" (exported)");
2426 }
2427 else if (is_imported)
2428 {
2429 export_status = _(" (overwritten)");
2430 }
2431 else
2432 {
2433 g_warning ("Unexpected code path, Save+export implementation is buggy!");
2434 }
2435 }
2436 else if (is_imported)
2437 {
2438 export_status = _(" (imported)");
2439 }
2440
2441 if (display_file)
2442 display_file = gimp_file_with_new_extension (display_file, NULL);
2443
2444 uri_format = "[%s]";
2445 }
2446
2447 if (! display_file)
2448 display_file = g_object_ref (gimp_image_get_untitled_file (image));
2449
2450 if (basename)
2451 display_uri = g_path_get_basename (gimp_file_get_utf8_name (display_file));
2452 else
2453 display_uri = g_strdup (gimp_file_get_utf8_name (display_file));
2454
2455 g_object_unref (display_file);
2456
2457 format_string = g_strconcat (uri_format, export_status, NULL);
2458
2459 tmp = g_strdup_printf (format_string, display_uri);
2460 g_free (display_uri);
2461 display_uri = tmp;
2462
2463 g_free (format_string);
2464
2465 return display_uri;
2466 }
2467
2468 const gchar *
gimp_image_get_display_name(GimpImage * image)2469 gimp_image_get_display_name (GimpImage *image)
2470 {
2471 GimpImagePrivate *private;
2472
2473 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2474
2475 private = GIMP_IMAGE_GET_PRIVATE (image);
2476
2477 if (! private->display_name)
2478 private->display_name = gimp_image_format_display_uri (image, TRUE);
2479
2480 return private->display_name;
2481 }
2482
2483 const gchar *
gimp_image_get_display_path(GimpImage * image)2484 gimp_image_get_display_path (GimpImage *image)
2485 {
2486 GimpImagePrivate *private;
2487
2488 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2489
2490 private = GIMP_IMAGE_GET_PRIVATE (image);
2491
2492 if (! private->display_path)
2493 private->display_path = gimp_image_format_display_uri (image, FALSE);
2494
2495 return private->display_path;
2496 }
2497
2498 void
gimp_image_set_load_proc(GimpImage * image,GimpPlugInProcedure * proc)2499 gimp_image_set_load_proc (GimpImage *image,
2500 GimpPlugInProcedure *proc)
2501 {
2502 g_return_if_fail (GIMP_IS_IMAGE (image));
2503
2504 GIMP_IMAGE_GET_PRIVATE (image)->load_proc = proc;
2505 }
2506
2507 GimpPlugInProcedure *
gimp_image_get_load_proc(GimpImage * image)2508 gimp_image_get_load_proc (GimpImage *image)
2509 {
2510 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2511
2512 return GIMP_IMAGE_GET_PRIVATE (image)->load_proc;
2513 }
2514
2515 void
gimp_image_set_save_proc(GimpImage * image,GimpPlugInProcedure * proc)2516 gimp_image_set_save_proc (GimpImage *image,
2517 GimpPlugInProcedure *proc)
2518 {
2519 g_return_if_fail (GIMP_IS_IMAGE (image));
2520
2521 GIMP_IMAGE_GET_PRIVATE (image)->save_proc = proc;
2522 }
2523
2524 GimpPlugInProcedure *
gimp_image_get_save_proc(GimpImage * image)2525 gimp_image_get_save_proc (GimpImage *image)
2526 {
2527 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2528
2529 return GIMP_IMAGE_GET_PRIVATE (image)->save_proc;
2530 }
2531
2532 void
gimp_image_set_export_proc(GimpImage * image,GimpPlugInProcedure * proc)2533 gimp_image_set_export_proc (GimpImage *image,
2534 GimpPlugInProcedure *proc)
2535 {
2536 g_return_if_fail (GIMP_IS_IMAGE (image));
2537
2538 GIMP_IMAGE_GET_PRIVATE (image)->export_proc = proc;
2539 }
2540
2541 GimpPlugInProcedure *
gimp_image_get_export_proc(GimpImage * image)2542 gimp_image_get_export_proc (GimpImage *image)
2543 {
2544 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2545
2546 return GIMP_IMAGE_GET_PRIVATE (image)->export_proc;
2547 }
2548
2549 gint
gimp_image_get_xcf_version(GimpImage * image,gboolean zlib_compression,gint * gimp_version,const gchar ** version_string,gchar ** version_reason)2550 gimp_image_get_xcf_version (GimpImage *image,
2551 gboolean zlib_compression,
2552 gint *gimp_version,
2553 const gchar **version_string,
2554 gchar **version_reason)
2555 {
2556 GList *layers;
2557 GList *list;
2558 GList *reasons = NULL;
2559 gint version = 0; /* default to oldest */
2560 const gchar *enum_desc;
2561
2562 #define ADD_REASON(_reason) \
2563 if (version_reason) { \
2564 gchar *tmp = _reason; \
2565 if (g_list_find_custom (reasons, tmp, (GCompareFunc) strcmp)) \
2566 g_free (tmp); \
2567 else \
2568 reasons = g_list_prepend (reasons, tmp); }
2569
2570 /* need version 1 for colormaps */
2571 if (gimp_image_get_colormap (image))
2572 version = 1;
2573
2574 layers = gimp_image_get_layer_list (image);
2575
2576 for (list = layers; list; list = g_list_next (list))
2577 {
2578 GimpLayer *layer = GIMP_LAYER (list->data);
2579
2580 switch (gimp_layer_get_mode (layer))
2581 {
2582 /* Modes that exist since ancient times */
2583 case GIMP_LAYER_MODE_NORMAL_LEGACY:
2584 case GIMP_LAYER_MODE_DISSOLVE:
2585 case GIMP_LAYER_MODE_BEHIND_LEGACY:
2586 case GIMP_LAYER_MODE_MULTIPLY_LEGACY:
2587 case GIMP_LAYER_MODE_SCREEN_LEGACY:
2588 case GIMP_LAYER_MODE_OVERLAY_LEGACY:
2589 case GIMP_LAYER_MODE_DIFFERENCE_LEGACY:
2590 case GIMP_LAYER_MODE_ADDITION_LEGACY:
2591 case GIMP_LAYER_MODE_SUBTRACT_LEGACY:
2592 case GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY:
2593 case GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY:
2594 case GIMP_LAYER_MODE_HSV_HUE_LEGACY:
2595 case GIMP_LAYER_MODE_HSV_SATURATION_LEGACY:
2596 case GIMP_LAYER_MODE_HSL_COLOR_LEGACY:
2597 case GIMP_LAYER_MODE_HSV_VALUE_LEGACY:
2598 case GIMP_LAYER_MODE_DIVIDE_LEGACY:
2599 case GIMP_LAYER_MODE_DODGE_LEGACY:
2600 case GIMP_LAYER_MODE_BURN_LEGACY:
2601 case GIMP_LAYER_MODE_HARDLIGHT_LEGACY:
2602 break;
2603
2604 /* Since 2.6 */
2605 case GIMP_LAYER_MODE_SOFTLIGHT_LEGACY:
2606 case GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY:
2607 case GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY:
2608 case GIMP_LAYER_MODE_COLOR_ERASE_LEGACY:
2609 gimp_enum_get_value (GIMP_TYPE_LAYER_MODE,
2610 gimp_layer_get_mode (layer),
2611 NULL, NULL, &enum_desc, NULL);
2612 ADD_REASON (g_strdup_printf (_("Layer mode '%s' was added in %s"),
2613 enum_desc, "GIMP 2.6"));
2614 version = MAX (2, version);
2615 break;
2616
2617 /* Since 2.10 */
2618 case GIMP_LAYER_MODE_OVERLAY:
2619 case GIMP_LAYER_MODE_LCH_HUE:
2620 case GIMP_LAYER_MODE_LCH_CHROMA:
2621 case GIMP_LAYER_MODE_LCH_COLOR:
2622 case GIMP_LAYER_MODE_LCH_LIGHTNESS:
2623 gimp_enum_get_value (GIMP_TYPE_LAYER_MODE,
2624 gimp_layer_get_mode (layer),
2625 NULL, NULL, &enum_desc, NULL);
2626 ADD_REASON (g_strdup_printf (_("Layer mode '%s' was added in %s"),
2627 enum_desc, "GIMP 2.10"));
2628 version = MAX (9, version);
2629 break;
2630
2631 /* Since 2.10 */
2632 case GIMP_LAYER_MODE_NORMAL:
2633 case GIMP_LAYER_MODE_BEHIND:
2634 case GIMP_LAYER_MODE_MULTIPLY:
2635 case GIMP_LAYER_MODE_SCREEN:
2636 case GIMP_LAYER_MODE_DIFFERENCE:
2637 case GIMP_LAYER_MODE_ADDITION:
2638 case GIMP_LAYER_MODE_SUBTRACT:
2639 case GIMP_LAYER_MODE_DARKEN_ONLY:
2640 case GIMP_LAYER_MODE_LIGHTEN_ONLY:
2641 case GIMP_LAYER_MODE_HSV_HUE:
2642 case GIMP_LAYER_MODE_HSV_SATURATION:
2643 case GIMP_LAYER_MODE_HSL_COLOR:
2644 case GIMP_LAYER_MODE_HSV_VALUE:
2645 case GIMP_LAYER_MODE_DIVIDE:
2646 case GIMP_LAYER_MODE_DODGE:
2647 case GIMP_LAYER_MODE_BURN:
2648 case GIMP_LAYER_MODE_HARDLIGHT:
2649 case GIMP_LAYER_MODE_SOFTLIGHT:
2650 case GIMP_LAYER_MODE_GRAIN_EXTRACT:
2651 case GIMP_LAYER_MODE_GRAIN_MERGE:
2652 case GIMP_LAYER_MODE_VIVID_LIGHT:
2653 case GIMP_LAYER_MODE_PIN_LIGHT:
2654 case GIMP_LAYER_MODE_LINEAR_LIGHT:
2655 case GIMP_LAYER_MODE_HARD_MIX:
2656 case GIMP_LAYER_MODE_EXCLUSION:
2657 case GIMP_LAYER_MODE_LINEAR_BURN:
2658 case GIMP_LAYER_MODE_LUMA_DARKEN_ONLY:
2659 case GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY:
2660 case GIMP_LAYER_MODE_LUMINANCE:
2661 case GIMP_LAYER_MODE_COLOR_ERASE:
2662 case GIMP_LAYER_MODE_ERASE:
2663 case GIMP_LAYER_MODE_MERGE:
2664 case GIMP_LAYER_MODE_SPLIT:
2665 case GIMP_LAYER_MODE_PASS_THROUGH:
2666 gimp_enum_get_value (GIMP_TYPE_LAYER_MODE,
2667 gimp_layer_get_mode (layer),
2668 NULL, NULL, &enum_desc, NULL);
2669 ADD_REASON (g_strdup_printf (_("Layer mode '%s' was added in %s"),
2670 enum_desc, "GIMP 2.10"));
2671 version = MAX (10, version);
2672 break;
2673
2674 /* Just here instead of default so we get compiler warnings */
2675 case GIMP_LAYER_MODE_REPLACE:
2676 case GIMP_LAYER_MODE_ANTI_ERASE:
2677 case GIMP_LAYER_MODE_SEPARATOR:
2678 break;
2679 }
2680
2681 /* need version 3 for layer trees */
2682 if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
2683 {
2684 ADD_REASON (g_strdup_printf (_("Layer groups were added in %s"),
2685 "GIMP 2.8"));
2686 version = MAX (3, version);
2687
2688 /* need version 13 for group layers with masks */
2689 if (gimp_layer_get_mask (layer))
2690 {
2691 ADD_REASON (g_strdup_printf (_("Masks on layer groups were "
2692 "added in %s"), "GIMP 2.10"));
2693 version = MAX (13, version);
2694 }
2695 }
2696 }
2697
2698 g_list_free (layers);
2699
2700 /* version 6 for new metadata has been dropped since they are
2701 * saved through parasites, which is compatible with older versions.
2702 */
2703
2704 /* need version 7 for != 8-bit gamma images */
2705 if (gimp_image_get_precision (image) != GIMP_PRECISION_U8_GAMMA)
2706 {
2707 ADD_REASON (g_strdup_printf (_("High bit-depth images were added "
2708 "in %s"), "GIMP 2.10"));
2709 version = MAX (7, version);
2710 }
2711
2712 /* need version 12 for > 8-bit images for proper endian swapping */
2713 if (gimp_image_get_precision (image) > GIMP_PRECISION_U8_GAMMA)
2714 version = MAX (12, version);
2715
2716 /* need version 8 for zlib compression */
2717 if (zlib_compression)
2718 {
2719 ADD_REASON (g_strdup_printf (_("Internal zlib compression was "
2720 "added in %s"), "GIMP 2.10"));
2721 version = MAX (8, version);
2722 }
2723
2724 /* if version is 10 (lots of new layer modes), go to version 11 with
2725 * 64 bit offsets right away
2726 */
2727 if (version == 10)
2728 version = 11;
2729
2730 /* use the image's in-memory size as an upper bound to estimate the
2731 * need for 64 bit file offsets inside the XCF, this is a *very*
2732 * conservative estimate and should never fail
2733 */
2734 if (gimp_object_get_memsize (GIMP_OBJECT (image), NULL) >= ((gint64) 1 << 32))
2735 {
2736 ADD_REASON (g_strdup_printf (_("Support for image files larger than "
2737 "4GB was added in %s"), "GIMP 2.10"));
2738 version = MAX (11, version);
2739 }
2740
2741 #undef ADD_REASON
2742
2743 switch (version)
2744 {
2745 case 0:
2746 case 1:
2747 case 2:
2748 if (gimp_version) *gimp_version = 206;
2749 if (version_string) *version_string = "GIMP 2.6";
2750 break;
2751
2752 case 3:
2753 if (gimp_version) *gimp_version = 208;
2754 if (version_string) *version_string = "GIMP 2.8";
2755 break;
2756
2757 case 4:
2758 case 5:
2759 case 6:
2760 case 7:
2761 case 8:
2762 case 9:
2763 case 10:
2764 case 11:
2765 case 12:
2766 case 13:
2767 if (gimp_version) *gimp_version = 210;
2768 if (version_string) *version_string = "GIMP 2.10";
2769 break;
2770 }
2771
2772 if (version_reason && reasons)
2773 {
2774 GString *reason = g_string_new (NULL);
2775
2776 reasons = g_list_sort (reasons, (GCompareFunc) strcmp);
2777
2778 for (list = reasons; list; list = g_list_next (list))
2779 {
2780 g_string_append (reason, list->data);
2781 if (g_list_next (list))
2782 g_string_append_c (reason, '\n');
2783 }
2784
2785 *version_reason = g_string_free (reason, FALSE);
2786 }
2787 if (reasons)
2788 g_list_free_full (reasons, g_free);
2789
2790 return version;
2791 }
2792
2793 void
gimp_image_set_xcf_compression(GimpImage * image,gboolean compression)2794 gimp_image_set_xcf_compression (GimpImage *image,
2795 gboolean compression)
2796 {
2797 g_return_if_fail (GIMP_IS_IMAGE (image));
2798
2799 GIMP_IMAGE_GET_PRIVATE (image)->xcf_compression = compression;
2800 }
2801
2802 gboolean
gimp_image_get_xcf_compression(GimpImage * image)2803 gimp_image_get_xcf_compression (GimpImage *image)
2804 {
2805 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
2806
2807 return GIMP_IMAGE_GET_PRIVATE (image)->xcf_compression;
2808 }
2809
2810 void
gimp_image_set_resolution(GimpImage * image,gdouble xresolution,gdouble yresolution)2811 gimp_image_set_resolution (GimpImage *image,
2812 gdouble xresolution,
2813 gdouble yresolution)
2814 {
2815 GimpImagePrivate *private;
2816
2817 g_return_if_fail (GIMP_IS_IMAGE (image));
2818
2819 private = GIMP_IMAGE_GET_PRIVATE (image);
2820
2821 /* don't allow to set the resolution out of bounds */
2822 if (xresolution < GIMP_MIN_RESOLUTION || xresolution > GIMP_MAX_RESOLUTION ||
2823 yresolution < GIMP_MIN_RESOLUTION || yresolution > GIMP_MAX_RESOLUTION)
2824 return;
2825
2826 private->resolution_set = TRUE;
2827
2828 if ((ABS (private->xresolution - xresolution) >= 1e-5) ||
2829 (ABS (private->yresolution - yresolution) >= 1e-5))
2830 {
2831 gimp_image_undo_push_image_resolution (image,
2832 C_("undo-type", "Change Image Resolution"));
2833
2834 private->xresolution = xresolution;
2835 private->yresolution = yresolution;
2836
2837 gimp_image_resolution_changed (image);
2838 gimp_image_size_changed_detailed (image,
2839 0,
2840 0,
2841 gimp_image_get_width (image),
2842 gimp_image_get_height (image));
2843 }
2844 }
2845
2846 void
gimp_image_get_resolution(GimpImage * image,gdouble * xresolution,gdouble * yresolution)2847 gimp_image_get_resolution (GimpImage *image,
2848 gdouble *xresolution,
2849 gdouble *yresolution)
2850 {
2851 GimpImagePrivate *private;
2852
2853 g_return_if_fail (GIMP_IS_IMAGE (image));
2854 g_return_if_fail (xresolution != NULL && yresolution != NULL);
2855
2856 private = GIMP_IMAGE_GET_PRIVATE (image);
2857
2858 *xresolution = private->xresolution;
2859 *yresolution = private->yresolution;
2860 }
2861
2862 void
gimp_image_resolution_changed(GimpImage * image)2863 gimp_image_resolution_changed (GimpImage *image)
2864 {
2865 g_return_if_fail (GIMP_IS_IMAGE (image));
2866
2867 g_signal_emit (image, gimp_image_signals[RESOLUTION_CHANGED], 0);
2868 }
2869
2870 void
gimp_image_set_unit(GimpImage * image,GimpUnit unit)2871 gimp_image_set_unit (GimpImage *image,
2872 GimpUnit unit)
2873 {
2874 GimpImagePrivate *private;
2875
2876 g_return_if_fail (GIMP_IS_IMAGE (image));
2877 g_return_if_fail (unit > GIMP_UNIT_PIXEL);
2878
2879 private = GIMP_IMAGE_GET_PRIVATE (image);
2880
2881 if (private->resolution_unit != unit)
2882 {
2883 gimp_image_undo_push_image_resolution (image,
2884 C_("undo-type", "Change Image Unit"));
2885
2886 private->resolution_unit = unit;
2887 gimp_image_unit_changed (image);
2888 }
2889 }
2890
2891 GimpUnit
gimp_image_get_unit(GimpImage * image)2892 gimp_image_get_unit (GimpImage *image)
2893 {
2894 g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_UNIT_INCH);
2895
2896 return GIMP_IMAGE_GET_PRIVATE (image)->resolution_unit;
2897 }
2898
2899 void
gimp_image_unit_changed(GimpImage * image)2900 gimp_image_unit_changed (GimpImage *image)
2901 {
2902 g_return_if_fail (GIMP_IS_IMAGE (image));
2903
2904 g_signal_emit (image, gimp_image_signals[UNIT_CHANGED], 0);
2905 }
2906
2907 gint
gimp_image_get_width(GimpImage * image)2908 gimp_image_get_width (GimpImage *image)
2909 {
2910 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
2911
2912 return GIMP_IMAGE_GET_PRIVATE (image)->width;
2913 }
2914
2915 gint
gimp_image_get_height(GimpImage * image)2916 gimp_image_get_height (GimpImage *image)
2917 {
2918 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
2919
2920 return GIMP_IMAGE_GET_PRIVATE (image)->height;
2921 }
2922
2923 gboolean
gimp_image_has_alpha(GimpImage * image)2924 gimp_image_has_alpha (GimpImage *image)
2925 {
2926 GimpImagePrivate *private;
2927 GimpLayer *layer;
2928
2929 g_return_val_if_fail (GIMP_IS_IMAGE (image), TRUE);
2930
2931 private = GIMP_IMAGE_GET_PRIVATE (image);
2932
2933 layer = GIMP_LAYER (gimp_container_get_first_child (private->layers->container));
2934
2935 return ((gimp_image_get_n_layers (image) > 1) ||
2936 (layer && gimp_drawable_has_alpha (GIMP_DRAWABLE (layer))));
2937 }
2938
2939 gboolean
gimp_image_is_empty(GimpImage * image)2940 gimp_image_is_empty (GimpImage *image)
2941 {
2942 g_return_val_if_fail (GIMP_IS_IMAGE (image), TRUE);
2943
2944 return gimp_container_is_empty (GIMP_IMAGE_GET_PRIVATE (image)->layers->container);
2945 }
2946
2947 void
gimp_image_set_floating_selection(GimpImage * image,GimpLayer * floating_sel)2948 gimp_image_set_floating_selection (GimpImage *image,
2949 GimpLayer *floating_sel)
2950 {
2951 GimpImagePrivate *private;
2952
2953 g_return_if_fail (GIMP_IS_IMAGE (image));
2954 g_return_if_fail (floating_sel == NULL || GIMP_IS_LAYER (floating_sel));
2955
2956 private = GIMP_IMAGE_GET_PRIVATE (image);
2957
2958 if (private->floating_sel != floating_sel)
2959 {
2960 private->floating_sel = floating_sel;
2961
2962 private->flush_accum.floating_selection_changed = TRUE;
2963 }
2964 }
2965
2966 GimpLayer *
gimp_image_get_floating_selection(GimpImage * image)2967 gimp_image_get_floating_selection (GimpImage *image)
2968 {
2969 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2970
2971 return GIMP_IMAGE_GET_PRIVATE (image)->floating_sel;
2972 }
2973
2974 void
gimp_image_floating_selection_changed(GimpImage * image)2975 gimp_image_floating_selection_changed (GimpImage *image)
2976 {
2977 g_return_if_fail (GIMP_IS_IMAGE (image));
2978
2979 g_signal_emit (image, gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
2980 }
2981
2982 GimpChannel *
gimp_image_get_mask(GimpImage * image)2983 gimp_image_get_mask (GimpImage *image)
2984 {
2985 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
2986
2987 return GIMP_IMAGE_GET_PRIVATE (image)->selection_mask;
2988 }
2989
2990 void
gimp_image_mask_changed(GimpImage * image)2991 gimp_image_mask_changed (GimpImage *image)
2992 {
2993 g_return_if_fail (GIMP_IS_IMAGE (image));
2994
2995 g_signal_emit (image, gimp_image_signals[MASK_CHANGED], 0);
2996 }
2997
2998 void
gimp_image_take_mask(GimpImage * image,GimpChannel * mask)2999 gimp_image_take_mask (GimpImage *image,
3000 GimpChannel *mask)
3001 {
3002 GimpImagePrivate *private;
3003
3004 g_return_if_fail (GIMP_IS_IMAGE (image));
3005 g_return_if_fail (GIMP_IS_SELECTION (mask));
3006
3007 private = GIMP_IMAGE_GET_PRIVATE (image);
3008
3009 if (private->selection_mask)
3010 g_object_unref (private->selection_mask);
3011
3012 private->selection_mask = g_object_ref_sink (mask);
3013
3014 g_signal_connect (private->selection_mask, "update",
3015 G_CALLBACK (gimp_image_mask_update),
3016 image);
3017 }
3018
3019
3020 /* image components */
3021
3022 const Babl *
gimp_image_get_component_format(GimpImage * image,GimpChannelType channel)3023 gimp_image_get_component_format (GimpImage *image,
3024 GimpChannelType channel)
3025 {
3026 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
3027
3028 switch (channel)
3029 {
3030 case GIMP_CHANNEL_RED:
3031 return gimp_babl_component_format (GIMP_RGB,
3032 gimp_image_get_precision (image),
3033 RED);
3034
3035 case GIMP_CHANNEL_GREEN:
3036 return gimp_babl_component_format (GIMP_RGB,
3037 gimp_image_get_precision (image),
3038 GREEN);
3039
3040 case GIMP_CHANNEL_BLUE:
3041 return gimp_babl_component_format (GIMP_RGB,
3042 gimp_image_get_precision (image),
3043 BLUE);
3044
3045 case GIMP_CHANNEL_ALPHA:
3046 return gimp_babl_component_format (GIMP_RGB,
3047 gimp_image_get_precision (image),
3048 ALPHA);
3049
3050 case GIMP_CHANNEL_GRAY:
3051 return gimp_babl_component_format (GIMP_GRAY,
3052 gimp_image_get_precision (image),
3053 GRAY);
3054
3055 case GIMP_CHANNEL_INDEXED:
3056 return babl_format ("Y u8"); /* will extract grayscale, the best
3057 * we can do here */
3058 }
3059
3060 return NULL;
3061 }
3062
3063 gint
gimp_image_get_component_index(GimpImage * image,GimpChannelType channel)3064 gimp_image_get_component_index (GimpImage *image,
3065 GimpChannelType channel)
3066 {
3067 g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
3068
3069 switch (channel)
3070 {
3071 case GIMP_CHANNEL_RED: return RED;
3072 case GIMP_CHANNEL_GREEN: return GREEN;
3073 case GIMP_CHANNEL_BLUE: return BLUE;
3074 case GIMP_CHANNEL_GRAY: return GRAY;
3075 case GIMP_CHANNEL_INDEXED: return INDEXED;
3076 case GIMP_CHANNEL_ALPHA:
3077 switch (gimp_image_get_base_type (image))
3078 {
3079 case GIMP_RGB: return ALPHA;
3080 case GIMP_GRAY: return ALPHA_G;
3081 case GIMP_INDEXED: return ALPHA_I;
3082 }
3083 }
3084
3085 return -1;
3086 }
3087
3088 void
gimp_image_set_component_active(GimpImage * image,GimpChannelType channel,gboolean active)3089 gimp_image_set_component_active (GimpImage *image,
3090 GimpChannelType channel,
3091 gboolean active)
3092 {
3093 GimpImagePrivate *private;
3094 gint index = -1;
3095
3096 g_return_if_fail (GIMP_IS_IMAGE (image));
3097
3098 private = GIMP_IMAGE_GET_PRIVATE (image);
3099
3100 index = gimp_image_get_component_index (image, channel);
3101
3102 if (index != -1 && active != private->active[index])
3103 {
3104 private->active[index] = active ? TRUE : FALSE;
3105
3106 /* If there is an active channel and we mess with the components,
3107 * the active channel gets unset...
3108 */
3109 gimp_image_unset_active_channel (image);
3110
3111 g_signal_emit (image,
3112 gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
3113 channel);
3114 }
3115 }
3116
3117 gboolean
gimp_image_get_component_active(GimpImage * image,GimpChannelType channel)3118 gimp_image_get_component_active (GimpImage *image,
3119 GimpChannelType channel)
3120 {
3121 gint index = -1;
3122
3123 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3124
3125 index = gimp_image_get_component_index (image, channel);
3126
3127 if (index != -1)
3128 return GIMP_IMAGE_GET_PRIVATE (image)->active[index];
3129
3130 return FALSE;
3131 }
3132
3133 void
gimp_image_get_active_array(GimpImage * image,gboolean * components)3134 gimp_image_get_active_array (GimpImage *image,
3135 gboolean *components)
3136 {
3137 GimpImagePrivate *private;
3138 gint i;
3139
3140 g_return_if_fail (GIMP_IS_IMAGE (image));
3141 g_return_if_fail (components != NULL);
3142
3143 private = GIMP_IMAGE_GET_PRIVATE (image);
3144
3145 for (i = 0; i < MAX_CHANNELS; i++)
3146 components[i] = private->active[i];
3147 }
3148
3149 GimpComponentMask
gimp_image_get_active_mask(GimpImage * image)3150 gimp_image_get_active_mask (GimpImage *image)
3151 {
3152 GimpImagePrivate *private;
3153 GimpComponentMask mask = 0;
3154
3155 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3156
3157 private = GIMP_IMAGE_GET_PRIVATE (image);
3158
3159 switch (gimp_image_get_base_type (image))
3160 {
3161 case GIMP_RGB:
3162 mask |= (private->active[RED]) ? GIMP_COMPONENT_MASK_RED : 0;
3163 mask |= (private->active[GREEN]) ? GIMP_COMPONENT_MASK_GREEN : 0;
3164 mask |= (private->active[BLUE]) ? GIMP_COMPONENT_MASK_BLUE : 0;
3165 mask |= (private->active[ALPHA]) ? GIMP_COMPONENT_MASK_ALPHA : 0;
3166 break;
3167
3168 case GIMP_GRAY:
3169 case GIMP_INDEXED:
3170 mask |= (private->active[GRAY]) ? GIMP_COMPONENT_MASK_RED : 0;
3171 mask |= (private->active[GRAY]) ? GIMP_COMPONENT_MASK_GREEN : 0;
3172 mask |= (private->active[GRAY]) ? GIMP_COMPONENT_MASK_BLUE : 0;
3173 mask |= (private->active[ALPHA_G]) ? GIMP_COMPONENT_MASK_ALPHA : 0;
3174 break;
3175 }
3176
3177 return mask;
3178 }
3179
3180 void
gimp_image_set_component_visible(GimpImage * image,GimpChannelType channel,gboolean visible)3181 gimp_image_set_component_visible (GimpImage *image,
3182 GimpChannelType channel,
3183 gboolean visible)
3184 {
3185 GimpImagePrivate *private;
3186 gint index = -1;
3187
3188 g_return_if_fail (GIMP_IS_IMAGE (image));
3189
3190 private = GIMP_IMAGE_GET_PRIVATE (image);
3191
3192 index = gimp_image_get_component_index (image, channel);
3193
3194 if (index != -1 && visible != private->visible[index])
3195 {
3196 private->visible[index] = visible ? TRUE : FALSE;
3197
3198 if (private->visible_mask)
3199 {
3200 GimpComponentMask mask;
3201
3202 mask = ~gimp_image_get_visible_mask (image) & GIMP_COMPONENT_MASK_ALL;
3203
3204 gegl_node_set (private->visible_mask,
3205 "mask", mask,
3206 NULL);
3207 }
3208
3209 g_signal_emit (image,
3210 gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
3211 channel);
3212
3213 gimp_image_invalidate_all (image);
3214 }
3215 }
3216
3217 gboolean
gimp_image_get_component_visible(GimpImage * image,GimpChannelType channel)3218 gimp_image_get_component_visible (GimpImage *image,
3219 GimpChannelType channel)
3220 {
3221 gint index = -1;
3222
3223 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3224
3225 index = gimp_image_get_component_index (image, channel);
3226
3227 if (index != -1)
3228 return GIMP_IMAGE_GET_PRIVATE (image)->visible[index];
3229
3230 return FALSE;
3231 }
3232
3233 void
gimp_image_get_visible_array(GimpImage * image,gboolean * components)3234 gimp_image_get_visible_array (GimpImage *image,
3235 gboolean *components)
3236 {
3237 GimpImagePrivate *private;
3238 gint i;
3239
3240 g_return_if_fail (GIMP_IS_IMAGE (image));
3241 g_return_if_fail (components != NULL);
3242
3243 private = GIMP_IMAGE_GET_PRIVATE (image);
3244
3245 for (i = 0; i < MAX_CHANNELS; i++)
3246 components[i] = private->visible[i];
3247 }
3248
3249 GimpComponentMask
gimp_image_get_visible_mask(GimpImage * image)3250 gimp_image_get_visible_mask (GimpImage *image)
3251 {
3252 GimpImagePrivate *private;
3253 GimpComponentMask mask = 0;
3254
3255 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3256
3257 private = GIMP_IMAGE_GET_PRIVATE (image);
3258
3259 switch (gimp_image_get_base_type (image))
3260 {
3261 case GIMP_RGB:
3262 mask |= (private->visible[RED]) ? GIMP_COMPONENT_MASK_RED : 0;
3263 mask |= (private->visible[GREEN]) ? GIMP_COMPONENT_MASK_GREEN : 0;
3264 mask |= (private->visible[BLUE]) ? GIMP_COMPONENT_MASK_BLUE : 0;
3265 mask |= (private->visible[ALPHA]) ? GIMP_COMPONENT_MASK_ALPHA : 0;
3266 break;
3267
3268 case GIMP_GRAY:
3269 case GIMP_INDEXED:
3270 mask |= (private->visible[GRAY]) ? GIMP_COMPONENT_MASK_RED : 0;
3271 mask |= (private->visible[GRAY]) ? GIMP_COMPONENT_MASK_GREEN : 0;
3272 mask |= (private->visible[GRAY]) ? GIMP_COMPONENT_MASK_BLUE : 0;
3273 mask |= (private->visible[ALPHA]) ? GIMP_COMPONENT_MASK_ALPHA : 0;
3274 break;
3275 }
3276
3277 return mask;
3278 }
3279
3280
3281 /* emitting image signals */
3282
3283 void
gimp_image_mode_changed(GimpImage * image)3284 gimp_image_mode_changed (GimpImage *image)
3285 {
3286 g_return_if_fail (GIMP_IS_IMAGE (image));
3287
3288 g_signal_emit (image, gimp_image_signals[MODE_CHANGED], 0);
3289 }
3290
3291 void
gimp_image_precision_changed(GimpImage * image)3292 gimp_image_precision_changed (GimpImage *image)
3293 {
3294 g_return_if_fail (GIMP_IS_IMAGE (image));
3295
3296 g_signal_emit (image, gimp_image_signals[PRECISION_CHANGED], 0);
3297 }
3298
3299 void
gimp_image_alpha_changed(GimpImage * image)3300 gimp_image_alpha_changed (GimpImage *image)
3301 {
3302 g_return_if_fail (GIMP_IS_IMAGE (image));
3303
3304 g_signal_emit (image, gimp_image_signals[ALPHA_CHANGED], 0);
3305 }
3306
3307 void
gimp_image_linked_items_changed(GimpImage * image)3308 gimp_image_linked_items_changed (GimpImage *image)
3309 {
3310 g_return_if_fail (GIMP_IS_IMAGE (image));
3311
3312 g_signal_emit (image, gimp_image_signals[LINKED_ITEMS_CHANGED], 0);
3313 }
3314
3315 void
gimp_image_invalidate(GimpImage * image,gint x,gint y,gint width,gint height)3316 gimp_image_invalidate (GimpImage *image,
3317 gint x,
3318 gint y,
3319 gint width,
3320 gint height)
3321 {
3322 g_return_if_fail (GIMP_IS_IMAGE (image));
3323
3324 gimp_projectable_invalidate (GIMP_PROJECTABLE (image),
3325 x, y, width, height);
3326
3327 GIMP_IMAGE_GET_PRIVATE (image)->flush_accum.preview_invalidated = TRUE;
3328 }
3329
3330 void
gimp_image_invalidate_all(GimpImage * image)3331 gimp_image_invalidate_all (GimpImage *image)
3332 {
3333 const GeglRectangle *bounding_box;
3334
3335 g_return_if_fail (GIMP_IS_IMAGE (image));
3336
3337 bounding_box = &GIMP_IMAGE_GET_PRIVATE (image)->bounding_box;
3338
3339 gimp_image_invalidate (image,
3340 bounding_box->x, bounding_box->y,
3341 bounding_box->width, bounding_box->height);
3342 }
3343
3344 void
gimp_image_guide_added(GimpImage * image,GimpGuide * guide)3345 gimp_image_guide_added (GimpImage *image,
3346 GimpGuide *guide)
3347 {
3348 g_return_if_fail (GIMP_IS_IMAGE (image));
3349 g_return_if_fail (GIMP_IS_GUIDE (guide));
3350
3351 g_signal_emit (image, gimp_image_signals[GUIDE_ADDED], 0,
3352 guide);
3353 }
3354
3355 void
gimp_image_guide_removed(GimpImage * image,GimpGuide * guide)3356 gimp_image_guide_removed (GimpImage *image,
3357 GimpGuide *guide)
3358 {
3359 g_return_if_fail (GIMP_IS_IMAGE (image));
3360 g_return_if_fail (GIMP_IS_GUIDE (guide));
3361
3362 g_signal_emit (image, gimp_image_signals[GUIDE_REMOVED], 0,
3363 guide);
3364 }
3365
3366 void
gimp_image_guide_moved(GimpImage * image,GimpGuide * guide)3367 gimp_image_guide_moved (GimpImage *image,
3368 GimpGuide *guide)
3369 {
3370 g_return_if_fail (GIMP_IS_IMAGE (image));
3371 g_return_if_fail (GIMP_IS_GUIDE (guide));
3372
3373 g_signal_emit (image, gimp_image_signals[GUIDE_MOVED], 0,
3374 guide);
3375 }
3376
3377 void
gimp_image_sample_point_added(GimpImage * image,GimpSamplePoint * sample_point)3378 gimp_image_sample_point_added (GimpImage *image,
3379 GimpSamplePoint *sample_point)
3380 {
3381 g_return_if_fail (GIMP_IS_IMAGE (image));
3382 g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
3383
3384 g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_ADDED], 0,
3385 sample_point);
3386 }
3387
3388 void
gimp_image_sample_point_removed(GimpImage * image,GimpSamplePoint * sample_point)3389 gimp_image_sample_point_removed (GimpImage *image,
3390 GimpSamplePoint *sample_point)
3391 {
3392 g_return_if_fail (GIMP_IS_IMAGE (image));
3393 g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
3394
3395 g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_REMOVED], 0,
3396 sample_point);
3397 }
3398
3399 void
gimp_image_sample_point_moved(GimpImage * image,GimpSamplePoint * sample_point)3400 gimp_image_sample_point_moved (GimpImage *image,
3401 GimpSamplePoint *sample_point)
3402 {
3403 g_return_if_fail (GIMP_IS_IMAGE (image));
3404 g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
3405
3406 g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_MOVED], 0,
3407 sample_point);
3408 }
3409
3410 /**
3411 * gimp_image_size_changed_detailed:
3412 * @image:
3413 * @previous_origin_x:
3414 * @previous_origin_y:
3415 *
3416 * Emits the size-changed-detailed signal that is typically used to adjust the
3417 * position of the image in the display shell on various operations,
3418 * e.g. crop.
3419 *
3420 * This function makes sure that GimpViewable::size-changed is also emitted.
3421 **/
3422 void
gimp_image_size_changed_detailed(GimpImage * image,gint previous_origin_x,gint previous_origin_y,gint previous_width,gint previous_height)3423 gimp_image_size_changed_detailed (GimpImage *image,
3424 gint previous_origin_x,
3425 gint previous_origin_y,
3426 gint previous_width,
3427 gint previous_height)
3428 {
3429 g_return_if_fail (GIMP_IS_IMAGE (image));
3430
3431 g_signal_emit (image, gimp_image_signals[SIZE_CHANGED_DETAILED], 0,
3432 previous_origin_x,
3433 previous_origin_y,
3434 previous_width,
3435 previous_height);
3436 }
3437
3438 void
gimp_image_colormap_changed(GimpImage * image,gint color_index)3439 gimp_image_colormap_changed (GimpImage *image,
3440 gint color_index)
3441 {
3442 g_return_if_fail (GIMP_IS_IMAGE (image));
3443 g_return_if_fail (color_index >= -1 &&
3444 color_index < GIMP_IMAGE_GET_PRIVATE (image)->n_colors);
3445
3446 g_signal_emit (image, gimp_image_signals[COLORMAP_CHANGED], 0,
3447 color_index);
3448 }
3449
3450 void
gimp_image_selection_invalidate(GimpImage * image)3451 gimp_image_selection_invalidate (GimpImage *image)
3452 {
3453 g_return_if_fail (GIMP_IS_IMAGE (image));
3454
3455 g_signal_emit (image, gimp_image_signals[SELECTION_INVALIDATE], 0);
3456 }
3457
3458 void
gimp_image_quick_mask_changed(GimpImage * image)3459 gimp_image_quick_mask_changed (GimpImage *image)
3460 {
3461 g_return_if_fail (GIMP_IS_IMAGE (image));
3462
3463 g_signal_emit (image, gimp_image_signals[QUICK_MASK_CHANGED], 0);
3464 }
3465
3466 void
gimp_image_undo_event(GimpImage * image,GimpUndoEvent event,GimpUndo * undo)3467 gimp_image_undo_event (GimpImage *image,
3468 GimpUndoEvent event,
3469 GimpUndo *undo)
3470 {
3471 g_return_if_fail (GIMP_IS_IMAGE (image));
3472 g_return_if_fail (((event == GIMP_UNDO_EVENT_UNDO_FREE ||
3473 event == GIMP_UNDO_EVENT_UNDO_FREEZE ||
3474 event == GIMP_UNDO_EVENT_UNDO_THAW) && undo == NULL) ||
3475 GIMP_IS_UNDO (undo));
3476
3477 g_signal_emit (image, gimp_image_signals[UNDO_EVENT], 0, event, undo);
3478 }
3479
3480
3481 /* dirty counters */
3482
3483 /* NOTE about the image->dirty counter:
3484 * If 0, then the image is clean (ie, copy on disk is the same as the one
3485 * in memory).
3486 * If positive, then that's the number of dirtying operations done
3487 * on the image since the last save.
3488 * If negative, then user has hit undo and gone back in time prior
3489 * to the saved copy. Hitting redo will eventually come back to
3490 * the saved copy.
3491 *
3492 * The image is dirty (ie, needs saving) if counter is non-zero.
3493 *
3494 * If the counter is around 100000, this is due to undo-ing back
3495 * before a saved version, then changing the image (thus destroying
3496 * the redo stack). Once this has happened, it's impossible to get
3497 * the image back to the state on disk, since the redo info has been
3498 * freed. See gimpimage-undo.c for the gory details.
3499 */
3500
3501 /*
3502 * NEVER CALL gimp_image_dirty() directly!
3503 *
3504 * If your code has just dirtied the image, push an undo instead.
3505 * Failing that, push the trivial undo which tells the user the
3506 * command is not undoable: undo_push_cantundo() (But really, it would
3507 * be best to push a proper undo). If you just dirty the image
3508 * without pushing an undo then the dirty count is increased, but
3509 * popping that many undo actions won't lead to a clean image.
3510 */
3511
3512 gint
gimp_image_dirty(GimpImage * image,GimpDirtyMask dirty_mask)3513 gimp_image_dirty (GimpImage *image,
3514 GimpDirtyMask dirty_mask)
3515 {
3516 GimpImagePrivate *private;
3517
3518 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3519
3520 private = GIMP_IMAGE_GET_PRIVATE (image);
3521
3522 private->dirty++;
3523 private->export_dirty++;
3524
3525 if (! private->dirty_time)
3526 private->dirty_time = time (NULL);
3527
3528 g_signal_emit (image, gimp_image_signals[DIRTY], 0, dirty_mask);
3529
3530 TRC (("dirty %d -> %d\n", private->dirty - 1, private->dirty));
3531
3532 return private->dirty;
3533 }
3534
3535 gint
gimp_image_clean(GimpImage * image,GimpDirtyMask dirty_mask)3536 gimp_image_clean (GimpImage *image,
3537 GimpDirtyMask dirty_mask)
3538 {
3539 GimpImagePrivate *private;
3540
3541 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3542
3543 private = GIMP_IMAGE_GET_PRIVATE (image);
3544
3545 private->dirty--;
3546 private->export_dirty--;
3547
3548 g_signal_emit (image, gimp_image_signals[CLEAN], 0, dirty_mask);
3549
3550 TRC (("clean %d -> %d\n", private->dirty + 1, private->dirty));
3551
3552 return private->dirty;
3553 }
3554
3555 void
gimp_image_clean_all(GimpImage * image)3556 gimp_image_clean_all (GimpImage *image)
3557 {
3558 GimpImagePrivate *private;
3559
3560 g_return_if_fail (GIMP_IS_IMAGE (image));
3561
3562 private = GIMP_IMAGE_GET_PRIVATE (image);
3563
3564 private->dirty = 0;
3565 private->dirty_time = 0;
3566
3567 g_signal_emit (image, gimp_image_signals[CLEAN], 0, GIMP_DIRTY_ALL);
3568
3569 gimp_object_name_changed (GIMP_OBJECT (image));
3570 }
3571
3572 void
gimp_image_export_clean_all(GimpImage * image)3573 gimp_image_export_clean_all (GimpImage *image)
3574 {
3575 GimpImagePrivate *private;
3576
3577 g_return_if_fail (GIMP_IS_IMAGE (image));
3578
3579 private = GIMP_IMAGE_GET_PRIVATE (image);
3580
3581 private->export_dirty = 0;
3582
3583 g_signal_emit (image, gimp_image_signals[CLEAN], 0, GIMP_DIRTY_ALL);
3584
3585 gimp_object_name_changed (GIMP_OBJECT (image));
3586 }
3587
3588 /**
3589 * gimp_image_is_dirty:
3590 * @image:
3591 *
3592 * Returns: True if the image is dirty, false otherwise.
3593 **/
3594 gint
gimp_image_is_dirty(GimpImage * image)3595 gimp_image_is_dirty (GimpImage *image)
3596 {
3597 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3598
3599 return GIMP_IMAGE_GET_PRIVATE (image)->dirty != 0;
3600 }
3601
3602 /**
3603 * gimp_image_is_export_dirty:
3604 * @image:
3605 *
3606 * Returns: True if the image export is dirty, false otherwise.
3607 **/
3608 gboolean
gimp_image_is_export_dirty(GimpImage * image)3609 gimp_image_is_export_dirty (GimpImage *image)
3610 {
3611 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3612
3613 return GIMP_IMAGE_GET_PRIVATE (image)->export_dirty != 0;
3614 }
3615
3616 gint64
gimp_image_get_dirty_time(GimpImage * image)3617 gimp_image_get_dirty_time (GimpImage *image)
3618 {
3619 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3620
3621 return GIMP_IMAGE_GET_PRIVATE (image)->dirty_time;
3622 }
3623
3624 /**
3625 * gimp_image_saving:
3626 * @image:
3627 *
3628 * Emits the "saving" signal, indicating that @image is about to be saved,
3629 * or exported.
3630 */
3631 void
gimp_image_saving(GimpImage * image)3632 gimp_image_saving (GimpImage *image)
3633 {
3634 g_return_if_fail (GIMP_IS_IMAGE (image));
3635
3636 g_signal_emit (image, gimp_image_signals[SAVING], 0);
3637 }
3638
3639 /**
3640 * gimp_image_saved:
3641 * @image:
3642 * @file:
3643 *
3644 * Emits the "saved" signal, indicating that @image was saved to the
3645 * location specified by @file.
3646 */
3647 void
gimp_image_saved(GimpImage * image,GFile * file)3648 gimp_image_saved (GimpImage *image,
3649 GFile *file)
3650 {
3651 g_return_if_fail (GIMP_IS_IMAGE (image));
3652 g_return_if_fail (G_IS_FILE (file));
3653
3654 g_signal_emit (image, gimp_image_signals[SAVED], 0, file);
3655 }
3656
3657 /**
3658 * gimp_image_exported:
3659 * @image:
3660 * @file:
3661 *
3662 * Emits the "exported" signal, indicating that @image was exported to the
3663 * location specified by @file.
3664 */
3665 void
gimp_image_exported(GimpImage * image,GFile * file)3666 gimp_image_exported (GimpImage *image,
3667 GFile *file)
3668 {
3669 g_return_if_fail (GIMP_IS_IMAGE (image));
3670 g_return_if_fail (G_IS_FILE (file));
3671
3672 g_signal_emit (image, gimp_image_signals[EXPORTED], 0, file);
3673 }
3674
3675
3676 /* flush this image's displays */
3677
3678 void
gimp_image_flush(GimpImage * image)3679 gimp_image_flush (GimpImage *image)
3680 {
3681 g_return_if_fail (GIMP_IS_IMAGE (image));
3682
3683 gimp_projectable_flush (GIMP_PROJECTABLE (image),
3684 GIMP_IMAGE_GET_PRIVATE (image)->flush_accum.preview_invalidated);
3685 }
3686
3687
3688 /* display / instance counters */
3689
3690 gint
gimp_image_get_display_count(GimpImage * image)3691 gimp_image_get_display_count (GimpImage *image)
3692 {
3693 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3694
3695 return GIMP_IMAGE_GET_PRIVATE (image)->disp_count;
3696 }
3697
3698 void
gimp_image_inc_display_count(GimpImage * image)3699 gimp_image_inc_display_count (GimpImage *image)
3700 {
3701 g_return_if_fail (GIMP_IS_IMAGE (image));
3702
3703 GIMP_IMAGE_GET_PRIVATE (image)->disp_count++;
3704 }
3705
3706 void
gimp_image_dec_display_count(GimpImage * image)3707 gimp_image_dec_display_count (GimpImage *image)
3708 {
3709 g_return_if_fail (GIMP_IS_IMAGE (image));
3710
3711 GIMP_IMAGE_GET_PRIVATE (image)->disp_count--;
3712 }
3713
3714 gint
gimp_image_get_instance_count(GimpImage * image)3715 gimp_image_get_instance_count (GimpImage *image)
3716 {
3717 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3718
3719 return GIMP_IMAGE_GET_PRIVATE (image)->instance_count;
3720 }
3721
3722 void
gimp_image_inc_instance_count(GimpImage * image)3723 gimp_image_inc_instance_count (GimpImage *image)
3724 {
3725 g_return_if_fail (GIMP_IS_IMAGE (image));
3726
3727 GIMP_IMAGE_GET_PRIVATE (image)->instance_count++;
3728 }
3729
3730 void
gimp_image_inc_show_all_count(GimpImage * image)3731 gimp_image_inc_show_all_count (GimpImage *image)
3732 {
3733 g_return_if_fail (GIMP_IS_IMAGE (image));
3734
3735 GIMP_IMAGE_GET_PRIVATE (image)->show_all++;
3736
3737 if (GIMP_IMAGE_GET_PRIVATE (image)->show_all == 1)
3738 {
3739 g_clear_object (&GIMP_IMAGE_GET_PRIVATE (image)->pickable_buffer);
3740
3741 gimp_image_update_bounding_box (image);
3742 }
3743 }
3744
3745 void
gimp_image_dec_show_all_count(GimpImage * image)3746 gimp_image_dec_show_all_count (GimpImage *image)
3747 {
3748 g_return_if_fail (GIMP_IS_IMAGE (image));
3749
3750 GIMP_IMAGE_GET_PRIVATE (image)->show_all--;
3751
3752 if (GIMP_IMAGE_GET_PRIVATE (image)->show_all == 0)
3753 {
3754 g_clear_object (&GIMP_IMAGE_GET_PRIVATE (image)->pickable_buffer);
3755
3756 gimp_image_update_bounding_box (image);
3757 }
3758 }
3759
3760
3761 /* parasites */
3762
3763 const GimpParasite *
gimp_image_parasite_find(GimpImage * image,const gchar * name)3764 gimp_image_parasite_find (GimpImage *image,
3765 const gchar *name)
3766 {
3767 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
3768
3769 return gimp_parasite_list_find (GIMP_IMAGE_GET_PRIVATE (image)->parasites,
3770 name);
3771 }
3772
3773 static void
list_func(gchar * key,GimpParasite * p,gchar *** cur)3774 list_func (gchar *key,
3775 GimpParasite *p,
3776 gchar ***cur)
3777 {
3778 *(*cur)++ = (gchar *) g_strdup (key);
3779 }
3780
3781 gchar **
gimp_image_parasite_list(GimpImage * image,gint * count)3782 gimp_image_parasite_list (GimpImage *image,
3783 gint *count)
3784 {
3785 GimpImagePrivate *private;
3786 gchar **list;
3787 gchar **cur;
3788
3789 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
3790
3791 private = GIMP_IMAGE_GET_PRIVATE (image);
3792
3793 *count = gimp_parasite_list_length (private->parasites);
3794 cur = list = g_new (gchar *, *count);
3795
3796 gimp_parasite_list_foreach (private->parasites, (GHFunc) list_func, &cur);
3797
3798 return list;
3799 }
3800
3801 gboolean
gimp_image_parasite_validate(GimpImage * image,const GimpParasite * parasite,GError ** error)3802 gimp_image_parasite_validate (GimpImage *image,
3803 const GimpParasite *parasite,
3804 GError **error)
3805 {
3806 const gchar *name;
3807
3808 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3809 g_return_val_if_fail (parasite != NULL, FALSE);
3810 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
3811
3812 name = gimp_parasite_name (parasite);
3813
3814 if (strcmp (name, GIMP_ICC_PROFILE_PARASITE_NAME) == 0)
3815 {
3816 return gimp_image_validate_icc_parasite (image, parasite, NULL, error);
3817 }
3818 else if (strcmp (name, "gimp-comment") == 0)
3819 {
3820 const gchar *data = gimp_parasite_data (parasite);
3821 gssize length = gimp_parasite_data_size (parasite);
3822 gboolean valid = FALSE;
3823
3824 if (length > 0)
3825 {
3826 if (data[length - 1] == '\0')
3827 valid = g_utf8_validate (data, -1, NULL);
3828 else
3829 valid = g_utf8_validate (data, length, NULL);
3830 }
3831
3832 if (! valid)
3833 {
3834 g_set_error (error, GIMP_ERROR, GIMP_FAILED,
3835 _("'gimp-comment' parasite validation failed: "
3836 "comment contains invalid UTF-8"));
3837 return FALSE;
3838 }
3839 }
3840
3841 return TRUE;
3842 }
3843
3844 void
gimp_image_parasite_attach(GimpImage * image,const GimpParasite * parasite,gboolean push_undo)3845 gimp_image_parasite_attach (GimpImage *image,
3846 const GimpParasite *parasite,
3847 gboolean push_undo)
3848 {
3849 GimpImagePrivate *private;
3850 GimpParasite copy;
3851 const gchar *name;
3852
3853 g_return_if_fail (GIMP_IS_IMAGE (image));
3854 g_return_if_fail (parasite != NULL);
3855
3856 private = GIMP_IMAGE_GET_PRIVATE (image);
3857
3858 name = gimp_parasite_name (parasite);
3859
3860 /* this is so ugly and is only for the PDB */
3861 if (strcmp (name, GIMP_ICC_PROFILE_PARASITE_NAME) == 0)
3862 {
3863 GimpColorProfile *profile;
3864 GimpColorProfile *builtin;
3865
3866 profile =
3867 gimp_color_profile_new_from_icc_profile (gimp_parasite_data (parasite),
3868 gimp_parasite_data_size (parasite),
3869 NULL);
3870 builtin = gimp_image_get_builtin_color_profile (image);
3871
3872 if (gimp_color_profile_is_equal (profile, builtin))
3873 {
3874 /* setting the builtin profile is equal to removing the profile */
3875 gimp_image_parasite_detach (image, GIMP_ICC_PROFILE_PARASITE_NAME,
3876 push_undo);
3877 g_object_unref (profile);
3878 return;
3879 }
3880
3881 g_object_unref (profile);
3882 }
3883
3884 /* make a temporary copy of the GimpParasite struct because
3885 * gimp_parasite_shift_parent() changes it
3886 */
3887 copy = *parasite;
3888
3889 /* only set the dirty bit manually if we can be saved and the new
3890 * parasite differs from the current one and we aren't undoable
3891 */
3892 if (push_undo && gimp_parasite_is_undoable (©))
3893 gimp_image_undo_push_image_parasite (image,
3894 C_("undo-type", "Attach Parasite to Image"),
3895 ©);
3896
3897 /* We used to push a cantundo on the stack here. This made the undo stack
3898 * unusable (NULL on the stack) and prevented people from undoing after a
3899 * save (since most save plug-ins attach an undoable comment parasite).
3900 * Now we simply attach the parasite without pushing an undo. That way
3901 * it's undoable but does not block the undo system. --Sven
3902 */
3903 gimp_parasite_list_add (private->parasites, ©);
3904
3905 if (push_undo && gimp_parasite_has_flag (©, GIMP_PARASITE_ATTACH_PARENT))
3906 {
3907 gimp_parasite_shift_parent (©);
3908 gimp_parasite_attach (image->gimp, ©);
3909 }
3910
3911 if (strcmp (name, GIMP_ICC_PROFILE_PARASITE_NAME) == 0)
3912 _gimp_image_update_color_profile (image, parasite);
3913
3914 g_signal_emit (image, gimp_image_signals[PARASITE_ATTACHED], 0,
3915 name);
3916 }
3917
3918 void
gimp_image_parasite_detach(GimpImage * image,const gchar * name,gboolean push_undo)3919 gimp_image_parasite_detach (GimpImage *image,
3920 const gchar *name,
3921 gboolean push_undo)
3922 {
3923 GimpImagePrivate *private;
3924 const GimpParasite *parasite;
3925
3926 g_return_if_fail (GIMP_IS_IMAGE (image));
3927 g_return_if_fail (name != NULL);
3928
3929 private = GIMP_IMAGE_GET_PRIVATE (image);
3930
3931 if (! (parasite = gimp_parasite_list_find (private->parasites, name)))
3932 return;
3933
3934 if (push_undo && gimp_parasite_is_undoable (parasite))
3935 gimp_image_undo_push_image_parasite_remove (image,
3936 C_("undo-type", "Remove Parasite from Image"),
3937 name);
3938
3939 gimp_parasite_list_remove (private->parasites, name);
3940
3941 if (strcmp (name, GIMP_ICC_PROFILE_PARASITE_NAME) == 0)
3942 _gimp_image_update_color_profile (image, NULL);
3943
3944 g_signal_emit (image, gimp_image_signals[PARASITE_DETACHED], 0,
3945 name);
3946 }
3947
3948
3949 /* tattoos */
3950
3951 GimpTattoo
gimp_image_get_new_tattoo(GimpImage * image)3952 gimp_image_get_new_tattoo (GimpImage *image)
3953 {
3954 GimpImagePrivate *private;
3955
3956 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3957
3958 private = GIMP_IMAGE_GET_PRIVATE (image);
3959
3960 private->tattoo_state++;
3961
3962 if (G_UNLIKELY (private->tattoo_state == 0))
3963 g_warning ("%s: Tattoo state corrupted (integer overflow).", G_STRFUNC);
3964
3965 return private->tattoo_state;
3966 }
3967
3968 GimpTattoo
gimp_image_get_tattoo_state(GimpImage * image)3969 gimp_image_get_tattoo_state (GimpImage *image)
3970 {
3971 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
3972
3973 return GIMP_IMAGE_GET_PRIVATE (image)->tattoo_state;
3974 }
3975
3976 gboolean
gimp_image_set_tattoo_state(GimpImage * image,GimpTattoo val)3977 gimp_image_set_tattoo_state (GimpImage *image,
3978 GimpTattoo val)
3979 {
3980 GList *all_items;
3981 GList *list;
3982 gboolean retval = TRUE;
3983 GimpTattoo maxval = 0;
3984
3985 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
3986
3987 /* Check that the layer tattoos don't overlap with channel or vector ones */
3988 all_items = gimp_image_get_layer_list (image);
3989
3990 for (list = all_items; list; list = g_list_next (list))
3991 {
3992 GimpTattoo ltattoo;
3993
3994 ltattoo = gimp_item_get_tattoo (GIMP_ITEM (list->data));
3995 if (ltattoo > maxval)
3996 maxval = ltattoo;
3997
3998 if (gimp_image_get_channel_by_tattoo (image, ltattoo))
3999 retval = FALSE; /* Oopps duplicated tattoo in channel */
4000
4001 if (gimp_image_get_vectors_by_tattoo (image, ltattoo))
4002 retval = FALSE; /* Oopps duplicated tattoo in vectors */
4003 }
4004
4005 g_list_free (all_items);
4006
4007 /* Now check that the channel and vectors tattoos don't overlap */
4008 all_items = gimp_image_get_channel_list (image);
4009
4010 for (list = all_items; list; list = g_list_next (list))
4011 {
4012 GimpTattoo ctattoo;
4013
4014 ctattoo = gimp_item_get_tattoo (GIMP_ITEM (list->data));
4015 if (ctattoo > maxval)
4016 maxval = ctattoo;
4017
4018 if (gimp_image_get_vectors_by_tattoo (image, ctattoo))
4019 retval = FALSE; /* Oopps duplicated tattoo in vectors */
4020 }
4021
4022 g_list_free (all_items);
4023
4024 /* Find the max tattoo value in the vectors */
4025 all_items = gimp_image_get_vectors_list (image);
4026
4027 for (list = all_items; list; list = g_list_next (list))
4028 {
4029 GimpTattoo vtattoo;
4030
4031 vtattoo = gimp_item_get_tattoo (GIMP_ITEM (list->data));
4032 if (vtattoo > maxval)
4033 maxval = vtattoo;
4034 }
4035
4036 g_list_free (all_items);
4037
4038 if (val < maxval)
4039 retval = FALSE;
4040
4041 /* Must check if the state is valid */
4042 if (retval == TRUE)
4043 GIMP_IMAGE_GET_PRIVATE (image)->tattoo_state = val;
4044
4045 return retval;
4046 }
4047
4048
4049 /* projection */
4050
4051 GimpProjection *
gimp_image_get_projection(GimpImage * image)4052 gimp_image_get_projection (GimpImage *image)
4053 {
4054 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4055
4056 return GIMP_IMAGE_GET_PRIVATE (image)->projection;
4057 }
4058
4059
4060 /* layers / channels / vectors */
4061
4062 GimpItemTree *
gimp_image_get_layer_tree(GimpImage * image)4063 gimp_image_get_layer_tree (GimpImage *image)
4064 {
4065 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4066
4067 return GIMP_IMAGE_GET_PRIVATE (image)->layers;
4068 }
4069
4070 GimpItemTree *
gimp_image_get_channel_tree(GimpImage * image)4071 gimp_image_get_channel_tree (GimpImage *image)
4072 {
4073 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4074
4075 return GIMP_IMAGE_GET_PRIVATE (image)->channels;
4076 }
4077
4078 GimpItemTree *
gimp_image_get_vectors_tree(GimpImage * image)4079 gimp_image_get_vectors_tree (GimpImage *image)
4080 {
4081 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4082
4083 return GIMP_IMAGE_GET_PRIVATE (image)->vectors;
4084 }
4085
4086 GimpContainer *
gimp_image_get_layers(GimpImage * image)4087 gimp_image_get_layers (GimpImage *image)
4088 {
4089 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4090
4091 return GIMP_IMAGE_GET_PRIVATE (image)->layers->container;
4092 }
4093
4094 GimpContainer *
gimp_image_get_channels(GimpImage * image)4095 gimp_image_get_channels (GimpImage *image)
4096 {
4097 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4098
4099 return GIMP_IMAGE_GET_PRIVATE (image)->channels->container;
4100 }
4101
4102 GimpContainer *
gimp_image_get_vectors(GimpImage * image)4103 gimp_image_get_vectors (GimpImage *image)
4104 {
4105 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4106
4107 return GIMP_IMAGE_GET_PRIVATE (image)->vectors->container;
4108 }
4109
4110 gint
gimp_image_get_n_layers(GimpImage * image)4111 gimp_image_get_n_layers (GimpImage *image)
4112 {
4113 GimpItemStack *stack;
4114
4115 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
4116
4117 stack = GIMP_ITEM_STACK (gimp_image_get_layers (image));
4118
4119 return gimp_item_stack_get_n_items (stack);
4120 }
4121
4122 gint
gimp_image_get_n_channels(GimpImage * image)4123 gimp_image_get_n_channels (GimpImage *image)
4124 {
4125 GimpItemStack *stack;
4126
4127 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
4128
4129 stack = GIMP_ITEM_STACK (gimp_image_get_channels (image));
4130
4131 return gimp_item_stack_get_n_items (stack);
4132 }
4133
4134 gint
gimp_image_get_n_vectors(GimpImage * image)4135 gimp_image_get_n_vectors (GimpImage *image)
4136 {
4137 GimpItemStack *stack;
4138
4139 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
4140
4141 stack = GIMP_ITEM_STACK (gimp_image_get_vectors (image));
4142
4143 return gimp_item_stack_get_n_items (stack);
4144 }
4145
4146 GList *
gimp_image_get_layer_iter(GimpImage * image)4147 gimp_image_get_layer_iter (GimpImage *image)
4148 {
4149 GimpItemStack *stack;
4150
4151 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4152
4153 stack = GIMP_ITEM_STACK (gimp_image_get_layers (image));
4154
4155 return gimp_item_stack_get_item_iter (stack);
4156 }
4157
4158 GList *
gimp_image_get_channel_iter(GimpImage * image)4159 gimp_image_get_channel_iter (GimpImage *image)
4160 {
4161 GimpItemStack *stack;
4162
4163 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4164
4165 stack = GIMP_ITEM_STACK (gimp_image_get_channels (image));
4166
4167 return gimp_item_stack_get_item_iter (stack);
4168 }
4169
4170 GList *
gimp_image_get_vectors_iter(GimpImage * image)4171 gimp_image_get_vectors_iter (GimpImage *image)
4172 {
4173 GimpItemStack *stack;
4174
4175 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4176
4177 stack = GIMP_ITEM_STACK (gimp_image_get_vectors (image));
4178
4179 return gimp_item_stack_get_item_iter (stack);
4180 }
4181
4182 GList *
gimp_image_get_layer_list(GimpImage * image)4183 gimp_image_get_layer_list (GimpImage *image)
4184 {
4185 GimpItemStack *stack;
4186
4187 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4188
4189 stack = GIMP_ITEM_STACK (gimp_image_get_layers (image));
4190
4191 return gimp_item_stack_get_item_list (stack);
4192 }
4193
4194 GList *
gimp_image_get_channel_list(GimpImage * image)4195 gimp_image_get_channel_list (GimpImage *image)
4196 {
4197 GimpItemStack *stack;
4198
4199 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4200
4201 stack = GIMP_ITEM_STACK (gimp_image_get_channels (image));
4202
4203 return gimp_item_stack_get_item_list (stack);
4204 }
4205
4206 GList *
gimp_image_get_vectors_list(GimpImage * image)4207 gimp_image_get_vectors_list (GimpImage *image)
4208 {
4209 GimpItemStack *stack;
4210
4211 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4212
4213 stack = GIMP_ITEM_STACK (gimp_image_get_vectors (image));
4214
4215 return gimp_item_stack_get_item_list (stack);
4216 }
4217
4218
4219 /* active drawable, layer, channel, vectors */
4220
4221 GimpDrawable *
gimp_image_get_active_drawable(GimpImage * image)4222 gimp_image_get_active_drawable (GimpImage *image)
4223 {
4224 GimpImagePrivate *private;
4225 GimpItem *active_channel;
4226 GimpItem *active_layer;
4227
4228 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4229
4230 private = GIMP_IMAGE_GET_PRIVATE (image);
4231
4232 active_channel = gimp_item_tree_get_active_item (private->channels);
4233 active_layer = gimp_item_tree_get_active_item (private->layers);
4234
4235 /* If there is an active channel (a saved selection, etc.),
4236 * we ignore the active layer
4237 */
4238 if (active_channel)
4239 {
4240 return GIMP_DRAWABLE (active_channel);
4241 }
4242 else if (active_layer)
4243 {
4244 GimpLayer *layer = GIMP_LAYER (active_layer);
4245 GimpLayerMask *mask = gimp_layer_get_mask (layer);
4246
4247 if (mask && gimp_layer_get_edit_mask (layer))
4248 return GIMP_DRAWABLE (mask);
4249 else
4250 return GIMP_DRAWABLE (layer);
4251 }
4252
4253 return NULL;
4254 }
4255
4256 GimpLayer *
gimp_image_get_active_layer(GimpImage * image)4257 gimp_image_get_active_layer (GimpImage *image)
4258 {
4259 GimpImagePrivate *private;
4260
4261 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4262
4263 private = GIMP_IMAGE_GET_PRIVATE (image);
4264
4265 return GIMP_LAYER (gimp_item_tree_get_active_item (private->layers));
4266 }
4267
4268 GimpChannel *
gimp_image_get_active_channel(GimpImage * image)4269 gimp_image_get_active_channel (GimpImage *image)
4270 {
4271 GimpImagePrivate *private;
4272
4273 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4274
4275 private = GIMP_IMAGE_GET_PRIVATE (image);
4276
4277 return GIMP_CHANNEL (gimp_item_tree_get_active_item (private->channels));
4278 }
4279
4280 GimpVectors *
gimp_image_get_active_vectors(GimpImage * image)4281 gimp_image_get_active_vectors (GimpImage *image)
4282 {
4283 GimpImagePrivate *private;
4284
4285 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4286
4287 private = GIMP_IMAGE_GET_PRIVATE (image);
4288
4289 return GIMP_VECTORS (gimp_item_tree_get_active_item (private->vectors));
4290 }
4291
4292 GimpLayer *
gimp_image_set_active_layer(GimpImage * image,GimpLayer * layer)4293 gimp_image_set_active_layer (GimpImage *image,
4294 GimpLayer *layer)
4295 {
4296 GimpImagePrivate *private;
4297 GimpLayer *floating_sel;
4298 GimpLayer *active_layer;
4299
4300 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4301 g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL);
4302 g_return_val_if_fail (layer == NULL ||
4303 (gimp_item_is_attached (GIMP_ITEM (layer)) &&
4304 gimp_item_get_image (GIMP_ITEM (layer)) == image),
4305 NULL);
4306
4307 private = GIMP_IMAGE_GET_PRIVATE (image);
4308
4309 floating_sel = gimp_image_get_floating_selection (image);
4310
4311 /* Make sure the floating_sel always is the active layer */
4312 if (floating_sel && layer != floating_sel)
4313 return floating_sel;
4314
4315 active_layer = gimp_image_get_active_layer (image);
4316
4317 if (layer != active_layer)
4318 {
4319 /* Don't cache selection info for the previous active layer */
4320 if (active_layer)
4321 gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (active_layer));
4322
4323 gimp_item_tree_set_active_item (private->layers, GIMP_ITEM (layer));
4324 }
4325
4326 return gimp_image_get_active_layer (image);
4327 }
4328
4329 GimpChannel *
gimp_image_set_active_channel(GimpImage * image,GimpChannel * channel)4330 gimp_image_set_active_channel (GimpImage *image,
4331 GimpChannel *channel)
4332 {
4333 GimpImagePrivate *private;
4334
4335 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4336 g_return_val_if_fail (channel == NULL || GIMP_IS_CHANNEL (channel), NULL);
4337 g_return_val_if_fail (channel == NULL ||
4338 (gimp_item_is_attached (GIMP_ITEM (channel)) &&
4339 gimp_item_get_image (GIMP_ITEM (channel)) == image),
4340 NULL);
4341
4342 private = GIMP_IMAGE_GET_PRIVATE (image);
4343
4344 /* Not if there is a floating selection */
4345 if (channel && gimp_image_get_floating_selection (image))
4346 return NULL;
4347
4348 if (channel != gimp_image_get_active_channel (image))
4349 {
4350 gimp_item_tree_set_active_item (private->channels, GIMP_ITEM (channel));
4351 }
4352
4353 return gimp_image_get_active_channel (image);
4354 }
4355
4356 GimpChannel *
gimp_image_unset_active_channel(GimpImage * image)4357 gimp_image_unset_active_channel (GimpImage *image)
4358 {
4359 GimpImagePrivate *private;
4360 GimpChannel *channel;
4361
4362 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4363
4364 private = GIMP_IMAGE_GET_PRIVATE (image);
4365
4366 channel = gimp_image_get_active_channel (image);
4367
4368 if (channel)
4369 {
4370 gimp_image_set_active_channel (image, NULL);
4371
4372 if (private->layer_stack)
4373 gimp_image_set_active_layer (image, private->layer_stack->data);
4374 }
4375
4376 return channel;
4377 }
4378
4379 GimpVectors *
gimp_image_set_active_vectors(GimpImage * image,GimpVectors * vectors)4380 gimp_image_set_active_vectors (GimpImage *image,
4381 GimpVectors *vectors)
4382 {
4383 GimpImagePrivate *private;
4384
4385 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4386 g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), NULL);
4387 g_return_val_if_fail (vectors == NULL ||
4388 (gimp_item_is_attached (GIMP_ITEM (vectors)) &&
4389 gimp_item_get_image (GIMP_ITEM (vectors)) == image),
4390 NULL);
4391
4392 private = GIMP_IMAGE_GET_PRIVATE (image);
4393
4394 if (vectors != gimp_image_get_active_vectors (image))
4395 {
4396 gimp_item_tree_set_active_item (private->vectors, GIMP_ITEM (vectors));
4397 }
4398
4399 return gimp_image_get_active_vectors (image);
4400 }
4401
4402
4403 /* layer, channel, vectors by tattoo */
4404
4405 GimpLayer *
gimp_image_get_layer_by_tattoo(GimpImage * image,GimpTattoo tattoo)4406 gimp_image_get_layer_by_tattoo (GimpImage *image,
4407 GimpTattoo tattoo)
4408 {
4409 GimpItemStack *stack;
4410
4411 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4412
4413 stack = GIMP_ITEM_STACK (gimp_image_get_layers (image));
4414
4415 return GIMP_LAYER (gimp_item_stack_get_item_by_tattoo (stack, tattoo));
4416 }
4417
4418 GimpChannel *
gimp_image_get_channel_by_tattoo(GimpImage * image,GimpTattoo tattoo)4419 gimp_image_get_channel_by_tattoo (GimpImage *image,
4420 GimpTattoo tattoo)
4421 {
4422 GimpItemStack *stack;
4423
4424 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4425
4426 stack = GIMP_ITEM_STACK (gimp_image_get_channels (image));
4427
4428 return GIMP_CHANNEL (gimp_item_stack_get_item_by_tattoo (stack, tattoo));
4429 }
4430
4431 GimpVectors *
gimp_image_get_vectors_by_tattoo(GimpImage * image,GimpTattoo tattoo)4432 gimp_image_get_vectors_by_tattoo (GimpImage *image,
4433 GimpTattoo tattoo)
4434 {
4435 GimpItemStack *stack;
4436
4437 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4438
4439 stack = GIMP_ITEM_STACK (gimp_image_get_vectors (image));
4440
4441 return GIMP_VECTORS (gimp_item_stack_get_item_by_tattoo (stack, tattoo));
4442 }
4443
4444
4445 /* layer, channel, vectors by name */
4446
4447 GimpLayer *
gimp_image_get_layer_by_name(GimpImage * image,const gchar * name)4448 gimp_image_get_layer_by_name (GimpImage *image,
4449 const gchar *name)
4450 {
4451 GimpItemTree *tree;
4452
4453 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4454 g_return_val_if_fail (name != NULL, NULL);
4455
4456 tree = gimp_image_get_layer_tree (image);
4457
4458 return GIMP_LAYER (gimp_item_tree_get_item_by_name (tree, name));
4459 }
4460
4461 GimpChannel *
gimp_image_get_channel_by_name(GimpImage * image,const gchar * name)4462 gimp_image_get_channel_by_name (GimpImage *image,
4463 const gchar *name)
4464 {
4465 GimpItemTree *tree;
4466
4467 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4468 g_return_val_if_fail (name != NULL, NULL);
4469
4470 tree = gimp_image_get_channel_tree (image);
4471
4472 return GIMP_CHANNEL (gimp_item_tree_get_item_by_name (tree, name));
4473 }
4474
4475 GimpVectors *
gimp_image_get_vectors_by_name(GimpImage * image,const gchar * name)4476 gimp_image_get_vectors_by_name (GimpImage *image,
4477 const gchar *name)
4478 {
4479 GimpItemTree *tree;
4480
4481 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
4482 g_return_val_if_fail (name != NULL, NULL);
4483
4484 tree = gimp_image_get_vectors_tree (image);
4485
4486 return GIMP_VECTORS (gimp_item_tree_get_item_by_name (tree, name));
4487 }
4488
4489
4490 /* items */
4491
4492 gboolean
gimp_image_reorder_item(GimpImage * image,GimpItem * item,GimpItem * new_parent,gint new_index,gboolean push_undo,const gchar * undo_desc)4493 gimp_image_reorder_item (GimpImage *image,
4494 GimpItem *item,
4495 GimpItem *new_parent,
4496 gint new_index,
4497 gboolean push_undo,
4498 const gchar *undo_desc)
4499 {
4500 GimpItemTree *tree;
4501 gboolean result;
4502
4503 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4504 g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
4505 g_return_val_if_fail (gimp_item_get_image (item) == image, FALSE);
4506
4507 tree = gimp_item_get_tree (item);
4508
4509 g_return_val_if_fail (tree != NULL, FALSE);
4510
4511 if (push_undo)
4512 {
4513 if (! undo_desc)
4514 undo_desc = GIMP_ITEM_GET_CLASS (item)->reorder_desc;
4515
4516 gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ITEM_REORDER,
4517 undo_desc);
4518 }
4519
4520 gimp_image_freeze_bounding_box (image);
4521
4522 gimp_item_start_move (item, push_undo);
4523
4524 /* item and new_parent are type-checked in GimpItemTree
4525 */
4526 result = gimp_item_tree_reorder_item (tree, item,
4527 new_parent, new_index,
4528 push_undo, undo_desc);
4529
4530 gimp_item_end_move (item, push_undo);
4531
4532 gimp_image_thaw_bounding_box (image);
4533
4534 if (push_undo)
4535 gimp_image_undo_group_end (image);
4536
4537 return result;
4538 }
4539
4540 gboolean
gimp_image_raise_item(GimpImage * image,GimpItem * item,GError ** error)4541 gimp_image_raise_item (GimpImage *image,
4542 GimpItem *item,
4543 GError **error)
4544 {
4545 gint index;
4546
4547 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4548 g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
4549 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
4550
4551 index = gimp_item_get_index (item);
4552
4553 g_return_val_if_fail (index != -1, FALSE);
4554
4555 if (index == 0)
4556 {
4557 g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
4558 GIMP_ITEM_GET_CLASS (item)->raise_failed);
4559 return FALSE;
4560 }
4561
4562 return gimp_image_reorder_item (image, item,
4563 gimp_item_get_parent (item), index - 1,
4564 TRUE, GIMP_ITEM_GET_CLASS (item)->raise_desc);
4565 }
4566
4567 gboolean
gimp_image_raise_item_to_top(GimpImage * image,GimpItem * item)4568 gimp_image_raise_item_to_top (GimpImage *image,
4569 GimpItem *item)
4570 {
4571 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4572 g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
4573
4574 return gimp_image_reorder_item (image, item,
4575 gimp_item_get_parent (item), 0,
4576 TRUE, GIMP_ITEM_GET_CLASS (item)->raise_to_top_desc);
4577 }
4578
4579 gboolean
gimp_image_lower_item(GimpImage * image,GimpItem * item,GError ** error)4580 gimp_image_lower_item (GimpImage *image,
4581 GimpItem *item,
4582 GError **error)
4583 {
4584 GimpContainer *container;
4585 gint index;
4586
4587 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4588 g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
4589 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
4590
4591 container = gimp_item_get_container (item);
4592
4593 g_return_val_if_fail (container != NULL, FALSE);
4594
4595 index = gimp_item_get_index (item);
4596
4597 if (index == gimp_container_get_n_children (container) - 1)
4598 {
4599 g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
4600 GIMP_ITEM_GET_CLASS (item)->lower_failed);
4601 return FALSE;
4602 }
4603
4604 return gimp_image_reorder_item (image, item,
4605 gimp_item_get_parent (item), index + 1,
4606 TRUE, GIMP_ITEM_GET_CLASS (item)->lower_desc);
4607 }
4608
4609 gboolean
gimp_image_lower_item_to_bottom(GimpImage * image,GimpItem * item)4610 gimp_image_lower_item_to_bottom (GimpImage *image,
4611 GimpItem *item)
4612 {
4613 GimpContainer *container;
4614 gint length;
4615
4616 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4617 g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
4618
4619 container = gimp_item_get_container (item);
4620
4621 g_return_val_if_fail (container != NULL, FALSE);
4622
4623 length = gimp_container_get_n_children (container);
4624
4625 return gimp_image_reorder_item (image, item,
4626 gimp_item_get_parent (item), length - 1,
4627 TRUE, GIMP_ITEM_GET_CLASS (item)->lower_to_bottom_desc);
4628 }
4629
4630
4631 /* layers */
4632
4633 gboolean
gimp_image_add_layer(GimpImage * image,GimpLayer * layer,GimpLayer * parent,gint position,gboolean push_undo)4634 gimp_image_add_layer (GimpImage *image,
4635 GimpLayer *layer,
4636 GimpLayer *parent,
4637 gint position,
4638 gboolean push_undo)
4639 {
4640 GimpImagePrivate *private;
4641 gboolean old_has_alpha;
4642
4643 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4644
4645 private = GIMP_IMAGE_GET_PRIVATE (image);
4646
4647 /* item and parent are type-checked in GimpItemTree
4648 */
4649 if (! gimp_item_tree_get_insert_pos (private->layers,
4650 (GimpItem *) layer,
4651 (GimpItem **) &parent,
4652 &position))
4653 return FALSE;
4654
4655 gimp_image_unset_default_new_layer_mode (image);
4656
4657 /* If there is a floating selection (and this isn't it!),
4658 * make sure the insert position is greater than 0
4659 */
4660 if (parent == NULL && position == 0 &&
4661 gimp_image_get_floating_selection (image))
4662 position = 1;
4663
4664 old_has_alpha = gimp_image_has_alpha (image);
4665
4666 if (push_undo)
4667 gimp_image_undo_push_layer_add (image, C_("undo-type", "Add Layer"),
4668 layer,
4669 gimp_image_get_active_layer (image));
4670
4671 gimp_item_tree_add_item (private->layers, GIMP_ITEM (layer),
4672 GIMP_ITEM (parent), position);
4673
4674 gimp_image_set_active_layer (image, layer);
4675
4676 /* If the layer is a floating selection, attach it to the drawable */
4677 if (gimp_layer_is_floating_sel (layer))
4678 gimp_drawable_attach_floating_sel (gimp_layer_get_floating_sel_drawable (layer),
4679 layer);
4680
4681 if (old_has_alpha != gimp_image_has_alpha (image))
4682 private->flush_accum.alpha_changed = TRUE;
4683
4684 return TRUE;
4685 }
4686
4687 void
gimp_image_remove_layer(GimpImage * image,GimpLayer * layer,gboolean push_undo,GimpLayer * new_active)4688 gimp_image_remove_layer (GimpImage *image,
4689 GimpLayer *layer,
4690 gboolean push_undo,
4691 GimpLayer *new_active)
4692 {
4693 GimpImagePrivate *private;
4694 GimpLayer *active_layer;
4695 gboolean old_has_alpha;
4696 const gchar *undo_desc;
4697
4698 g_return_if_fail (GIMP_IS_IMAGE (image));
4699 g_return_if_fail (GIMP_IS_LAYER (layer));
4700 g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)));
4701 g_return_if_fail (gimp_item_get_image (GIMP_ITEM (layer)) == image);
4702
4703 private = GIMP_IMAGE_GET_PRIVATE (image);
4704
4705 gimp_image_unset_default_new_layer_mode (image);
4706
4707 if (push_undo)
4708 gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE,
4709 C_("undo-type", "Remove Layer"));
4710
4711 gimp_item_start_move (GIMP_ITEM (layer), push_undo);
4712
4713 if (gimp_drawable_get_floating_sel (GIMP_DRAWABLE (layer)))
4714 {
4715 if (! push_undo)
4716 {
4717 g_warning ("%s() was called from an undo function while the layer "
4718 "had a floating selection. Please report this at "
4719 "https://www.gimp.org/bugs/", G_STRFUNC);
4720 return;
4721 }
4722
4723 gimp_image_remove_layer (image,
4724 gimp_drawable_get_floating_sel (GIMP_DRAWABLE (layer)),
4725 TRUE, NULL);
4726 }
4727
4728 active_layer = gimp_image_get_active_layer (image);
4729
4730 old_has_alpha = gimp_image_has_alpha (image);
4731
4732 if (gimp_layer_is_floating_sel (layer))
4733 {
4734 undo_desc = C_("undo-type", "Remove Floating Selection");
4735
4736 gimp_drawable_detach_floating_sel (gimp_layer_get_floating_sel_drawable (layer));
4737 }
4738 else
4739 {
4740 undo_desc = C_("undo-type", "Remove Layer");
4741 }
4742
4743 if (push_undo)
4744 gimp_image_undo_push_layer_remove (image, undo_desc, layer,
4745 gimp_layer_get_parent (layer),
4746 gimp_item_get_index (GIMP_ITEM (layer)),
4747 active_layer);
4748
4749 g_object_ref (layer);
4750
4751 /* Make sure we're not caching any old selection info */
4752 if (layer == active_layer)
4753 gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (layer));
4754
4755 private->layer_stack = g_slist_remove (private->layer_stack, layer);
4756
4757 /* Also remove all children of a group layer from the layer_stack */
4758 if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
4759 {
4760 GimpContainer *stack = gimp_viewable_get_children (GIMP_VIEWABLE (layer));
4761 GList *children;
4762 GList *list;
4763
4764 children = gimp_item_stack_get_item_list (GIMP_ITEM_STACK (stack));
4765
4766 for (list = children; list; list = g_list_next (list))
4767 {
4768 private->layer_stack = g_slist_remove (private->layer_stack,
4769 list->data);
4770 }
4771
4772 g_list_free (children);
4773 }
4774
4775 new_active =
4776 GIMP_LAYER (gimp_item_tree_remove_item (private->layers,
4777 GIMP_ITEM (layer),
4778 GIMP_ITEM (new_active)));
4779
4780 if (gimp_layer_is_floating_sel (layer))
4781 {
4782 /* If this was the floating selection, activate the underlying drawable
4783 */
4784 floating_sel_activate_drawable (layer);
4785 }
4786 else if (active_layer &&
4787 (layer == active_layer ||
4788 gimp_viewable_is_ancestor (GIMP_VIEWABLE (layer),
4789 GIMP_VIEWABLE (active_layer))))
4790 {
4791 gimp_image_set_active_layer (image, new_active);
4792 }
4793
4794 gimp_item_end_move (GIMP_ITEM (layer), push_undo);
4795
4796 g_object_unref (layer);
4797
4798 if (old_has_alpha != gimp_image_has_alpha (image))
4799 private->flush_accum.alpha_changed = TRUE;
4800
4801 if (push_undo)
4802 gimp_image_undo_group_end (image);
4803 }
4804
4805 void
gimp_image_add_layers(GimpImage * image,GList * layers,GimpLayer * parent,gint position,gint x,gint y,gint width,gint height,const gchar * undo_desc)4806 gimp_image_add_layers (GimpImage *image,
4807 GList *layers,
4808 GimpLayer *parent,
4809 gint position,
4810 gint x,
4811 gint y,
4812 gint width,
4813 gint height,
4814 const gchar *undo_desc)
4815 {
4816 GimpImagePrivate *private;
4817 GList *list;
4818 gint layers_x = G_MAXINT;
4819 gint layers_y = G_MAXINT;
4820 gint layers_width = 0;
4821 gint layers_height = 0;
4822 gint offset_x;
4823 gint offset_y;
4824
4825 g_return_if_fail (GIMP_IS_IMAGE (image));
4826 g_return_if_fail (layers != NULL);
4827
4828 private = GIMP_IMAGE_GET_PRIVATE (image);
4829
4830 /* item and parent are type-checked in GimpItemTree
4831 */
4832 if (! gimp_item_tree_get_insert_pos (private->layers,
4833 (GimpItem *) layers->data,
4834 (GimpItem **) &parent,
4835 &position))
4836 return;
4837
4838 for (list = layers; list; list = g_list_next (list))
4839 {
4840 GimpItem *item = GIMP_ITEM (list->data);
4841 gint off_x, off_y;
4842
4843 gimp_item_get_offset (item, &off_x, &off_y);
4844
4845 layers_x = MIN (layers_x, off_x);
4846 layers_y = MIN (layers_y, off_y);
4847
4848 layers_width = MAX (layers_width,
4849 off_x + gimp_item_get_width (item) - layers_x);
4850 layers_height = MAX (layers_height,
4851 off_y + gimp_item_get_height (item) - layers_y);
4852 }
4853
4854 offset_x = x + (width - layers_width) / 2 - layers_x;
4855 offset_y = y + (height - layers_height) / 2 - layers_y;
4856
4857 gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_LAYER_ADD, undo_desc);
4858
4859 for (list = layers; list; list = g_list_next (list))
4860 {
4861 GimpItem *new_item = GIMP_ITEM (list->data);
4862
4863 gimp_item_translate (new_item, offset_x, offset_y, FALSE);
4864
4865 gimp_image_add_layer (image, GIMP_LAYER (new_item),
4866 parent, position, TRUE);
4867 position++;
4868 }
4869
4870 if (layers)
4871 gimp_image_set_active_layer (image, layers->data);
4872
4873 gimp_image_undo_group_end (image);
4874 }
4875
4876
4877 /* channels */
4878
4879 gboolean
gimp_image_add_channel(GimpImage * image,GimpChannel * channel,GimpChannel * parent,gint position,gboolean push_undo)4880 gimp_image_add_channel (GimpImage *image,
4881 GimpChannel *channel,
4882 GimpChannel *parent,
4883 gint position,
4884 gboolean push_undo)
4885 {
4886 GimpImagePrivate *private;
4887
4888 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4889
4890 private = GIMP_IMAGE_GET_PRIVATE (image);
4891
4892 /* item and parent are type-checked in GimpItemTree
4893 */
4894 if (! gimp_item_tree_get_insert_pos (private->channels,
4895 (GimpItem *) channel,
4896 (GimpItem **) &parent,
4897 &position))
4898 return FALSE;
4899
4900 if (push_undo)
4901 gimp_image_undo_push_channel_add (image, C_("undo-type", "Add Channel"),
4902 channel,
4903 gimp_image_get_active_channel (image));
4904
4905 gimp_item_tree_add_item (private->channels, GIMP_ITEM (channel),
4906 GIMP_ITEM (parent), position);
4907
4908 gimp_image_set_active_channel (image, channel);
4909
4910 return TRUE;
4911 }
4912
4913 void
gimp_image_remove_channel(GimpImage * image,GimpChannel * channel,gboolean push_undo,GimpChannel * new_active)4914 gimp_image_remove_channel (GimpImage *image,
4915 GimpChannel *channel,
4916 gboolean push_undo,
4917 GimpChannel *new_active)
4918 {
4919 GimpImagePrivate *private;
4920 GimpChannel *active_channel;
4921
4922 g_return_if_fail (GIMP_IS_IMAGE (image));
4923 g_return_if_fail (GIMP_IS_CHANNEL (channel));
4924 g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));
4925 g_return_if_fail (gimp_item_get_image (GIMP_ITEM (channel)) == image);
4926
4927 if (push_undo)
4928 gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE,
4929 C_("undo-type", "Remove Channel"));
4930
4931 gimp_item_start_move (GIMP_ITEM (channel), push_undo);
4932
4933 if (gimp_drawable_get_floating_sel (GIMP_DRAWABLE (channel)))
4934 {
4935 if (! push_undo)
4936 {
4937 g_warning ("%s() was called from an undo function while the channel "
4938 "had a floating selection. Please report this at "
4939 "https://www.gimp.org/bugs/", G_STRFUNC);
4940 return;
4941 }
4942
4943 gimp_image_remove_layer (image,
4944 gimp_drawable_get_floating_sel (GIMP_DRAWABLE (channel)),
4945 TRUE, NULL);
4946 }
4947
4948 private = GIMP_IMAGE_GET_PRIVATE (image);
4949
4950 active_channel = gimp_image_get_active_channel (image);
4951
4952 if (push_undo)
4953 gimp_image_undo_push_channel_remove (image, C_("undo-type", "Remove Channel"), channel,
4954 gimp_channel_get_parent (channel),
4955 gimp_item_get_index (GIMP_ITEM (channel)),
4956 active_channel);
4957
4958 g_object_ref (channel);
4959
4960 new_active =
4961 GIMP_CHANNEL (gimp_item_tree_remove_item (private->channels,
4962 GIMP_ITEM (channel),
4963 GIMP_ITEM (new_active)));
4964
4965 if (active_channel &&
4966 (channel == active_channel ||
4967 gimp_viewable_is_ancestor (GIMP_VIEWABLE (channel),
4968 GIMP_VIEWABLE (active_channel))))
4969 {
4970 if (new_active)
4971 gimp_image_set_active_channel (image, new_active);
4972 else
4973 gimp_image_unset_active_channel (image);
4974 }
4975
4976 gimp_item_end_move (GIMP_ITEM (channel), push_undo);
4977
4978 g_object_unref (channel);
4979
4980 if (push_undo)
4981 gimp_image_undo_group_end (image);
4982 }
4983
4984
4985 /* vectors */
4986
4987 gboolean
gimp_image_add_vectors(GimpImage * image,GimpVectors * vectors,GimpVectors * parent,gint position,gboolean push_undo)4988 gimp_image_add_vectors (GimpImage *image,
4989 GimpVectors *vectors,
4990 GimpVectors *parent,
4991 gint position,
4992 gboolean push_undo)
4993 {
4994 GimpImagePrivate *private;
4995
4996 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
4997
4998 private = GIMP_IMAGE_GET_PRIVATE (image);
4999
5000 /* item and parent are type-checked in GimpItemTree
5001 */
5002 if (! gimp_item_tree_get_insert_pos (private->vectors,
5003 (GimpItem *) vectors,
5004 (GimpItem **) &parent,
5005 &position))
5006 return FALSE;
5007
5008 if (push_undo)
5009 gimp_image_undo_push_vectors_add (image, C_("undo-type", "Add Path"),
5010 vectors,
5011 gimp_image_get_active_vectors (image));
5012
5013 gimp_item_tree_add_item (private->vectors, GIMP_ITEM (vectors),
5014 GIMP_ITEM (parent), position);
5015
5016 gimp_image_set_active_vectors (image, vectors);
5017
5018 return TRUE;
5019 }
5020
5021 void
gimp_image_remove_vectors(GimpImage * image,GimpVectors * vectors,gboolean push_undo,GimpVectors * new_active)5022 gimp_image_remove_vectors (GimpImage *image,
5023 GimpVectors *vectors,
5024 gboolean push_undo,
5025 GimpVectors *new_active)
5026 {
5027 GimpImagePrivate *private;
5028 GimpVectors *active_vectors;
5029
5030 g_return_if_fail (GIMP_IS_IMAGE (image));
5031 g_return_if_fail (GIMP_IS_VECTORS (vectors));
5032 g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (vectors)));
5033 g_return_if_fail (gimp_item_get_image (GIMP_ITEM (vectors)) == image);
5034
5035 private = GIMP_IMAGE_GET_PRIVATE (image);
5036
5037 if (push_undo)
5038 gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE,
5039 C_("undo-type", "Remove Path"));
5040
5041 gimp_item_start_move (GIMP_ITEM (vectors), push_undo);
5042
5043 active_vectors = gimp_image_get_active_vectors (image);
5044
5045 if (push_undo)
5046 gimp_image_undo_push_vectors_remove (image, C_("undo-type", "Remove Path"), vectors,
5047 gimp_vectors_get_parent (vectors),
5048 gimp_item_get_index (GIMP_ITEM (vectors)),
5049 active_vectors);
5050
5051 g_object_ref (vectors);
5052
5053 new_active =
5054 GIMP_VECTORS (gimp_item_tree_remove_item (private->vectors,
5055 GIMP_ITEM (vectors),
5056 GIMP_ITEM (new_active)));
5057
5058 if (active_vectors &&
5059 (vectors == active_vectors ||
5060 gimp_viewable_is_ancestor (GIMP_VIEWABLE (vectors),
5061 GIMP_VIEWABLE (active_vectors))))
5062 {
5063 gimp_image_set_active_vectors (image, new_active);
5064 }
5065
5066 gimp_item_end_move (GIMP_ITEM (vectors), push_undo);
5067
5068 g_object_unref (vectors);
5069
5070 if (push_undo)
5071 gimp_image_undo_group_end (image);
5072 }
5073
5074 gboolean
gimp_image_coords_in_active_pickable(GimpImage * image,const GimpCoords * coords,gboolean show_all,gboolean sample_merged,gboolean selected_only)5075 gimp_image_coords_in_active_pickable (GimpImage *image,
5076 const GimpCoords *coords,
5077 gboolean show_all,
5078 gboolean sample_merged,
5079 gboolean selected_only)
5080 {
5081 gint x, y;
5082 gboolean in_pickable = FALSE;
5083
5084 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
5085
5086 x = floor (coords->x);
5087 y = floor (coords->y);
5088
5089 if (sample_merged)
5090 {
5091 if (show_all || (x >= 0 && x < gimp_image_get_width (image) &&
5092 y >= 0 && y < gimp_image_get_height (image)))
5093 {
5094 in_pickable = TRUE;
5095 }
5096 }
5097 else
5098 {
5099 GimpDrawable *drawable = gimp_image_get_active_drawable (image);
5100
5101 if (drawable)
5102 {
5103 GimpItem *item = GIMP_ITEM (drawable);
5104 gint off_x, off_y;
5105 gint d_x, d_y;
5106
5107 gimp_item_get_offset (item, &off_x, &off_y);
5108
5109 d_x = x - off_x;
5110 d_y = y - off_y;
5111
5112 if (d_x >= 0 && d_x < gimp_item_get_width (item) &&
5113 d_y >= 0 && d_y < gimp_item_get_height (item))
5114 in_pickable = TRUE;
5115 }
5116 }
5117
5118 if (in_pickable && selected_only)
5119 {
5120 GimpChannel *selection = gimp_image_get_mask (image);
5121
5122 if (! gimp_channel_is_empty (selection) &&
5123 ! gimp_pickable_get_opacity_at (GIMP_PICKABLE (selection),
5124 x, y))
5125 {
5126 in_pickable = FALSE;
5127 }
5128 }
5129
5130 return in_pickable;
5131 }
5132
5133 void
gimp_image_invalidate_previews(GimpImage * image)5134 gimp_image_invalidate_previews (GimpImage *image)
5135 {
5136 GimpItemStack *layers;
5137 GimpItemStack *channels;
5138
5139 g_return_if_fail (GIMP_IS_IMAGE (image));
5140
5141 layers = GIMP_ITEM_STACK (gimp_image_get_layers (image));
5142 channels = GIMP_ITEM_STACK (gimp_image_get_channels (image));
5143
5144 gimp_item_stack_invalidate_previews (layers);
5145 gimp_item_stack_invalidate_previews (channels);
5146 }
5147