app/core/gimpchannel.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
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
212
213
214
215
216

/* GIMP - The GNU Image Manipulation Program
 * 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 __GIMP_CHANNEL_H__
#define __GIMP_CHANNEL_H__

#include "gimpdrawable.h"


#define GIMP_TYPE_CHANNEL            (gimp_channel_get_type ())
#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))
#define GIMP_CHANNEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CHANNEL, GimpChannelClass))


typedef struct _GimpChannelClass GimpChannelClass;

struct _GimpChannel
{
  GimpDrawable  parent_instance;

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

  GeglNode     *color_node;
  GeglNode     *invert_node;
  GeglNode     *mask_node;

  /*  Selection mask variables  */
  gboolean      boundary_known;    /*  is the current boundary valid  */
  GimpBoundSeg *segs_in;           /*  outline of selected region     */
  GimpBoundSeg *segs_out;          /*  outline of selected region     */
  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?        */
  gint          x1, y1;            /*  coordinates for bounding box   */
  gint          x2, y2;            /*  lower right hand coordinate    */
};

struct _GimpChannelClass
{
  GimpDrawableClass  parent_class;

  /*  signals  */
  void     (* color_changed) (GimpChannel             *channel);

  /*  virtual functions  */
  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                 edge_lock,
                              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);

  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;
  const gchar *flood_desc;
};


/*  function declarations  */

GType         gimp_channel_get_type           (void) G_GNUC_CONST;

GimpChannel * gimp_channel_new                (GimpImage         *image,
                                               gint               width,
                                               gint               height,
                                               const gchar       *name,
                                               const GimpRGB     *color);
GimpChannel * gimp_channel_new_from_buffer    (GimpImage         *image,
                                               GeglBuffer        *buffer,
                                               const gchar       *name,
                                               const GimpRGB     *color);
GimpChannel * gimp_channel_new_from_alpha     (GimpImage         *image,
                                               GimpDrawable      *drawable,
                                               const gchar       *name,
                                               const GimpRGB     *color);
GimpChannel * gimp_channel_new_from_component (GimpImage         *image,
                                               GimpChannelType    type,
                                               const gchar       *name,
                                               const GimpRGB     *color);

GimpChannel * gimp_channel_get_parent         (GimpChannel       *channel);

gdouble       gimp_channel_get_opacity        (GimpChannel       *channel);
void          gimp_channel_set_opacity        (GimpChannel       *channel,
                                               gdouble            opacity,
                                               gboolean           push_undo);

void          gimp_channel_get_color          (GimpChannel       *channel,
                                               GimpRGB           *color);
void          gimp_channel_set_color          (GimpChannel       *channel,
                                               const GimpRGB     *color,
                                               gboolean           push_undo);

gboolean      gimp_channel_get_show_masked    (GimpChannel       *channel);
void          gimp_channel_set_show_masked    (GimpChannel       *channel,
                                               gboolean           show_masked);

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


/*  selection mask functions  */

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                edge_lock,
                                               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);


#endif /* __GIMP_CHANNEL_H__ */