paint-funcs

paint-funcs

Synopsis

void                paint_funcs_setup                   (void);
void                paint_funcs_free                    (void);
void                color_pixels                        (guchar *dest,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);
void                color_pixels_mask                   (guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);
void                pattern_pixels_mask                 (guchar *dest,
                                                         const guchar *mask,
                                                         TempBuf *pattern,
                                                         guint w,
                                                         guint bytes,
                                                         gint x,
                                                         gint y);
void                blend_pixels                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         guchar blend,
                                                         guint w,
                                                         guint bytes);
void                shade_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *color,
                                                         guchar rblend,
                                                         guint w,
                                                         guint bytes,
                                                         gboolean has_alpha);
void                extract_alpha_pixels                (const guchar *src,
                                                         const guchar *mask,
                                                         guchar *dest,
                                                         guint w,
                                                         guint bytes);
void                swap_pixels                         (guchar *src,
                                                         guchar *dest,
                                                         guint length);
void                scale_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         gint scale);
void                add_alpha_pixels                    (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                flatten_pixels                      (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *bg,
                                                         guint length,
                                                         guint bytes);
void                gray_to_rgb_pixels                  (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                apply_mask_to_alpha_channel         (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_mask_and_alpha_channel_stipple
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_mask_and_alpha_channel_stroke
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                copy_gray_to_inten_a_pixels         (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                copy_color                          (PixelRegion *src,
                                                         PixelRegion *dest);
void                copy_color_pixels                   (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                copy_component_pixels               (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes,
                                                         guint pixel);
void                initial_channel_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                initial_indexed_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *cmap,
                                                         guint length);
void                initial_indexed_a_pixels            (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length);
void                initial_inten_pixels                (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                initial_inten_a_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_indexed_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_indexed_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gint *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_indexed_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_and_inten_pixels      (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_and_inten_a_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_inten_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_inten_a_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_channel_mask_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_channel_selection_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                paint_funcs_color_erase_helper      (GimpRGB *src,
                                                         const GimpRGB *color);
void                extract_from_inten_pixels           (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);
void                extract_from_indexed_pixels         (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);
void                color_region                        (PixelRegion *dest,
                                                         const guchar *color);
void                color_region_mask                   (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *color);
void                pattern_region                      (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         TempBuf *pattern,
                                                         gint off_x,
                                                         gint off_y);
void                blend_region                        (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         guchar blend);
void                shade_region                        (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *color,
                                                         guchar blend);
void                copy_region                         (PixelRegion *src,
                                                         PixelRegion *dest);
void                copy_region_nocow                   (PixelRegion *src,
                                                         PixelRegion *dest);
void                clear_region                        (PixelRegion *dest);
void                add_alpha_region                    (PixelRegion *src,
                                                         PixelRegion *dest);
void                flatten_region                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *bg);
void                extract_alpha_region                (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         PixelRegion *dest);
void                extract_from_region                 (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         GimpImageBaseType type,
                                                         gboolean cut);
void                convolve_region                     (PixelRegion *srcR,
                                                         PixelRegion *destR,
                                                         const gfloat *matrix,
                                                         gint size,
                                                         gdouble divisor,
                                                         GimpConvolutionType mode,
                                                         gboolean alpha_weighting);
void                multiply_alpha_region               (PixelRegion *srcR);
void                separate_alpha_region               (PixelRegion *srcR);
void                gaussian_blur_region                (PixelRegion *srcR,
                                                         gdouble radius_x,
                                                         gdouble radius_y);
void                border_region                       (PixelRegion *src,
                                                         gint16 xradius,
                                                         gint16 yradius,
                                                         gboolean feather,
                                                         gboolean edge_lock);
gfloat              shapeburst_region                   (PixelRegion *srcPR,
                                                         PixelRegion *distPR,
                                                         GimpProgressFunc progress_callback,
                                                         gpointer progress_data);
void                thin_region                         (PixelRegion *region,
                                                         gint16 xradius,
                                                         gint16 yradius,
                                                         gboolean edge_lock);
void                fatten_region                       (PixelRegion *region,
                                                         gint16 xradius,
                                                         gint16 yradius);
void                smooth_region                       (PixelRegion *region);
void                erode_region                        (PixelRegion *region);
void                dilate_region                       (PixelRegion *region);
void                swap_region                         (PixelRegion *src,
                                                         PixelRegion *dest);
void                apply_mask_to_region                (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         guint opacity);
void                combine_mask_and_region             (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         guint opacity,
                                                         gboolean stipple);
void                copy_gray_to_region                 (PixelRegion *src,
                                                         PixelRegion *dest);
void                copy_component                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guint pixel);
void                initial_region                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         GimpLayerModeEffects mode,
                                                         const gboolean *affect,
                                                         InitialMode type);
void                combine_regions                     (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         GimpLayerModeEffects mode,
                                                         const gboolean *affect,
                                                         CombinationMode type);
void                combine_regions_replace             (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         CombinationMode type);

Description

Details

paint_funcs_setup ()

void                paint_funcs_setup                   (void);


paint_funcs_free ()

void                paint_funcs_free                    (void);


color_pixels ()

void                color_pixels                        (guchar *dest,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);


color_pixels_mask ()

void                color_pixels_mask                   (guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);


pattern_pixels_mask ()

void                pattern_pixels_mask                 (guchar *dest,
                                                         const guchar *mask,
                                                         TempBuf *pattern,
                                                         guint w,
                                                         guint bytes,
                                                         gint x,
                                                         gint y);


blend_pixels ()

void                blend_pixels                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         guchar blend,
                                                         guint w,
                                                         guint bytes);


shade_pixels ()

void                shade_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *color,
                                                         guchar rblend,
                                                         guint w,
                                                         guint bytes,
                                                         gboolean has_alpha);


extract_alpha_pixels ()

void                extract_alpha_pixels                (const guchar *src,
                                                         const guchar *mask,
                                                         guchar *dest,
                                                         guint w,
                                                         guint bytes);


swap_pixels ()

void                swap_pixels                         (guchar *src,
                                                         guchar *dest,
                                                         guint length);


scale_pixels ()

void                scale_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         gint scale);


add_alpha_pixels ()

void                add_alpha_pixels                    (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);


flatten_pixels ()

void                flatten_pixels                      (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *bg,
                                                         guint length,
                                                         guint bytes);


gray_to_rgb_pixels ()

void                gray_to_rgb_pixels                  (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);


apply_mask_to_alpha_channel ()

void                apply_mask_to_alpha_channel         (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


combine_mask_and_alpha_channel_stipple ()

void                combine_mask_and_alpha_channel_stipple
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


combine_mask_and_alpha_channel_stroke ()

void                combine_mask_and_alpha_channel_stroke
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


copy_gray_to_inten_a_pixels ()

void                copy_gray_to_inten_a_pixels         (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);


copy_color ()

void                copy_color                          (PixelRegion *src,
                                                         PixelRegion *dest);


copy_color_pixels ()

void                copy_color_pixels                   (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);


copy_component_pixels ()

void                copy_component_pixels               (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes,
                                                         guint pixel);


initial_channel_pixels ()

void                initial_channel_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);


initial_indexed_pixels ()

void                initial_indexed_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *cmap,
                                                         guint length);


initial_indexed_a_pixels ()

void                initial_indexed_a_pixels            (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length);


initial_inten_pixels ()

void                initial_inten_pixels                (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);


initial_inten_a_pixels ()

void                initial_inten_a_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);


combine_indexed_and_indexed_pixels ()

void                combine_indexed_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);


combine_indexed_and_indexed_a_pixels ()

void                combine_indexed_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gint *affect,
                                                         guint length,
                                                         guint bytes);


combine_indexed_a_and_indexed_a_pixels ()

void                combine_indexed_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);


combine_inten_a_and_indexed_pixels ()

void                combine_inten_a_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


combine_inten_a_and_indexed_a_pixels ()

void                combine_inten_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


combine_inten_and_inten_pixels ()

void                combine_inten_and_inten_pixels      (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);


combine_inten_and_inten_a_pixels ()

void                combine_inten_and_inten_a_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);


combine_inten_a_and_inten_pixels ()

void                combine_inten_a_and_inten_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);


combine_inten_a_and_inten_a_pixels ()

void                combine_inten_a_and_inten_a_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);


combine_inten_a_and_channel_mask_pixels ()

void                combine_inten_a_and_channel_mask_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


combine_inten_a_and_channel_selection_pixels ()

void                combine_inten_a_and_channel_selection_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);


paint_funcs_color_erase_helper ()

void                paint_funcs_color_erase_helper      (GimpRGB *src,
                                                         const GimpRGB *color);


extract_from_inten_pixels ()

void                extract_from_inten_pixels           (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);


extract_from_indexed_pixels ()

void                extract_from_indexed_pixels         (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);


color_region ()

void                color_region                        (PixelRegion *dest,
                                                         const guchar *color);


color_region_mask ()

void                color_region_mask                   (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *color);


pattern_region ()

void                pattern_region                      (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         TempBuf *pattern,
                                                         gint off_x,
                                                         gint off_y);


blend_region ()

void                blend_region                        (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         guchar blend);


shade_region ()

void                shade_region                        (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *color,
                                                         guchar blend);


copy_region ()

void                copy_region                         (PixelRegion *src,
                                                         PixelRegion *dest);


copy_region_nocow ()

void                copy_region_nocow                   (PixelRegion *src,
                                                         PixelRegion *dest);


clear_region ()

void                clear_region                        (PixelRegion *dest);


add_alpha_region ()

void                add_alpha_region                    (PixelRegion *src,
                                                         PixelRegion *dest);


flatten_region ()

void                flatten_region                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *bg);


extract_alpha_region ()

void                extract_alpha_region                (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         PixelRegion *dest);


extract_from_region ()

void                extract_from_region                 (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         GimpImageBaseType type,
                                                         gboolean cut);


convolve_region ()

void                convolve_region                     (PixelRegion *srcR,
                                                         PixelRegion *destR,
                                                         const gfloat *matrix,
                                                         gint size,
                                                         gdouble divisor,
                                                         GimpConvolutionType mode,
                                                         gboolean alpha_weighting);


multiply_alpha_region ()

void                multiply_alpha_region               (PixelRegion *srcR);


separate_alpha_region ()

void                separate_alpha_region               (PixelRegion *srcR);


gaussian_blur_region ()

void                gaussian_blur_region                (PixelRegion *srcR,
                                                         gdouble radius_x,
                                                         gdouble radius_y);


border_region ()

void                border_region                       (PixelRegion *src,
                                                         gint16 xradius,
                                                         gint16 yradius,
                                                         gboolean feather,
                                                         gboolean edge_lock);


shapeburst_region ()

gfloat              shapeburst_region                   (PixelRegion *srcPR,
                                                         PixelRegion *distPR,
                                                         GimpProgressFunc progress_callback,
                                                         gpointer progress_data);


thin_region ()

void                thin_region                         (PixelRegion *region,
                                                         gint16 xradius,
                                                         gint16 yradius,
                                                         gboolean edge_lock);


fatten_region ()

void                fatten_region                       (PixelRegion *region,
                                                         gint16 xradius,
                                                         gint16 yradius);


smooth_region ()

void                smooth_region                       (PixelRegion *region);


erode_region ()

void                erode_region                        (PixelRegion *region);


dilate_region ()

void                dilate_region                       (PixelRegion *region);


swap_region ()

void                swap_region                         (PixelRegion *src,
                                                         PixelRegion *dest);


apply_mask_to_region ()

void                apply_mask_to_region                (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         guint opacity);


combine_mask_and_region ()

void                combine_mask_and_region             (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         guint opacity,
                                                         gboolean stipple);


copy_gray_to_region ()

void                copy_gray_to_region                 (PixelRegion *src,
                                                         PixelRegion *dest);


copy_component ()

void                copy_component                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guint pixel);


initial_region ()

void                initial_region                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         GimpLayerModeEffects mode,
                                                         const gboolean *affect,
                                                         InitialMode type);


combine_regions ()

void                combine_regions                     (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         GimpLayerModeEffects mode,
                                                         const gboolean *affect,
                                                         CombinationMode type);


combine_regions_replace ()

void                combine_regions_replace             (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         CombinationMode type);