1 /* GIMP - The GNU Image Manipulation Program
2  * Copyright (C) 1995 Spencer Kimball and Peter Mattisbvf
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 #ifndef __GIMP_IMAGE_H__
19 #define __GIMP_IMAGE_H__
20 
21 
22 #include "gimpviewable.h"
23 
24 
25 #define GIMP_IMAGE_ACTIVE_PARENT ((gpointer) 1)
26 
27 
28 #define GIMP_TYPE_IMAGE            (gimp_image_get_type ())
29 #define GIMP_IMAGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_IMAGE, GimpImage))
30 #define GIMP_IMAGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_IMAGE, GimpImageClass))
31 #define GIMP_IS_IMAGE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_IMAGE))
32 #define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
33 #define GIMP_IMAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_IMAGE, GimpImageClass))
34 
35 
36 typedef struct _GimpImageClass   GimpImageClass;
37 typedef struct _GimpImagePrivate GimpImagePrivate;
38 
39 struct _GimpImage
40 {
41   GimpViewable      parent_instance;
42 
43   Gimp             *gimp;  /*  the GIMP the image belongs to  */
44 
45   GimpImagePrivate *priv;
46 };
47 
48 struct _GimpImageClass
49 {
50   GimpViewableClass  parent_class;
51 
52   /*  signals  */
53   void (* mode_changed)                 (GimpImage            *image);
54   void (* precision_changed)            (GimpImage            *image);
55   void (* alpha_changed)                (GimpImage            *image);
56   void (* floating_selection_changed)   (GimpImage            *image);
57   void (* active_layer_changed)         (GimpImage            *image);
58   void (* active_channel_changed)       (GimpImage            *image);
59   void (* active_vectors_changed)       (GimpImage            *image);
60   void (* linked_items_changed)         (GimpImage            *image);
61   void (* component_visibility_changed) (GimpImage            *image,
62                                          GimpChannelType       channel);
63   void (* component_active_changed)     (GimpImage            *image,
64                                          GimpChannelType       channel);
65   void (* mask_changed)                 (GimpImage            *image);
66   void (* resolution_changed)           (GimpImage            *image);
67   void (* size_changed_detailed)        (GimpImage            *image,
68                                          gint                  previous_origin_x,
69                                          gint                  previous_origin_y,
70                                          gint                  previous_width,
71                                          gint                  previous_height);
72   void (* unit_changed)                 (GimpImage            *image);
73   void (* quick_mask_changed)           (GimpImage            *image);
74   void (* selection_invalidate)         (GimpImage            *image);
75 
76   void (* clean)                        (GimpImage            *image,
77                                          GimpDirtyMask         dirty_mask);
78   void (* dirty)                        (GimpImage            *image,
79                                          GimpDirtyMask         dirty_mask);
80   void (* saving)                       (GimpImage            *image);
81   void (* saved)                        (GimpImage            *image,
82                                          GFile                *file);
83   void (* exported)                     (GimpImage            *image,
84                                          GFile                *file);
85 
86   void (* guide_added)                  (GimpImage            *image,
87                                          GimpGuide            *guide);
88   void (* guide_removed)                (GimpImage            *image,
89                                          GimpGuide            *guide);
90   void (* guide_moved)                  (GimpImage            *image,
91                                          GimpGuide            *guide);
92   void (* sample_point_added)           (GimpImage            *image,
93                                          GimpSamplePoint      *sample_point);
94   void (* sample_point_removed)         (GimpImage            *image,
95                                          GimpSamplePoint      *sample_point);
96   void (* sample_point_moved)           (GimpImage            *image,
97                                          GimpSamplePoint      *sample_point);
98   void (* parasite_attached)            (GimpImage            *image,
99                                          const gchar          *name);
100   void (* parasite_detached)            (GimpImage            *image,
101                                          const gchar          *name);
102   void (* colormap_changed)             (GimpImage            *image,
103                                          gint                  color_index);
104   void (* undo_event)                   (GimpImage            *image,
105                                          GimpUndoEvent         event,
106                                          GimpUndo             *undo);
107 };
108 
109 
110 GType           gimp_image_get_type              (void) G_GNUC_CONST;
111 
112 GimpImage     * gimp_image_new                   (Gimp               *gimp,
113                                                   gint                width,
114                                                   gint                height,
115                                                   GimpImageBaseType   base_type,
116                                                   GimpPrecision       precision);
117 
118 gint64          gimp_image_estimate_memsize      (GimpImage          *image,
119                                                   GimpComponentType   component_type,
120                                                   gint                width,
121                                                   gint                height);
122 
123 GimpImageBaseType  gimp_image_get_base_type      (GimpImage          *image);
124 GimpComponentType  gimp_image_get_component_type (GimpImage          *image);
125 GimpPrecision      gimp_image_get_precision      (GimpImage          *image);
126 
127 const Babl    * gimp_image_get_format            (GimpImage          *image,
128                                                   GimpImageBaseType   base_type,
129                                                   GimpPrecision       precision,
130                                                   gboolean            with_alpha);
131 const Babl    * gimp_image_get_layer_format      (GimpImage          *image,
132                                                   gboolean            with_alpha);
133 const Babl    * gimp_image_get_channel_format    (GimpImage          *image);
134 const Babl    * gimp_image_get_mask_format       (GimpImage          *image);
135 
136 GimpLayerMode   gimp_image_get_default_new_layer_mode
137                                                  (GimpImage          *image);
138 void            gimp_image_unset_default_new_layer_mode
139                                                  (GimpImage          *image);
140 
141 gint            gimp_image_get_ID                (GimpImage          *image);
142 GimpImage     * gimp_image_get_by_ID             (Gimp               *gimp,
143                                                   gint                id);
144 
145 GFile         * gimp_image_get_file              (GimpImage          *image);
146 GFile         * gimp_image_get_untitled_file     (GimpImage          *image);
147 GFile         * gimp_image_get_file_or_untitled  (GimpImage          *image);
148 GFile         * gimp_image_get_imported_file     (GimpImage          *image);
149 GFile         * gimp_image_get_exported_file     (GimpImage          *image);
150 GFile         * gimp_image_get_save_a_copy_file  (GimpImage          *image);
151 GFile         * gimp_image_get_any_file          (GimpImage          *image);
152 
153 void            gimp_image_set_file              (GimpImage          *image,
154                                                   GFile              *file);
155 void            gimp_image_set_imported_file     (GimpImage          *image,
156                                                   GFile              *file);
157 void            gimp_image_set_exported_file     (GimpImage          *image,
158                                                   GFile              *file);
159 void            gimp_image_set_save_a_copy_file  (GimpImage          *image,
160                                                   GFile              *file);
161 
162 const gchar   * gimp_image_get_display_name      (GimpImage          *image);
163 const gchar   * gimp_image_get_display_path      (GimpImage          *image);
164 
165 void            gimp_image_set_load_proc         (GimpImage          *image,
166                                                   GimpPlugInProcedure *proc);
167 GimpPlugInProcedure * gimp_image_get_load_proc   (GimpImage          *image);
168 void            gimp_image_set_save_proc         (GimpImage          *image,
169                                                   GimpPlugInProcedure *proc);
170 GimpPlugInProcedure * gimp_image_get_save_proc   (GimpImage          *image);
171 void            gimp_image_saving                (GimpImage          *image);
172 void            gimp_image_saved                 (GimpImage          *image,
173                                                   GFile              *file);
174 void            gimp_image_set_export_proc       (GimpImage          *image,
175                                                   GimpPlugInProcedure *proc);
176 GimpPlugInProcedure * gimp_image_get_export_proc (GimpImage          *image);
177 void            gimp_image_exported              (GimpImage          *image,
178                                                   GFile              *file);
179 
180 gint            gimp_image_get_xcf_version       (GimpImage          *image,
181                                                   gboolean            zlib_compression,
182                                                   gint               *gimp_version,
183                                                   const gchar       **version_string,
184                                                   gchar             **version_reason);
185 
186 void            gimp_image_set_xcf_compression   (GimpImage          *image,
187                                                   gboolean            compression);
188 gboolean        gimp_image_get_xcf_compression   (GimpImage          *image);
189 
190 void            gimp_image_set_resolution        (GimpImage          *image,
191                                                   gdouble             xres,
192                                                   gdouble             yres);
193 void            gimp_image_get_resolution        (GimpImage          *image,
194                                                   gdouble            *xres,
195                                                   gdouble            *yres);
196 void            gimp_image_resolution_changed    (GimpImage          *image);
197 
198 void            gimp_image_set_unit              (GimpImage          *image,
199                                                   GimpUnit            unit);
200 GimpUnit        gimp_image_get_unit              (GimpImage          *image);
201 void            gimp_image_unit_changed          (GimpImage          *image);
202 
203 gint            gimp_image_get_width             (GimpImage          *image);
204 gint            gimp_image_get_height            (GimpImage          *image);
205 
206 gboolean        gimp_image_has_alpha             (GimpImage          *image);
207 gboolean        gimp_image_is_empty              (GimpImage          *image);
208 
209 void           gimp_image_set_floating_selection (GimpImage          *image,
210                                                   GimpLayer          *floating_sel);
211 GimpLayer    * gimp_image_get_floating_selection (GimpImage          *image);
212 void       gimp_image_floating_selection_changed (GimpImage          *image);
213 
214 GimpChannel   * gimp_image_get_mask              (GimpImage          *image);
215 void            gimp_image_mask_changed          (GimpImage          *image);
216 
217 
218 /*  image components  */
219 
220 const Babl    * gimp_image_get_component_format  (GimpImage          *image,
221                                                   GimpChannelType     channel);
222 gint            gimp_image_get_component_index   (GimpImage          *image,
223                                                   GimpChannelType     channel);
224 
225 void            gimp_image_set_component_active  (GimpImage          *image,
226                                                   GimpChannelType     type,
227                                                   gboolean            active);
228 gboolean        gimp_image_get_component_active  (GimpImage          *image,
229                                                   GimpChannelType     type);
230 void            gimp_image_get_active_array      (GimpImage          *image,
231                                                   gboolean           *components);
232 GimpComponentMask gimp_image_get_active_mask     (GimpImage          *image);
233 
234 void            gimp_image_set_component_visible (GimpImage          *image,
235                                                   GimpChannelType     type,
236                                                   gboolean            visible);
237 gboolean        gimp_image_get_component_visible (GimpImage          *image,
238                                                   GimpChannelType     type);
239 void            gimp_image_get_visible_array     (GimpImage          *image,
240                                                   gboolean           *components);
241 GimpComponentMask gimp_image_get_visible_mask    (GimpImage          *image);
242 
243 
244 /*  emitting image signals  */
245 
246 void            gimp_image_mode_changed          (GimpImage          *image);
247 void            gimp_image_precision_changed     (GimpImage          *image);
248 void            gimp_image_alpha_changed         (GimpImage          *image);
249 void            gimp_image_linked_items_changed  (GimpImage          *image);
250 void            gimp_image_invalidate            (GimpImage          *image,
251                                                   gint                x,
252                                                   gint                y,
253                                                   gint                width,
254                                                   gint                height);
255 void            gimp_image_invalidate_all        (GimpImage          *image);
256 void            gimp_image_guide_added           (GimpImage          *image,
257                                                   GimpGuide          *guide);
258 void            gimp_image_guide_removed         (GimpImage          *image,
259                                                   GimpGuide          *guide);
260 void            gimp_image_guide_moved           (GimpImage          *image,
261                                                   GimpGuide          *guide);
262 
263 void            gimp_image_sample_point_added    (GimpImage          *image,
264                                                   GimpSamplePoint    *sample_point);
265 void            gimp_image_sample_point_removed  (GimpImage          *image,
266                                                   GimpSamplePoint    *sample_point);
267 void            gimp_image_sample_point_moved    (GimpImage          *image,
268                                                   GimpSamplePoint    *sample_point);
269 void            gimp_image_colormap_changed      (GimpImage          *image,
270                                                   gint                col);
271 void            gimp_image_selection_invalidate  (GimpImage          *image);
272 void            gimp_image_quick_mask_changed    (GimpImage          *image);
273 void            gimp_image_size_changed_detailed (GimpImage          *image,
274                                                   gint                previous_origin_x,
275                                                   gint                previous_origin_y,
276                                                   gint                previous_width,
277                                                   gint                previous_height);
278 void            gimp_image_undo_event            (GimpImage          *image,
279                                                   GimpUndoEvent       event,
280                                                   GimpUndo           *undo);
281 
282 
283 /*  dirty counters  */
284 
285 gint            gimp_image_dirty                 (GimpImage          *image,
286                                                   GimpDirtyMask       dirty_mask);
287 gint            gimp_image_clean                 (GimpImage          *image,
288                                                   GimpDirtyMask       dirty_mask);
289 void            gimp_image_clean_all             (GimpImage          *image);
290 void            gimp_image_export_clean_all      (GimpImage          *image);
291 gint            gimp_image_is_dirty              (GimpImage          *image);
292 gboolean        gimp_image_is_export_dirty       (GimpImage          *image);
293 gint64          gimp_image_get_dirty_time        (GimpImage          *image);
294 
295 
296 /*  flush this image's displays  */
297 
298 void            gimp_image_flush                 (GimpImage          *image);
299 
300 
301 /*  display / instance counters  */
302 
303 gint            gimp_image_get_display_count     (GimpImage          *image);
304 void            gimp_image_inc_display_count     (GimpImage          *image);
305 void            gimp_image_dec_display_count     (GimpImage          *image);
306 
307 gint            gimp_image_get_instance_count    (GimpImage          *image);
308 void            gimp_image_inc_instance_count    (GimpImage          *image);
309 
310 void            gimp_image_inc_show_all_count    (GimpImage          *image);
311 void            gimp_image_dec_show_all_count    (GimpImage          *image);
312 
313 
314 /*  parasites  */
315 
316 const GimpParasite * gimp_image_parasite_find    (GimpImage          *image,
317                                                   const gchar        *name);
318 gchar        ** gimp_image_parasite_list         (GimpImage          *image,
319                                                   gint               *count);
320 gboolean        gimp_image_parasite_validate     (GimpImage          *image,
321                                                   const GimpParasite *parasite,
322                                                   GError            **error);
323 void            gimp_image_parasite_attach       (GimpImage          *image,
324                                                   const GimpParasite *parasite,
325                                                   gboolean            push_undo);
326 void            gimp_image_parasite_detach       (GimpImage          *image,
327                                                   const gchar        *name,
328                                                   gboolean            push_undo);
329 
330 
331 /*  tattoos  */
332 
333 GimpTattoo      gimp_image_get_new_tattoo        (GimpImage          *image);
334 gboolean        gimp_image_set_tattoo_state      (GimpImage          *image,
335                                                   GimpTattoo          val);
336 GimpTattoo      gimp_image_get_tattoo_state      (GimpImage          *image);
337 
338 
339 /*  projection  */
340 
341 GimpProjection * gimp_image_get_projection       (GimpImage          *image);
342 
343 
344 /*  layers / channels / vectors  */
345 
346 GimpItemTree  * gimp_image_get_layer_tree        (GimpImage          *image);
347 GimpItemTree  * gimp_image_get_channel_tree      (GimpImage          *image);
348 GimpItemTree  * gimp_image_get_vectors_tree      (GimpImage          *image);
349 
350 GimpContainer * gimp_image_get_layers            (GimpImage          *image);
351 GimpContainer * gimp_image_get_channels          (GimpImage          *image);
352 GimpContainer * gimp_image_get_vectors           (GimpImage          *image);
353 
354 gint            gimp_image_get_n_layers          (GimpImage          *image);
355 gint            gimp_image_get_n_channels        (GimpImage          *image);
356 gint            gimp_image_get_n_vectors         (GimpImage          *image);
357 
358 GList         * gimp_image_get_layer_iter        (GimpImage          *image);
359 GList         * gimp_image_get_channel_iter      (GimpImage          *image);
360 GList         * gimp_image_get_vectors_iter      (GimpImage          *image);
361 
362 GList         * gimp_image_get_layer_list        (GimpImage          *image);
363 GList         * gimp_image_get_channel_list      (GimpImage          *image);
364 GList         * gimp_image_get_vectors_list      (GimpImage          *image);
365 
366 GimpDrawable  * gimp_image_get_active_drawable   (GimpImage          *image);
367 GimpLayer     * gimp_image_get_active_layer      (GimpImage          *image);
368 GimpChannel   * gimp_image_get_active_channel    (GimpImage          *image);
369 GimpVectors   * gimp_image_get_active_vectors    (GimpImage          *image);
370 
371 GimpLayer     * gimp_image_set_active_layer      (GimpImage          *image,
372                                                   GimpLayer          *layer);
373 GimpChannel   * gimp_image_set_active_channel    (GimpImage          *image,
374                                                   GimpChannel        *channel);
375 GimpChannel   * gimp_image_unset_active_channel  (GimpImage          *image);
376 GimpVectors   * gimp_image_set_active_vectors    (GimpImage          *image,
377                                                   GimpVectors        *vectors);
378 
379 GimpLayer     * gimp_image_get_layer_by_tattoo   (GimpImage          *image,
380                                                   GimpTattoo          tattoo);
381 GimpChannel   * gimp_image_get_channel_by_tattoo (GimpImage          *image,
382                                                   GimpTattoo          tattoo);
383 GimpVectors   * gimp_image_get_vectors_by_tattoo (GimpImage          *image,
384                                                   GimpTattoo          tattoo);
385 
386 GimpLayer     * gimp_image_get_layer_by_name     (GimpImage          *image,
387                                                   const gchar        *name);
388 GimpChannel   * gimp_image_get_channel_by_name   (GimpImage          *image,
389                                                   const gchar        *name);
390 GimpVectors   * gimp_image_get_vectors_by_name   (GimpImage          *image,
391                                                   const gchar        *name);
392 
393 gboolean        gimp_image_reorder_item          (GimpImage          *image,
394                                                   GimpItem           *item,
395                                                   GimpItem           *new_parent,
396                                                   gint                new_index,
397                                                   gboolean            push_undo,
398                                                   const gchar        *undo_desc);
399 gboolean        gimp_image_raise_item            (GimpImage          *image,
400                                                   GimpItem           *item,
401                                                   GError            **error);
402 gboolean        gimp_image_raise_item_to_top     (GimpImage          *image,
403                                                   GimpItem           *item);
404 gboolean        gimp_image_lower_item            (GimpImage          *image,
405                                                   GimpItem           *item,
406                                                   GError            **error);
407 gboolean        gimp_image_lower_item_to_bottom  (GimpImage          *image,
408                                                   GimpItem           *item);
409 
410 gboolean        gimp_image_add_layer             (GimpImage          *image,
411                                                   GimpLayer          *layer,
412                                                   GimpLayer          *parent,
413                                                   gint                position,
414                                                   gboolean            push_undo);
415 void            gimp_image_remove_layer          (GimpImage          *image,
416                                                   GimpLayer          *layer,
417                                                   gboolean            push_undo,
418                                                   GimpLayer          *new_active);
419 
420 void            gimp_image_add_layers            (GimpImage          *image,
421                                                   GList              *layers,
422                                                   GimpLayer          *parent,
423                                                   gint                position,
424                                                   gint                x,
425                                                   gint                y,
426                                                   gint                width,
427                                                   gint                height,
428                                                   const gchar        *undo_desc);
429 
430 gboolean        gimp_image_add_channel           (GimpImage          *image,
431                                                   GimpChannel        *channel,
432                                                   GimpChannel        *parent,
433                                                   gint                position,
434                                                   gboolean            push_undo);
435 void            gimp_image_remove_channel        (GimpImage          *image,
436                                                   GimpChannel        *channel,
437                                                   gboolean            push_undo,
438                                                   GimpChannel        *new_active);
439 
440 gboolean        gimp_image_add_vectors           (GimpImage          *image,
441                                                   GimpVectors        *vectors,
442                                                   GimpVectors        *parent,
443                                                   gint                position,
444                                                   gboolean            push_undo);
445 void            gimp_image_remove_vectors        (GimpImage          *image,
446                                                   GimpVectors        *vectors,
447                                                   gboolean            push_undo,
448                                                   GimpVectors        *new_active);
449 
450 gboolean    gimp_image_coords_in_active_pickable (GimpImage          *image,
451                                                   const GimpCoords   *coords,
452                                                   gboolean            show_all,
453                                                   gboolean            sample_merged,
454                                                   gboolean            selected_only);
455 
456 void            gimp_image_invalidate_previews   (GimpImage          *image);
457 
458 
459 #endif /* __GIMP_IMAGE_H__ */
460