/* PIKA - Photo and Image Kooker Application
 * a rebranding of The GNU Image Manipulation Program (created with heckimp)
 * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
 *
 * Original copyright, applying to most contents (license remains unchanged): 
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef __PIKA_IMAGE_PRIVATE_H__
#define __PIKA_IMAGE_PRIVATE_H__


typedef struct _PikaImageFlushAccumulator PikaImageFlushAccumulator;

struct _PikaImageFlushAccumulator
{
  gboolean alpha_changed;
  gboolean mask_changed;
  gboolean floating_selection_changed;
  gboolean preview_invalidated;
};


struct _PikaImagePrivate
{
  gint               ID;                    /*  provides a unique ID         */

  PikaPlugInProcedure *load_proc;           /*  procedure used for loading   */
  PikaPlugInProcedure *save_proc;           /*  last save procedure used     */
  PikaPlugInProcedure *export_proc;         /*  last export procedure used   */

  gchar             *display_name;          /*  display basename             */
  gchar             *display_path;          /*  display full path            */
  gint               width;                 /*  width in pixels              */
  gint               height;                /*  height in pixels             */
  gdouble            xresolution;           /*  image x-res, in dpi          */
  gdouble            yresolution;           /*  image y-res, in dpi          */
  PikaUnit           resolution_unit;       /*  resolution unit              */
  gboolean           resolution_set;        /*  resolution explicitly set    */
  PikaImageBaseType  base_type;             /*  base pika_image type         */
  PikaPrecision      precision;             /*  image's precision            */
  PikaLayerMode      new_layer_mode;        /*  default mode of new layers   */

  gint               show_all;              /*  render full image content    */
  GeglRectangle      bounding_box;          /*  image content bounding box   */
  gint               bounding_box_freeze_count;
  gboolean           bounding_box_update_pending;
  GeglBuffer        *pickable_buffer;

  PikaPalette       *palette;               /*  palette of colormap          */
  const Babl        *babl_palette_rgb;      /*  palette's RGB Babl format    */
  const Babl        *babl_palette_rgba;     /*  palette's RGBA Babl format   */

  PikaColorProfile  *color_profile;         /*  image's color profile        */
  const Babl        *layer_space;           /*  image's Babl layer space     */
  PikaColorProfile  *hidden_profile;        /*  hidden by "use sRGB"         */

  /* image's simulation/soft-proofing settings */
  PikaColorProfile         *simulation_profile;
  PikaColorRenderingIntent  simulation_intent;
  gboolean                  simulation_bpc;

  gboolean           converting;            /*  color model or profile in middle of conversion?  */

  /*  Cached color transforms: from layer to sRGB u8 and double, and back    */
  gboolean            color_transforms_created;
  PikaColorTransform *transform_to_srgb_u8;
  PikaColorTransform *transform_from_srgb_u8;
  PikaColorTransform *transform_to_srgb_double;
  PikaColorTransform *transform_from_srgb_double;

  PikaMetadata      *metadata;              /*  image's metadata             */

  GFile             *file;                  /*  the image's XCF file         */
  GFile             *imported_file;         /*  the image's source file      */
  GFile             *exported_file;         /*  the image's export file      */
  GFile             *save_a_copy_file;      /*  the image's save-a-copy file */
  GFile             *untitled_file;         /*  a file saying "Untitled"     */

  gboolean           xcf_compression;       /*  XCF compression enabled?     */

  gint               dirty;                 /*  dirty flag -- # of ops       */
  gint64             dirty_time;            /*  time when image became dirty */
  gint               export_dirty;          /*  'dirty' but for export       */

  gint               undo_freeze_count;     /*  counts the _freeze's         */

  gint               instance_count;        /*  number of instances          */
  gint               disp_count;            /*  number of displays           */

  PikaTattoo         tattoo_state;          /*  the last used tattoo         */

  PikaProjection    *projection;            /*  projection layers & channels */
  GeglNode          *graph;                 /*  GEGL projection graph        */
  GeglNode          *visible_mask;          /*  component visibility node    */

  GList             *symmetries;            /*  Painting symmetries          */
  PikaSymmetry      *active_symmetry;       /*  Active symmetry              */

  GList             *guides;                /*  guides                       */
  PikaGrid          *grid;                  /*  grid                         */
  GList             *sample_points;         /*  color sample points          */

  /*  Layer/Channel attributes  */
  PikaItemTree      *layers;                /*  the tree of layers           */
  PikaItemTree      *channels;              /*  the tree of masks            */
  PikaItemTree      *vectors;               /*  the tree of vectors          */
  GSList            *layer_stack;           /*  the layers in MRU order      */

  GList             *hidden_items;          /*  internal process-only items  */

  GList             *stored_layer_sets;
  GList             *stored_channel_sets;
  GList             *stored_vectors_sets;

  GQuark             layer_offset_x_handler;
  GQuark             layer_offset_y_handler;
  GQuark             layer_bounding_box_handler;
  GQuark             layer_alpha_handler;
  GQuark             channel_name_changed_handler;
  GQuark             channel_color_changed_handler;

  PikaLayer         *floating_sel;          /*  the FS layer                 */
  PikaChannel       *selection_mask;        /*  the selection mask channel   */

  PikaParasiteList  *parasites;             /*  Plug-in parasite data        */

  gboolean           visible[MAX_CHANNELS]; /*  visible channels             */
  gboolean           active[MAX_CHANNELS];  /*  active channels              */

  gboolean           quick_mask_state;      /*  TRUE if quick mask is on       */
  gboolean           quick_mask_inverted;   /*  TRUE if quick mask is inverted */
  PikaRGB            quick_mask_color;      /*  rgba triplet of the color      */

  /*  Undo apparatus  */
  PikaUndoStack     *undo_stack;            /*  stack for undo operations    */
  PikaUndoStack     *redo_stack;            /*  stack for redo operations    */
  gint               group_count;           /*  nested undo groups           */
  PikaUndoType       pushing_undo_group;    /*  undo group status flag       */

  /*  Signal emission accumulator  */
  PikaImageFlushAccumulator  flush_accum;
};

#define PIKA_IMAGE_GET_PRIVATE(image) (((PikaImage *) (image))->priv)

void   pika_image_take_mask (PikaImage   *image,
                             PikaChannel *mask);


#endif  /* __PIKA_IMAGE_PRIVATE_H__ */
