gimpchannel.h 11.3 KB
Newer Older
1
/* GIMP - The GNU Image Manipulation Program
Elliot Lee's avatar
Elliot Lee committed
2 3
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
4
 * This program is free software: you can redistribute it and/or modify
Elliot Lee's avatar
Elliot Lee committed
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
Elliot Lee's avatar
Elliot Lee committed
7 8 9 10 11 12 13 14
 * (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
15
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
Elliot Lee's avatar
Elliot Lee committed
16
 */
Sven Neumann's avatar
Sven Neumann committed
17

18 19
#ifndef __GIMP_CHANNEL_H__
#define __GIMP_CHANNEL_H__
Elliot Lee's avatar
Elliot Lee committed
20

21
#include "gimpdrawable.h"
Elliot Lee's avatar
Elliot Lee committed
22 23


24
#define GIMP_TYPE_CHANNEL            (gimp_channel_get_type ())
25 26 27 28
#define GIMP_CHANNEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CHANNEL, GimpChannel))
#define GIMP_CHANNEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CHANNEL, GimpChannelClass))
#define GIMP_IS_CHANNEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CHANNEL))
#define GIMP_IS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CHANNEL))
29
#define GIMP_CHANNEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CHANNEL, GimpChannelClass))
30

Michael Natterer's avatar
Michael Natterer committed
31 32 33

typedef struct _GimpChannelClass GimpChannelClass;

34 35
struct _GimpChannel
{
36
  GimpDrawable  parent_instance;
37

38
  GimpRGB       color;             /*  Also stores the opacity        */
39
  gboolean      show_masked;       /*  Show masked areas--as          */
40
                                   /*  opposed to selected areas      */
41

42 43 44 45
  GeglNode     *color_node;
  GeglNode     *invert_node;
  GeglNode     *mask_node;

46
  /*  Selection mask variables  */
47
  gboolean      boundary_known;    /*  is the current boundary valid  */
48 49
  GimpBoundSeg *segs_in;           /*  outline of selected region     */
  GimpBoundSeg *segs_out;          /*  outline of selected region     */
50 51 52 53
  gint          num_segs_in;       /*  number of lines in boundary    */
  gint          num_segs_out;      /*  number of lines in boundary    */
  gboolean      empty;             /*  is the region empty?           */
  gboolean      bounds_known;      /*  recalculate the bounds?        */
54 55
  gint          x1, y1;            /*  coordinates for bounding box   */
  gint          x2, y2;            /*  lower right hand coordinate    */
56 57 58 59
};

struct _GimpChannelClass
{
60
  GimpDrawableClass  parent_class;
61

62
  /*  signals  */
63
  void     (* color_changed) (GimpChannel             *channel);
64 65

  /*  virtual functions  */
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
  gboolean (* boundary)      (GimpChannel             *channel,
                              const GimpBoundSeg     **segs_in,
                              const GimpBoundSeg     **segs_out,
                              gint                    *num_segs_in,
                              gint                    *num_segs_out,
                              gint                     x1,
                              gint                     y1,
                              gint                     x2,
                              gint                     y2);
  gboolean (* is_empty)      (GimpChannel             *channel);

  void     (* feather)       (GimpChannel             *channel,
                              gdouble                  radius_x,
                              gdouble                  radius_y,
                              gboolean                 push_undo);
  void     (* sharpen)       (GimpChannel             *channel,
                              gboolean                 push_undo);
  void     (* clear)         (GimpChannel             *channel,
                              const gchar             *undo_desc,
                              gboolean                 push_undo);
  void     (* all)           (GimpChannel             *channel,
                              gboolean                 push_undo);
  void     (* invert)        (GimpChannel             *channel,
                              gboolean                 push_undo);
  void     (* border)        (GimpChannel             *channel,
                              gint                     radius_x,
                              gint                     radius_y,
                              GimpChannelBorderStyle   style,
                              gboolean                 edge_lock,
                              gboolean                 push_undo);
  void     (* grow)          (GimpChannel             *channel,
                              gint                     radius_x,
                              gint                     radius_y,
                              gboolean                 push_undo);
  void     (* shrink)        (GimpChannel             *channel,
                              gint                     radius_x,
                              gint                     radius_y,
                              gboolean                 edge_lock,
                              gboolean                 push_undo);
  void     (* flood)         (GimpChannel             *channel,
                              gboolean                 push_undo);
107 108 109 110 111 112 113 114 115

  const gchar *feather_desc;
  const gchar *sharpen_desc;
  const gchar *clear_desc;
  const gchar *all_desc;
  const gchar *invert_desc;
  const gchar *border_desc;
  const gchar *grow_desc;
  const gchar *shrink_desc;
116
  const gchar *flood_desc;
117
};
Elliot Lee's avatar
Elliot Lee committed
118 119


120
/*  function declarations  */
Elliot Lee's avatar
Elliot Lee committed
121

122
GType         gimp_channel_get_type           (void) G_GNUC_CONST;
123

124
GimpChannel * gimp_channel_new                (GimpImage         *image,
125 126 127 128
                                               gint               width,
                                               gint               height,
                                               const gchar       *name,
                                               const GimpRGB     *color);
129 130
GimpChannel * gimp_channel_new_from_buffer    (GimpImage         *image,
                                               GeglBuffer        *buffer,
131 132
                                               const gchar       *name,
                                               const GimpRGB     *color);
133
GimpChannel * gimp_channel_new_from_alpha     (GimpImage         *image,
134
                                               GimpDrawable      *drawable,
135 136
                                               const gchar       *name,
                                               const GimpRGB     *color);
137
GimpChannel * gimp_channel_new_from_component (GimpImage         *image,
138 139 140
                                               GimpChannelType    type,
                                               const gchar       *name,
                                               const GimpRGB     *color);
141

142 143
GimpChannel * gimp_channel_get_parent         (GimpChannel       *channel);

144
gdouble       gimp_channel_get_opacity        (GimpChannel       *channel);
145 146 147
void          gimp_channel_set_opacity        (GimpChannel       *channel,
                                               gdouble            opacity,
                                               gboolean           push_undo);
148

149
void          gimp_channel_get_color          (GimpChannel       *channel,
150 151 152 153
                                               GimpRGB           *color);
void          gimp_channel_set_color          (GimpChannel       *channel,
                                               const GimpRGB     *color,
                                               gboolean           push_undo);
154

155 156 157
gboolean      gimp_channel_get_show_masked    (GimpChannel       *channel);
void          gimp_channel_set_show_masked    (GimpChannel       *channel,
                                               gboolean           show_masked);
158

159 160 161
void          gimp_channel_push_undo          (GimpChannel       *mask,
                                               const gchar       *undo_desc);

162

Michael Natterer's avatar
Michael Natterer committed
163
/*  selection mask functions  */
Elliot Lee's avatar
Elliot Lee committed
164

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
GimpChannel * gimp_channel_new_mask           (GimpImage              *image,
                                               gint                    width,
                                               gint                    height);

gboolean      gimp_channel_boundary           (GimpChannel            *mask,
                                               const GimpBoundSeg    **segs_in,
                                               const GimpBoundSeg    **segs_out,
                                               gint                   *num_segs_in,
                                               gint                   *num_segs_out,
                                               gint                    x1,
                                               gint                    y1,
                                               gint                    x2,
                                               gint                    y2);
gboolean      gimp_channel_is_empty           (GimpChannel            *mask);

void          gimp_channel_feather            (GimpChannel            *mask,
                                               gdouble                 radius_x,
                                               gdouble                 radius_y,
                                               gboolean                push_undo);
void          gimp_channel_sharpen            (GimpChannel            *mask,
                                               gboolean                push_undo);

void          gimp_channel_clear              (GimpChannel            *mask,
                                               const gchar            *undo_desc,
                                               gboolean                push_undo);
void          gimp_channel_all                (GimpChannel            *mask,
                                               gboolean                push_undo);
void          gimp_channel_invert             (GimpChannel            *mask,
                                               gboolean                push_undo);

void          gimp_channel_border             (GimpChannel            *mask,
                                               gint                    radius_x,
                                               gint                    radius_y,
                                               GimpChannelBorderStyle  style,
                                               gboolean                edge_lock,
                                               gboolean                push_undo);
void          gimp_channel_grow               (GimpChannel            *mask,
                                               gint                    radius_x,
                                               gint                    radius_y,
                                               gboolean                push_undo);
void          gimp_channel_shrink             (GimpChannel            *mask,
                                               gint                    radius_x,
                                               gint                    radius_y,
                                               gboolean                edge_lock,
                                               gboolean                push_undo);
void          gimp_channel_flood              (GimpChannel            *mask,
                                               gboolean                push_undo);
212

213 214

#endif /* __GIMP_CHANNEL_H__ */