graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-23 04:51:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Instead of having one GEGL operation per layer mode, make

Browse source 
GimpOperationLayerMode instantiable and add a GimpLayerModeEffects
property to it that we check in ::process() to blend pixels
together.

* app/gegl/gimpoperationlayermode.[ch]: Do the change described
above. Currently only Normal and Addition are implemented. Normal
so that we don't need a special case for the gegl:normal op. Also,
the Dissolve layer mode is not a point op and needs to be
implemented elsewhere.

* app/gegl/gimpoperation*mode.c: Removed.

* app/gegl/gimp-gegl-utils.[ch]: Removed
gimp_layer_mode_to_gegl_operation().

* app/core/gimplayer.c

* app/gegl/Makefile.am
* app/gegl/gimp-gegl.c: Adapt.

svn path=/trunk/; revision=27400
This commit is contained in:
Martin Nordholts 2008-10-25 13:29:55 +00:00
parent f0c79b81e3
commit 1a19f7315a
58 changed files with 201 additions and 3639 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
ChangeLog
View file

@ -1,3 +1,26 @@
2008-10-25 Martin Nordholts <martinn@svn.gnome.org>
Instead of having one GEGL operation per layer mode, make
GimpOperationLayerMode instantiable and add a GimpLayerModeEffects
property to it that we check in ::process() to blend pixels
together.
* app/gegl/gimpoperationlayermode.[ch]: Do the change described
above. Currently only Normal and Addition are implemented. Normal
so that we don't need a special case for the gegl:normal op. Also,
the Dissolve layer mode is not a point op and needs to be
implemented elsewhere.
* app/gegl/gimpoperation*mode.c: Removed.
* app/gegl/gimp-gegl-utils.[ch]: Removed
gimp_layer_mode_to_gegl_operation().
* app/core/gimplayer.c
* app/gegl/Makefile.am
* app/gegl/gimp-gegl.c: Adapt.
2008-10-25 Michael Natterer <mitch@gimp.org>
Merge a modified and enhanced patch from the vector layer branch:

6
app/core/gimplayer.c
View file

@ -561,7 +561,8 @@ gimp_layer_get_node (GimpDrawable *drawable)
mode_node = gimp_drawable_get_mode_node (drawable);
gegl_node_set (mode_node,
"operation", gimp_layer_mode_to_gegl_operation (layer->mode),
"operation", "gimp:layer-mode",
"blend-mode", layer->mode,
NULL);
gegl_node_connect_to (layer->opacity_node, "output",
@ -2035,7 +2036,8 @@ gimp_layer_set_mode (GimpLayer *layer,
mode_node = gimp_drawable_get_mode_node (GIMP_DRAWABLE (layer));
gegl_node_set (mode_node,
"operation", gimp_layer_mode_to_gegl_operation (layer->mode),
"operation", "gimp:layer-mode",
"blend-mode", layer->mode,
NULL);
}

52
app/gegl/Makefile.am
View file

@ -65,54 +65,4 @@ libappgegl_a_SOURCES = \
gimpoperationthreshold.h \
\
gimpoperationlayermode.c \
gimpoperationlayermode.h \
gimpoperationdissolvemode.c \
gimpoperationdissolvemode.h \
gimpoperationbehindmode.c \
gimpoperationbehindmode.h \
gimpoperationmultiplymode.c \
gimpoperationmultiplymode.h \
gimpoperationscreenmode.c \
gimpoperationscreenmode.h \
gimpoperationoverlaymode.c \
gimpoperationoverlaymode.h \
gimpoperationdifferencemode.c \
gimpoperationdifferencemode.h \
gimpoperationadditionmode.c \
gimpoperationadditionmode.h \
gimpoperationsubtractmode.c \
gimpoperationsubtractmode.h \
gimpoperationdarkenonlymode.c \
gimpoperationdarkenonlymode.h \
gimpoperationlightenonlymode.c \
gimpoperationlightenonlymode.h \
gimpoperationhuemode.c \
gimpoperationhuemode.h \
gimpoperationsaturationmode.c \
gimpoperationsaturationmode.h \
gimpoperationcolormode.c \
gimpoperationcolormode.h \
gimpoperationvaluemode.c \
gimpoperationvaluemode.h \
gimpoperationdividemode.c \
gimpoperationdividemode.h \
gimpoperationdodgemode.c \
gimpoperationdodgemode.h \
gimpoperationburnmode.c \
gimpoperationburnmode.h \
gimpoperationhardlightmode.c \
gimpoperationhardlightmode.h \
gimpoperationsoftlightmode.c \
gimpoperationsoftlightmode.h \
gimpoperationgrainextractmode.c \
gimpoperationgrainextractmode.h \
gimpoperationgrainmergemode.c \
gimpoperationgrainmergemode.h \
gimpoperationcolorerasemode.c \
gimpoperationcolorerasemode.h \
gimpoperationerasemode.c \
gimpoperationerasemode.h \
gimpoperationreplacemode.c \
gimpoperationreplacemode.h \
gimpoperationantierasemode.c \
gimpoperationantierasemode.h
gimpoperationlayermode.h

38
app/gegl/gimp-gegl-utils.c
View file

@ -75,41 +75,3 @@ gimp_bpp_to_babl_format (guint bpp,
return NULL;
}
const gchar *
gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode)
{
switch (mode)
{
case GIMP_NORMAL_MODE: return "gegl:normal";
case GIMP_DISSOLVE_MODE: return "gimp-dissolve-mode";
case GIMP_BEHIND_MODE: return "gimp-behind-mode";
case GIMP_MULTIPLY_MODE: return "gimp-multiply-mode";
case GIMP_SCREEN_MODE: return "gimp-screen-mode";
case GIMP_OVERLAY_MODE: return "gimp-overlay-mode";
case GIMP_DIFFERENCE_MODE: return "gimp-difference-mode";
case GIMP_ADDITION_MODE: return "gimp-addition-mode";
case GIMP_SUBTRACT_MODE: return "gimp-subtract-mode";
case GIMP_DARKEN_ONLY_MODE: return "gimp-darken-mode";
case GIMP_LIGHTEN_ONLY_MODE: return "gimp-lighten-mode";
case GIMP_HUE_MODE: return "gimp-hue-mode";
case GIMP_SATURATION_MODE: return "gimp-saturation-mode";
case GIMP_COLOR_MODE: return "gimp-color-mode";
case GIMP_VALUE_MODE: return "gimp-value-mode";
case GIMP_DIVIDE_MODE: return "gimp-divide-mode";
case GIMP_DODGE_MODE: return "gimp-dodge-mode";
case GIMP_BURN_MODE: return "gimp-burn-mode";
case GIMP_HARDLIGHT_MODE: return "gimp-hardlight-mode";
case GIMP_SOFTLIGHT_MODE: return "gimp-softlight-mode";
case GIMP_GRAIN_EXTRACT_MODE: return "gimp-grain-extract-mode";
case GIMP_GRAIN_MERGE_MODE: return "gimp-grain-merge-mode";
case GIMP_COLOR_ERASE_MODE: return "gimp-color-erase-mode";
case GIMP_ERASE_MODE: return "gimp-erase-mode";
case GIMP_REPLACE_MODE: return "gimp-replace-mode";
case GIMP_ANTI_ERASE_MODE: return "gimp-anti-erase-mode";
default:
break;
}
return "gegl:normal";
}

2
app/gegl/gimp-gegl-utils.h
View file

@ -26,7 +26,5 @@
const Babl * gimp_bpp_to_babl_format (guint bpp,
gboolean linear) G_GNUC_CONST;
const gchar * gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode) G_GNUC_CONST;
#endif /* __GIMP_GEGL_UTILS_H__ */

52
app/gegl/gimp-gegl.c
View file

@ -39,31 +39,7 @@
#include "gimpoperationtilesink.h"
#include "gimpoperationtilesource.h"
#include "gimpoperationdissolvemode.h"
#include "gimpoperationbehindmode.h"
#include "gimpoperationmultiplymode.h"
#include "gimpoperationscreenmode.h"
#include "gimpoperationoverlaymode.h"
#include "gimpoperationdifferencemode.h"
#include "gimpoperationadditionmode.h"
#include "gimpoperationsubtractmode.h"
#include "gimpoperationdarkenonlymode.h"
#include "gimpoperationlightenonlymode.h"
#include "gimpoperationhuemode.h"
#include "gimpoperationsaturationmode.h"
#include "gimpoperationcolormode.h"
#include "gimpoperationvaluemode.h"
#include "gimpoperationdividemode.h"
#include "gimpoperationdodgemode.h"
#include "gimpoperationburnmode.h"
#include "gimpoperationhardlightmode.h"
#include "gimpoperationsoftlightmode.h"
#include "gimpoperationgrainextractmode.h"
#include "gimpoperationgrainmergemode.h"
#include "gimpoperationcolorerasemode.h"
#include "gimpoperationerasemode.h"
#include "gimpoperationreplacemode.h"
#include "gimpoperationantierasemode.h"
#include "gimpoperationlayermode.h"
void
@ -86,29 +62,5 @@ gimp_gegl_init (void)
g_type_class_ref (GIMP_TYPE_OPERATION_POSTERIZE);
g_type_class_ref (GIMP_TYPE_OPERATION_THRESHOLD);
g_type_class_ref (GIMP_TYPE_OPERATION_DISSOLVE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_BEHIND_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_MULTIPLY_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_SCREEN_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_OVERLAY_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_DIFFERENCE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_ADDITION_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_SUBTRACT_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_HUE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_SATURATION_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_COLOR_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_VALUE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_DIVIDE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_DODGE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_BURN_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_HARDLIGHT_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_SOFTLIGHT_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_COLOR_ERASE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_ERASE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_REPLACE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_ANTI_ERASE_MODE);
g_type_class_ref (GIMP_TYPE_OPERATION_LAYER_MODE);
}

95
app/gegl/gimpoperationadditionmode.c
View file

@ -1,95 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationadditionmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationadditionmode.h"
static gboolean gimp_operation_addition_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationAdditionMode, gimp_operation_addition_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_addition_mode_class_init (GimpOperationAdditionModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-addition-mode";
operation_class->description = "GIMP addition mode operation";
mode_class->process = gimp_operation_addition_mode_process;
}
static void
gimp_operation_addition_mode_init (GimpOperationAdditionMode *self)
{
}
static gboolean
gimp_operation_addition_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
/* To be more mathematically correct we would have to either
* adjust the formula for the resulting opacity or adapt the
* other channels to the change in opacity. Compare to the
* 'plus' compositiong operation in SVG 1.2.
*
* Since this doesn't matter for completely opaque layers, and
* since consistency in how the alpha channel of layers is
* interpreted is more important than mathematically correct
* results, we don't bother.
*/
out[RED] = in[RED] + layer[RED];
out[GREEN] = in[GREEN] + layer[GREEN];
out[BLUE] = in[BLUE] + layer[BLUE];
out[ALPHA] = in[ALPHA] + layer[ALPHA] - in[ALPHA] * layer[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationadditionmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationadditionmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_ADDITION_MODE_H__
#define __GIMP_OPERATION_ADDITION_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ADDITION_MODE (gimp_operation_addition_mode_get_type ())
#define GIMP_OPERATION_ADDITION_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_ADDITION_MODE, GimpOperationAdditionMode))
#define GIMP_OPERATION_ADDITION_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_ADDITION_MODE, GimpOperationAdditionModeClass))
#define GIMP_IS_OPERATION_ADDITION_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_ADDITION_MODE))
#define GIMP_IS_OPERATION_ADDITION_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_ADDITION_MODE))
#define GIMP_OPERATION_ADDITION_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_ADDITION_MODE, GimpOperationAdditionModeClass))
typedef struct _GimpOperationAdditionModeClass GimpOperationAdditionModeClass;
struct _GimpOperationAdditionMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationAdditionModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_addition_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_ADDITION_MODE_H__ */

85
app/gegl/gimpoperationantierasemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationantierasemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationantierasemode.h"
static gboolean gimp_operation_anti_erase_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationAntiEraseMode, gimp_operation_anti_erase_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_anti_erase_mode_class_init (GimpOperationAntiEraseModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-anti-erase-mode";
operation_class->description = "GIMP anti erase mode operation";
mode_class->process = gimp_operation_anti_erase_mode_process;
}
static void
gimp_operation_anti_erase_mode_init (GimpOperationAntiEraseMode *self)
{
}
static gboolean
gimp_operation_anti_erase_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationantierasemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationanti_erasemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_ANTI_ERASE_MODE_H__
#define __GIMP_OPERATION_ANTI_ERASE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ANTI_ERASE_MODE (gimp_operation_anti_erase_mode_get_type ())
#define GIMP_OPERATION_ANTI_ERASE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_ANTI_ERASE_MODE, GimpOperationAntiEraseMode))
#define GIMP_OPERATION_ANTI_ERASE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_ANTI_ERASE_MODE, GimpOperationAntiEraseModeClass))
#define GIMP_IS_OPERATION_ANTI_ERASE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_ANTI_ERASE_MODE))
#define GIMP_IS_OPERATION_ANTI_ERASE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_ANTI_ERASE_MODE))
#define GIMP_OPERATION_ANTI_ERASE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_ANTI_ERASE_MODE, GimpOperationAntiEraseModeClass))
typedef struct _GimpOperationAntiEraseModeClass GimpOperationAntiEraseModeClass;
struct _GimpOperationAntiEraseMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationAntiEraseModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_anti_erase_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_ANTI_ERASE_MODE_H__ */

85
app/gegl/gimpoperationbehindmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationbehindmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationbehindmode.h"
static gboolean gimp_operation_behind_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationBehindMode, gimp_operation_behind_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_behind_mode_class_init (GimpOperationBehindModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-behind-mode";
operation_class->description = "GIMP behind mode operation";
mode_class->process = gimp_operation_behind_mode_process;
}
static void
gimp_operation_behind_mode_init (GimpOperationBehindMode *self)
{
}
static gboolean
gimp_operation_behind_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationbehindmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationbehindmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_BEHIND_MODE_H__
#define __GIMP_OPERATION_BEHIND_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_BEHIND_MODE (gimp_operation_behind_mode_get_type ())
#define GIMP_OPERATION_BEHIND_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_BEHIND_MODE, GimpOperationBehindMode))
#define GIMP_OPERATION_BEHIND_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_BEHIND_MODE, GimpOperationBehindModeClass))
#define GIMP_IS_OPERATION_BEHIND_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_BEHIND_MODE))
#define GIMP_IS_OPERATION_BEHIND_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_BEHIND_MODE))
#define GIMP_OPERATION_BEHIND_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_BEHIND_MODE, GimpOperationBehindModeClass))
typedef struct _GimpOperationBehindModeClass GimpOperationBehindModeClass;
struct _GimpOperationBehindMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationBehindModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_behind_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_BEHIND_MODE_H__ */

85
app/gegl/gimpoperationburnmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationburnmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationburnmode.h"
static gboolean gimp_operation_burn_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationBurnMode, gimp_operation_burn_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_burn_mode_class_init (GimpOperationBurnModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-burn-mode";
operation_class->description = "GIMP burn mode operation";
mode_class->process = gimp_operation_burn_mode_process;
}
static void
gimp_operation_burn_mode_init (GimpOperationBurnMode *self)
{
}
static gboolean
gimp_operation_burn_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationburnmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationburnmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_BURN_MODE_H__
#define __GIMP_OPERATION_BURN_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_BURN_MODE (gimp_operation_burn_mode_get_type ())
#define GIMP_OPERATION_BURN_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_BURN_MODE, GimpOperationBurnMode))
#define GIMP_OPERATION_BURN_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_BURN_MODE, GimpOperationBurnModeClass))
#define GIMP_IS_OPERATION_BURN_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_BURN_MODE))
#define GIMP_IS_OPERATION_BURN_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_BURN_MODE))
#define GIMP_OPERATION_BURN_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_BURN_MODE, GimpOperationBurnModeClass))
typedef struct _GimpOperationBurnModeClass GimpOperationBurnModeClass;
struct _GimpOperationBurnMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationBurnModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_burn_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_BURN_MODE_H__ */

85
app/gegl/gimpoperationcolorerasemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationcolorerasemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationcolorerasemode.h"
static gboolean gimp_operation_color_erase_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationColorEraseMode, gimp_operation_color_erase_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_color_erase_mode_class_init (GimpOperationColorEraseModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-color-erase-mode";
operation_class->description = "GIMP color erase mode operation";
mode_class->process = gimp_operation_color_erase_mode_process;
}
static void
gimp_operation_color_erase_mode_init (GimpOperationColorEraseMode *self)
{
}
static gboolean
gimp_operation_color_erase_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationcolorerasemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationcolor_erasemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_COLOR_ERASE_MODE_H__
#define __GIMP_OPERATION_COLOR_ERASE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_COLOR_ERASE_MODE (gimp_operation_color_erase_mode_get_type ())
#define GIMP_OPERATION_COLOR_ERASE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_COLOR_ERASE_MODE, GimpOperationColorEraseMode))
#define GIMP_OPERATION_COLOR_ERASE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_COLOR_ERASE_MODE, GimpOperationColorEraseModeClass))
#define GIMP_IS_OPERATION_COLOR_ERASE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_COLOR_ERASE_MODE))
#define GIMP_IS_OPERATION_COLOR_ERASE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_COLOR_ERASE_MODE))
#define GIMP_OPERATION_COLOR_ERASE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_COLOR_ERASE_MODE, GimpOperationColorEraseModeClass))
typedef struct _GimpOperationColorEraseModeClass GimpOperationColorEraseModeClass;
struct _GimpOperationColorEraseMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationColorEraseModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_color_erase_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_COLOR_ERASE_MODE_H__ */

85
app/gegl/gimpoperationcolormode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationcolormode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationcolormode.h"
static gboolean gimp_operation_color_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationColorMode, gimp_operation_color_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_color_mode_class_init (GimpOperationColorModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-color-mode";
operation_class->description = "GIMP color mode operation";
mode_class->process = gimp_operation_color_mode_process;
}
static void
gimp_operation_color_mode_init (GimpOperationColorMode *self)
{
}
static gboolean
gimp_operation_color_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationcolormode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationcolormode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_COLOR_MODE_H__
#define __GIMP_OPERATION_COLOR_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_COLOR_MODE (gimp_operation_color_mode_get_type ())
#define GIMP_OPERATION_COLOR_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_COLOR_MODE, GimpOperationColorMode))
#define GIMP_OPERATION_COLOR_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_COLOR_MODE, GimpOperationColorModeClass))
#define GIMP_IS_OPERATION_COLOR_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_COLOR_MODE))
#define GIMP_IS_OPERATION_COLOR_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_COLOR_MODE))
#define GIMP_OPERATION_COLOR_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_COLOR_MODE, GimpOperationColorModeClass))
typedef struct _GimpOperationColorModeClass GimpOperationColorModeClass;
struct _GimpOperationColorMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationColorModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_color_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_COLOR_MODE_H__ */

85
app/gegl/gimpoperationdarkenonlymode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdarkenonlymode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationdarkenonlymode.h"
static gboolean gimp_operation_darken_only_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationDarkenOnlyMode, gimp_operation_darken_only_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_darken_only_mode_class_init (GimpOperationDarkenOnlyModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-darken-only-mode";
operation_class->description = "GIMP darken only mode operation";
mode_class->process = gimp_operation_darken_only_mode_process;
}
static void
gimp_operation_darken_only_mode_init (GimpOperationDarkenOnlyMode *self)
{
}
static gboolean
gimp_operation_darken_only_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdarkenonlymode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdarken_onlymode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_DARKEN_ONLY_MODE_H__
#define __GIMP_OPERATION_DARKEN_ONLY_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE (gimp_operation_darken_only_mode_get_type ())
#define GIMP_OPERATION_DARKEN_ONLY_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE, GimpOperationDarkenOnlyMode))
#define GIMP_OPERATION_DARKEN_ONLY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE, GimpOperationDarkenOnlyModeClass))
#define GIMP_IS_OPERATION_DARKEN_ONLY_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE))
#define GIMP_IS_OPERATION_DARKEN_ONLY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE))
#define GIMP_OPERATION_DARKEN_ONLY_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_DARKEN_ONLY_MODE, GimpOperationDarkenOnlyModeClass))
typedef struct _GimpOperationDarkenOnlyModeClass GimpOperationDarkenOnlyModeClass;
struct _GimpOperationDarkenOnlyMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDarkenOnlyModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_darken_only_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DARKEN_ONLY_MODE_H__ */

85
app/gegl/gimpoperationdifferencemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdifferencemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationdifferencemode.h"
static gboolean gimp_operation_difference_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationDifferenceMode, gimp_operation_difference_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_difference_mode_class_init (GimpOperationDifferenceModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-difference-mode";
operation_class->description = "GIMP difference mode operation";
mode_class->process = gimp_operation_difference_mode_process;
}
static void
gimp_operation_difference_mode_init (GimpOperationDifferenceMode *self)
{
}
static gboolean
gimp_operation_difference_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdifferencemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdifferencemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_DIFFERENCE_MODE_H__
#define __GIMP_OPERATION_DIFFERENCE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DIFFERENCE_MODE (gimp_operation_difference_mode_get_type ())
#define GIMP_OPERATION_DIFFERENCE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_DIFFERENCE_MODE, GimpOperationDifferenceMode))
#define GIMP_OPERATION_DIFFERENCE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_DIFFERENCE_MODE, GimpOperationDifferenceModeClass))
#define GIMP_IS_OPERATION_DIFFERENCE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_DIFFERENCE_MODE))
#define GIMP_IS_OPERATION_DIFFERENCE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_DIFFERENCE_MODE))
#define GIMP_OPERATION_DIFFERENCE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_DIFFERENCE_MODE, GimpOperationDifferenceModeClass))
typedef struct _GimpOperationDifferenceModeClass GimpOperationDifferenceModeClass;
struct _GimpOperationDifferenceMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDifferenceModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_difference_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DIFFERENCE_MODE_H__ */

85
app/gegl/gimpoperationdissolvemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdissolvemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationdissolvemode.h"
static gboolean gimp_operation_dissolve_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationDissolveMode, gimp_operation_dissolve_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_dissolve_mode_class_init (GimpOperationDissolveModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-dissolve-mode";
operation_class->description = "GIMP dissolve mode operation";
mode_class->process = gimp_operation_dissolve_mode_process;
}
static void
gimp_operation_dissolve_mode_init (GimpOperationDissolveMode *self)
{
}
static gboolean
gimp_operation_dissolve_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdissolvemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdissolvemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_DISSOLVE_MODE_H__
#define __GIMP_OPERATION_DISSOLVE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DISSOLVE_MODE (gimp_operation_dissolve_mode_get_type ())
#define GIMP_OPERATION_DISSOLVE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_DISSOLVE_MODE, GimpOperationDissolveMode))
#define GIMP_OPERATION_DISSOLVE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_DISSOLVE_MODE, GimpOperationDissolveModeClass))
#define GIMP_IS_OPERATION_DISSOLVE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_DISSOLVE_MODE))
#define GIMP_IS_OPERATION_DISSOLVE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_DISSOLVE_MODE))
#define GIMP_OPERATION_DISSOLVE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_DISSOLVE_MODE, GimpOperationDissolveModeClass))
typedef struct _GimpOperationDissolveModeClass GimpOperationDissolveModeClass;
struct _GimpOperationDissolveMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDissolveModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_dissolve_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DISSOLVE_MODE_H__ */

85
app/gegl/gimpoperationdividemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdividemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationdividemode.h"
static gboolean gimp_operation_divide_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationDivideMode, gimp_operation_divide_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_divide_mode_class_init (GimpOperationDivideModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-divide-mode";
operation_class->description = "GIMP divide mode operation";
mode_class->process = gimp_operation_divide_mode_process;
}
static void
gimp_operation_divide_mode_init (GimpOperationDivideMode *self)
{
}
static gboolean
gimp_operation_divide_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdividemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdividemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_DIVIDE_MODE_H__
#define __GIMP_OPERATION_DIVIDE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DIVIDE_MODE (gimp_operation_divide_mode_get_type ())
#define GIMP_OPERATION_DIVIDE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_DIVIDE_MODE, GimpOperationDivideMode))
#define GIMP_OPERATION_DIVIDE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_DIVIDE_MODE, GimpOperationDivideModeClass))
#define GIMP_IS_OPERATION_DIVIDE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_DIVIDE_MODE))
#define GIMP_IS_OPERATION_DIVIDE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_DIVIDE_MODE))
#define GIMP_OPERATION_DIVIDE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_DIVIDE_MODE, GimpOperationDivideModeClass))
typedef struct _GimpOperationDivideModeClass GimpOperationDivideModeClass;
struct _GimpOperationDivideMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDivideModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_divide_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DIVIDE_MODE_H__ */

85
app/gegl/gimpoperationdodgemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdodgemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationdodgemode.h"
static gboolean gimp_operation_dodge_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationDodgeMode, gimp_operation_dodge_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_dodge_mode_class_init (GimpOperationDodgeModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-dodge-mode";
operation_class->description = "GIMP dodge mode operation";
mode_class->process = gimp_operation_dodge_mode_process;
}
static void
gimp_operation_dodge_mode_init (GimpOperationDodgeMode *self)
{
}
static gboolean
gimp_operation_dodge_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdodgemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationdodgemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_DODGE_MODE_H__
#define __GIMP_OPERATION_DODGE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DODGE_MODE (gimp_operation_dodge_mode_get_type ())
#define GIMP_OPERATION_DODGE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_DODGE_MODE, GimpOperationDodgeMode))
#define GIMP_OPERATION_DODGE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_DODGE_MODE, GimpOperationDodgeModeClass))
#define GIMP_IS_OPERATION_DODGE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_DODGE_MODE))
#define GIMP_IS_OPERATION_DODGE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_DODGE_MODE))
#define GIMP_OPERATION_DODGE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_DODGE_MODE, GimpOperationDodgeModeClass))
typedef struct _GimpOperationDodgeModeClass GimpOperationDodgeModeClass;
struct _GimpOperationDodgeMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDodgeModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_dodge_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DODGE_MODE_H__ */

85
app/gegl/gimpoperationerasemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationerasemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationerasemode.h"
static gboolean gimp_operation_erase_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationEraseMode, gimp_operation_erase_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_erase_mode_class_init (GimpOperationEraseModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-erase-mode";
operation_class->description = "GIMP erase mode operation";
mode_class->process = gimp_operation_erase_mode_process;
}
static void
gimp_operation_erase_mode_init (GimpOperationEraseMode *self)
{
}
static gboolean
gimp_operation_erase_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationerasemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationerasemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_ERASE_MODE_H__
#define __GIMP_OPERATION_ERASE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ERASE_MODE (gimp_operation_erase_mode_get_type ())
#define GIMP_OPERATION_ERASE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_ERASE_MODE, GimpOperationEraseMode))
#define GIMP_OPERATION_ERASE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_ERASE_MODE, GimpOperationEraseModeClass))
#define GIMP_IS_OPERATION_ERASE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_ERASE_MODE))
#define GIMP_IS_OPERATION_ERASE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_ERASE_MODE))
#define GIMP_OPERATION_ERASE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_ERASE_MODE, GimpOperationEraseModeClass))
typedef struct _GimpOperationEraseModeClass GimpOperationEraseModeClass;
struct _GimpOperationEraseMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationEraseModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_erase_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_ERASE_MODE_H__ */

85
app/gegl/gimpoperationgrainextractmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationgrainextractmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationgrainextractmode.h"
static gboolean gimp_operation_grain_extract_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationGrainExtractMode, gimp_operation_grain_extract_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_grain_extract_mode_class_init (GimpOperationGrainExtractModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-grain-extract-mode";
operation_class->description = "GIMP grain extract mode operation";
mode_class->process = gimp_operation_grain_extract_mode_process;
}
static void
gimp_operation_grain_extract_mode_init (GimpOperationGrainExtractMode *self)
{
}
static gboolean
gimp_operation_grain_extract_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationgrainextractmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationgrain_extractmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_GRAIN_EXTRACT_MODE_H__
#define __GIMP_OPERATION_GRAIN_EXTRACT_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE (gimp_operation_grain_extract_mode_get_type ())
#define GIMP_OPERATION_GRAIN_EXTRACT_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE, GimpOperationGrainExtractMode))
#define GIMP_OPERATION_GRAIN_EXTRACT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE, GimpOperationGrainExtractModeClass))
#define GIMP_IS_OPERATION_GRAIN_EXTRACT_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE))
#define GIMP_IS_OPERATION_GRAIN_EXTRACT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE))
#define GIMP_OPERATION_GRAIN_EXTRACT_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_GRAIN_EXTRACT_MODE, GimpOperationGrainExtractModeClass))
typedef struct _GimpOperationGrainExtractModeClass GimpOperationGrainExtractModeClass;
struct _GimpOperationGrainExtractMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationGrainExtractModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_grain_extract_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_GRAIN_EXTRACT_MODE_H__ */

85
app/gegl/gimpoperationgrainmergemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationgrainmergemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationgrainmergemode.h"
static gboolean gimp_operation_grain_merge_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationGrainMergeMode, gimp_operation_grain_merge_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_grain_merge_mode_class_init (GimpOperationGrainMergeModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-grain-merge-mode";
operation_class->description = "GIMP grain merge mode operation";
mode_class->process = gimp_operation_grain_merge_mode_process;
}
static void
gimp_operation_grain_merge_mode_init (GimpOperationGrainMergeMode *self)
{
}
static gboolean
gimp_operation_grain_merge_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationgrainmergemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationgrain_mergemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_GRAIN_MERGE_MODE_H__
#define __GIMP_OPERATION_GRAIN_MERGE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE (gimp_operation_grain_merge_mode_get_type ())
#define GIMP_OPERATION_GRAIN_MERGE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE, GimpOperationGrainMergeMode))
#define GIMP_OPERATION_GRAIN_MERGE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE, GimpOperationGrainMergeModeClass))
#define GIMP_IS_OPERATION_GRAIN_MERGE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE))
#define GIMP_IS_OPERATION_GRAIN_MERGE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE))
#define GIMP_OPERATION_GRAIN_MERGE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_GRAIN_MERGE_MODE, GimpOperationGrainMergeModeClass))
typedef struct _GimpOperationGrainMergeModeClass GimpOperationGrainMergeModeClass;
struct _GimpOperationGrainMergeMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationGrainMergeModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_grain_merge_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_GRAIN_MERGE_MODE_H__ */

85
app/gegl/gimpoperationhardlightmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationhardlightmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationhardlightmode.h"
static gboolean gimp_operation_hardlight_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationHardlightMode, gimp_operation_hardlight_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_hardlight_mode_class_init (GimpOperationHardlightModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-hardlight-mode";
operation_class->description = "GIMP hardlight mode operation";
mode_class->process = gimp_operation_hardlight_mode_process;
}
static void
gimp_operation_hardlight_mode_init (GimpOperationHardlightMode *self)
{
}
static gboolean
gimp_operation_hardlight_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationhardlightmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationhardlightmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_HARDLIGHT_MODE_H__
#define __GIMP_OPERATION_HARDLIGHT_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HARDLIGHT_MODE (gimp_operation_hardlight_mode_get_type ())
#define GIMP_OPERATION_HARDLIGHT_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_HARDLIGHT_MODE, GimpOperationHardlightMode))
#define GIMP_OPERATION_HARDLIGHT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_HARDLIGHT_MODE, GimpOperationHardlightModeClass))
#define GIMP_IS_OPERATION_HARDLIGHT_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_HARDLIGHT_MODE))
#define GIMP_IS_OPERATION_HARDLIGHT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_HARDLIGHT_MODE))
#define GIMP_OPERATION_HARDLIGHT_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_HARDLIGHT_MODE, GimpOperationHardlightModeClass))
typedef struct _GimpOperationHardlightModeClass GimpOperationHardlightModeClass;
struct _GimpOperationHardlightMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHardlightModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_hardlight_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_HARDLIGHT_MODE_H__ */

85
app/gegl/gimpoperationhuemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationhuemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationhuemode.h"
static gboolean gimp_operation_hue_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationHueMode, gimp_operation_hue_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_hue_mode_class_init (GimpOperationHueModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-hue-mode";
operation_class->description = "GIMP hue mode operation";
mode_class->process = gimp_operation_hue_mode_process;
}
static void
gimp_operation_hue_mode_init (GimpOperationHueMode *self)
{
}
static gboolean
gimp_operation_hue_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationhuemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationhuemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_HUE_MODE_H__
#define __GIMP_OPERATION_HUE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HUE_MODE (gimp_operation_hue_mode_get_type ())
#define GIMP_OPERATION_HUE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_HUE_MODE, GimpOperationHueMode))
#define GIMP_OPERATION_HUE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_HUE_MODE, GimpOperationHueModeClass))
#define GIMP_IS_OPERATION_HUE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_HUE_MODE))
#define GIMP_IS_OPERATION_HUE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_HUE_MODE))
#define GIMP_OPERATION_HUE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_HUE_MODE, GimpOperationHueModeClass))
typedef struct _GimpOperationHueModeClass GimpOperationHueModeClass;
struct _GimpOperationHueMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHueModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_hue_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_HUE_MODE_H__ */

169
app/gegl/gimpoperationlayermode.c
View file

@ -29,6 +29,37 @@
#include "gimpoperationlayermode.h"
enum
{
PROP_0,
PROP_BLEND_MODE
};
typedef struct _GimpOperationLayerModeClass GimpOperationLayerModeClass;
struct _GimpOperationLayerModeClass
{
GeglOperationPointComposerClass parent_class;
};
struct _GimpOperationLayerMode
{
GeglOperationPointComposer parent_instance;
GimpLayerModeEffects blend_mode;
};
static void gimp_operation_layer_mode_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_operation_layer_mode_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_operation_layer_mode_prepare (GeglOperation *operation);
static gboolean gimp_operation_layer_mode_process (GeglOperation *operation,
void *in_buf,
@ -38,21 +69,33 @@ static gboolean gimp_operation_layer_mode_process (GeglOperation *operatio
const GeglRectangle *roi);
G_DEFINE_ABSTRACT_TYPE (GimpOperationLayerMode, gimp_operation_layer_mode,
G_DEFINE_TYPE (GimpOperationLayerMode, gimp_operation_layer_mode,
GEGL_TYPE_OPERATION_POINT_COMPOSER)
static void
gimp_operation_layer_mode_class_init (GimpOperationLayerModeClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
object_class->set_property = gimp_operation_layer_mode_set_property;
object_class->get_property = gimp_operation_layer_mode_get_property;
operation_class->name = "gimp:layer-mode";
operation_class->description = "GIMP layer mode operation";
operation_class->categories = "compositors";
operation_class->prepare = gimp_operation_layer_mode_prepare;
point_class->process = gimp_operation_layer_mode_process;
g_object_class_install_property (object_class, PROP_BLEND_MODE,
g_param_spec_enum ("blend-mode", NULL, NULL,
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_PARAM_READWRITE));
}
static void
@ -60,6 +103,46 @@ gimp_operation_layer_mode_init (GimpOperationLayerMode *self)
{
}
static void
gimp_operation_layer_mode_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpOperationLayerMode *self = GIMP_OPERATION_LAYER_MODE (object);
switch (property_id)
{
case PROP_BLEND_MODE:
self->blend_mode = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_operation_layer_mode_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpOperationLayerMode *self = GIMP_OPERATION_LAYER_MODE (object);
switch (property_id)
{
case PROP_BLEND_MODE:
g_value_set_enum (value, self->blend_mode);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_operation_layer_mode_prepare (GeglOperation *operation)
{
@ -78,10 +161,82 @@ gimp_operation_layer_mode_process (GeglOperation *operation,
glong samples,
const GeglRectangle *roi)
{
return GIMP_OPERATION_LAYER_MODE_GET_CLASS (operation)->process (operation,
in_buf,
aux_buf,
out_buf,
samples,
roi);
GimpOperationLayerMode *self = GIMP_OPERATION_LAYER_MODE (operation);
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[ALPHA] = in[ALPHA] + layer[ALPHA] - in[ALPHA] * layer[ALPHA];
switch (self->blend_mode)
{
case GIMP_NORMAL_MODE:
out[RED] = layer[RED] + in[RED] * (1 - layer[ALPHA]);
out[GREEN] = layer[GREEN] + in[GREEN] * (1 - layer[ALPHA]);
out[BLUE] = layer[BLUE] + in[BLUE] * (1 - layer[ALPHA]);
break;
case GIMP_DISSOLVE_MODE:
g_warning ("Not a point filter and cannot be implemented here.");
break;
case GIMP_BEHIND_MODE:
case GIMP_MULTIPLY_MODE:
case GIMP_SCREEN_MODE:
case GIMP_OVERLAY_MODE:
case GIMP_DIFFERENCE_MODE:
/* TODO */
break;
case GIMP_ADDITION_MODE:
/* To be more mathematically correct we would have to either
* adjust the formula for the resulting opacity or adapt the
* other channels to the change in opacity. Compare to the
* 'plus' compositing operation in SVG 1.2.
*
* Since this doesn't matter for completely opaque layers, and
* since consistency in how the alpha channel of layers is
* interpreted is more important than mathematically correct
* results, we don't bother.
*/
out[RED] = in[RED] + layer[RED];
out[GREEN] = in[GREEN] + layer[GREEN];
out[BLUE] = in[BLUE] + layer[BLUE];
break;
case GIMP_SUBTRACT_MODE:
case GIMP_DARKEN_ONLY_MODE:
case GIMP_LIGHTEN_ONLY_MODE:
case GIMP_HUE_MODE:
case GIMP_SATURATION_MODE:
case GIMP_COLOR_MODE:
case GIMP_VALUE_MODE:
case GIMP_DIVIDE_MODE:
case GIMP_DODGE_MODE:
case GIMP_BURN_MODE:
case GIMP_HARDLIGHT_MODE:
case GIMP_SOFTLIGHT_MODE:
case GIMP_GRAIN_EXTRACT_MODE:
case GIMP_GRAIN_MERGE_MODE:
case GIMP_COLOR_ERASE_MODE:
case GIMP_ERASE_MODE:
case GIMP_REPLACE_MODE:
case GIMP_ANTI_ERASE_MODE:
/* TODO */
break;
default:
g_error ("Unknown layer mode");
break;
}
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

20
app/gegl/gimpoperationlayermode.h
View file

@ -35,26 +35,6 @@
#define GIMP_OPERATION_LAYER_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_LAYER_MODE, GimpOperationLayerModeClass))
typedef struct _GimpOperationLayerModeClass GimpOperationLayerModeClass;
struct _GimpOperationLayerMode
{
GeglOperationPointComposer parent_instance;
};
struct _GimpOperationLayerModeClass
{
GeglOperationPointComposerClass parent_class;
gboolean (* process) (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
};
GType gimp_operation_layer_mode_get_type (void) G_GNUC_CONST;

85
app/gegl/gimpoperationlightenonlymode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationlightenonlymode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationlightenonlymode.h"
static gboolean gimp_operation_lighten_only_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationLightenOnlyMode, gimp_operation_lighten_only_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_lighten_only_mode_class_init (GimpOperationLightenOnlyModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-lighten-only-mode";
operation_class->description = "GIMP lighten only mode operation";
mode_class->process = gimp_operation_lighten_only_mode_process;
}
static void
gimp_operation_lighten_only_mode_init (GimpOperationLightenOnlyMode *self)
{
}
static gboolean
gimp_operation_lighten_only_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationlightenonlymode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationlighten_onlymode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_LIGHTEN_ONLY_MODE_H__
#define __GIMP_OPERATION_LIGHTEN_ONLY_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE (gimp_operation_lighten_only_mode_get_type ())
#define GIMP_OPERATION_LIGHTEN_ONLY_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE, GimpOperationLightenOnlyMode))
#define GIMP_OPERATION_LIGHTEN_ONLY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE, GimpOperationLightenOnlyModeClass))
#define GIMP_IS_OPERATION_LIGHTEN_ONLY_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE))
#define GIMP_IS_OPERATION_LIGHTEN_ONLY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE))
#define GIMP_OPERATION_LIGHTEN_ONLY_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_LIGHTEN_ONLY_MODE, GimpOperationLightenOnlyModeClass))
typedef struct _GimpOperationLightenOnlyModeClass GimpOperationLightenOnlyModeClass;
struct _GimpOperationLightenOnlyMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLightenOnlyModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_lighten_only_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_LIGHTEN_ONLY_MODE_H__ */

85
app/gegl/gimpoperationmultiplymode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationmultiplymode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationmultiplymode.h"
static gboolean gimp_operation_multiply_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationMultiplyMode, gimp_operation_multiply_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_multiply_mode_class_init (GimpOperationMultiplyModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-multiply-mode";
operation_class->description = "GIMP multiply mode operation";
mode_class->process = gimp_operation_multiply_mode_process;
}
static void
gimp_operation_multiply_mode_init (GimpOperationMultiplyMode *self)
{
}
static gboolean
gimp_operation_multiply_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationmultiplymode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationmultiplymode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_MULTIPLY_MODE_H__
#define __GIMP_OPERATION_MULTIPLY_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_MULTIPLY_MODE (gimp_operation_multiply_mode_get_type ())
#define GIMP_OPERATION_MULTIPLY_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_MULTIPLY_MODE, GimpOperationMultiplyMode))
#define GIMP_OPERATION_MULTIPLY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_MULTIPLY_MODE, GimpOperationMultiplyModeClass))
#define GIMP_IS_OPERATION_MULTIPLY_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_MULTIPLY_MODE))
#define GIMP_IS_OPERATION_MULTIPLY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_MULTIPLY_MODE))
#define GIMP_OPERATION_MULTIPLY_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_MULTIPLY_MODE, GimpOperationMultiplyModeClass))
typedef struct _GimpOperationMultiplyModeClass GimpOperationMultiplyModeClass;
struct _GimpOperationMultiplyMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationMultiplyModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_multiply_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_MULTIPLY_MODE_H__ */

85
app/gegl/gimpoperationoverlaymode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationoverlaymode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationoverlaymode.h"
static gboolean gimp_operation_overlay_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationOverlayMode, gimp_operation_overlay_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_overlay_mode_class_init (GimpOperationOverlayModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-overlay-mode";
operation_class->description = "GIMP overlay mode operation";
mode_class->process = gimp_operation_overlay_mode_process;
}
static void
gimp_operation_overlay_mode_init (GimpOperationOverlayMode *self)
{
}
static gboolean
gimp_operation_overlay_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationoverlaymode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationoverlaymode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_OVERLAY_MODE_H__
#define __GIMP_OPERATION_OVERLAY_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_OVERLAY_MODE (gimp_operation_overlay_mode_get_type ())
#define GIMP_OPERATION_OVERLAY_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_OVERLAY_MODE, GimpOperationOverlayMode))
#define GIMP_OPERATION_OVERLAY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_OVERLAY_MODE, GimpOperationOverlayModeClass))
#define GIMP_IS_OPERATION_OVERLAY_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_OVERLAY_MODE))
#define GIMP_IS_OPERATION_OVERLAY_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_OVERLAY_MODE))
#define GIMP_OPERATION_OVERLAY_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_OVERLAY_MODE, GimpOperationOverlayModeClass))
typedef struct _GimpOperationOverlayModeClass GimpOperationOverlayModeClass;
struct _GimpOperationOverlayMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationOverlayModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_overlay_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_OVERLAY_MODE_H__ */

85
app/gegl/gimpoperationreplacemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationreplacemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationreplacemode.h"
static gboolean gimp_operation_replace_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationReplaceMode, gimp_operation_replace_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_replace_mode_class_init (GimpOperationReplaceModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-replace-mode";
operation_class->description = "GIMP replace mode operation";
mode_class->process = gimp_operation_replace_mode_process;
}
static void
gimp_operation_replace_mode_init (GimpOperationReplaceMode *self)
{
}
static gboolean
gimp_operation_replace_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationreplacemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationreplacemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_REPLACE_MODE_H__
#define __GIMP_OPERATION_REPLACE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_REPLACE_MODE (gimp_operation_replace_mode_get_type ())
#define GIMP_OPERATION_REPLACE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_REPLACE_MODE, GimpOperationReplaceMode))
#define GIMP_OPERATION_REPLACE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_REPLACE_MODE, GimpOperationReplaceModeClass))
#define GIMP_IS_OPERATION_REPLACE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_REPLACE_MODE))
#define GIMP_IS_OPERATION_REPLACE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_REPLACE_MODE))
#define GIMP_OPERATION_REPLACE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_REPLACE_MODE, GimpOperationReplaceModeClass))
typedef struct _GimpOperationReplaceModeClass GimpOperationReplaceModeClass;
struct _GimpOperationReplaceMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationReplaceModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_replace_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_REPLACE_MODE_H__ */

85
app/gegl/gimpoperationsaturationmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationsaturationmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationsaturationmode.h"
static gboolean gimp_operation_saturation_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationSaturationMode, gimp_operation_saturation_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_saturation_mode_class_init (GimpOperationSaturationModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-saturation-mode";
operation_class->description = "GIMP saturation mode operation";
mode_class->process = gimp_operation_saturation_mode_process;
}
static void
gimp_operation_saturation_mode_init (GimpOperationSaturationMode *self)
{
}
static gboolean
gimp_operation_saturation_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationsaturationmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationsaturationmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_SATURATION_MODE_H__
#define __GIMP_OPERATION_SATURATION_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SATURATION_MODE (gimp_operation_saturation_mode_get_type ())
#define GIMP_OPERATION_SATURATION_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_SATURATION_MODE, GimpOperationSaturationMode))
#define GIMP_OPERATION_SATURATION_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_SATURATION_MODE, GimpOperationSaturationModeClass))
#define GIMP_IS_OPERATION_SATURATION_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_SATURATION_MODE))
#define GIMP_IS_OPERATION_SATURATION_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_SATURATION_MODE))
#define GIMP_OPERATION_SATURATION_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_SATURATION_MODE, GimpOperationSaturationModeClass))
typedef struct _GimpOperationSaturationModeClass GimpOperationSaturationModeClass;
struct _GimpOperationSaturationMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSaturationModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_saturation_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SATURATION_MODE_H__ */

85
app/gegl/gimpoperationscreenmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationscreenmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationscreenmode.h"
static gboolean gimp_operation_screen_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationScreenMode, gimp_operation_screen_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_screen_mode_class_init (GimpOperationScreenModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-screen-mode";
operation_class->description = "GIMP screen mode operation";
mode_class->process = gimp_operation_screen_mode_process;
}
static void
gimp_operation_screen_mode_init (GimpOperationScreenMode *self)
{
}
static gboolean
gimp_operation_screen_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationscreenmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationscreenmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_SCREEN_MODE_H__
#define __GIMP_OPERATION_SCREEN_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SCREEN_MODE (gimp_operation_screen_mode_get_type ())
#define GIMP_OPERATION_SCREEN_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_SCREEN_MODE, GimpOperationScreenMode))
#define GIMP_OPERATION_SCREEN_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_SCREEN_MODE, GimpOperationScreenModeClass))
#define GIMP_IS_OPERATION_SCREEN_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_SCREEN_MODE))
#define GIMP_IS_OPERATION_SCREEN_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_SCREEN_MODE))
#define GIMP_OPERATION_SCREEN_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_SCREEN_MODE, GimpOperationScreenModeClass))
typedef struct _GimpOperationScreenModeClass GimpOperationScreenModeClass;
struct _GimpOperationScreenMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationScreenModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_screen_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SCREEN_MODE_H__ */

85
app/gegl/gimpoperationsoftlightmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationsoftlightmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationsoftlightmode.h"
static gboolean gimp_operation_softlight_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationSoftlightMode, gimp_operation_softlight_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_softlight_mode_class_init (GimpOperationSoftlightModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-softlight-mode";
operation_class->description = "GIMP softlight mode operation";
mode_class->process = gimp_operation_softlight_mode_process;
}
static void
gimp_operation_softlight_mode_init (GimpOperationSoftlightMode *self)
{
}
static gboolean
gimp_operation_softlight_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationsoftlightmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationsoftlightmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_SOFTLIGHT_MODE_H__
#define __GIMP_OPERATION_SOFTLIGHT_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SOFTLIGHT_MODE (gimp_operation_softlight_mode_get_type ())
#define GIMP_OPERATION_SOFTLIGHT_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_SOFTLIGHT_MODE, GimpOperationSoftlightMode))
#define GIMP_OPERATION_SOFTLIGHT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_SOFTLIGHT_MODE, GimpOperationSoftlightModeClass))
#define GIMP_IS_OPERATION_SOFTLIGHT_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_SOFTLIGHT_MODE))
#define GIMP_IS_OPERATION_SOFTLIGHT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_SOFTLIGHT_MODE))
#define GIMP_OPERATION_SOFTLIGHT_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_SOFTLIGHT_MODE, GimpOperationSoftlightModeClass))
typedef struct _GimpOperationSoftlightModeClass GimpOperationSoftlightModeClass;
struct _GimpOperationSoftlightMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSoftlightModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_softlight_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SOFTLIGHT_MODE_H__ */

85
app/gegl/gimpoperationsubtractmode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationsubtractmode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationsubtractmode.h"
static gboolean gimp_operation_subtract_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationSubtractMode, gimp_operation_subtract_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_subtract_mode_class_init (GimpOperationSubtractModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-subtract-mode";
operation_class->description = "GIMP subtract mode operation";
mode_class->process = gimp_operation_subtract_mode_process;
}
static void
gimp_operation_subtract_mode_init (GimpOperationSubtractMode *self)
{
}
static gboolean
gimp_operation_subtract_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationsubtractmode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationsubtractmode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_SUBTRACT_MODE_H__
#define __GIMP_OPERATION_SUBTRACT_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SUBTRACT_MODE (gimp_operation_subtract_mode_get_type ())
#define GIMP_OPERATION_SUBTRACT_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_SUBTRACT_MODE, GimpOperationSubtractMode))
#define GIMP_OPERATION_SUBTRACT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_SUBTRACT_MODE, GimpOperationSubtractModeClass))
#define GIMP_IS_OPERATION_SUBTRACT_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_SUBTRACT_MODE))
#define GIMP_IS_OPERATION_SUBTRACT_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_SUBTRACT_MODE))
#define GIMP_OPERATION_SUBTRACT_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_SUBTRACT_MODE, GimpOperationSubtractModeClass))
typedef struct _GimpOperationSubtractModeClass GimpOperationSubtractModeClass;
struct _GimpOperationSubtractMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSubtractModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_subtract_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SUBTRACT_MODE_H__ */

85
app/gegl/gimpoperationvaluemode.c
View file

@ -1,85 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationvaluemode.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "gegl-types.h"
#include "gimpoperationvaluemode.h"
static gboolean gimp_operation_value_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi);
G_DEFINE_TYPE (GimpOperationValueMode, gimp_operation_value_mode,
GIMP_TYPE_OPERATION_LAYER_MODE)
static void
gimp_operation_value_mode_class_init (GimpOperationValueModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GimpOperationLayerModeClass *mode_class = GIMP_OPERATION_LAYER_MODE_CLASS (klass);
operation_class->name = "gimp-value-mode";
operation_class->description = "GIMP value mode operation";
mode_class->process = gimp_operation_value_mode_process;
}
static void
gimp_operation_value_mode_init (GimpOperationValueMode *self)
{
}
static gboolean
gimp_operation_value_mode_process (GeglOperation *operation,
void *in_buf,
void *aux_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
gfloat *in = in_buf;
gfloat *layer = aux_buf;
gfloat *out = out_buf;
while (samples--)
{
out[RED] = in[RED];
out[GREEN] = in[GREEN];
out[BLUE] = in[BLUE];
out[ALPHA] = in[ALPHA];
in += 4;
layer += 4;
out += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationvaluemode.h
View file

@ -1,53 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationvaluemode.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_OPERATION_VALUE_MODE_H__
#define __GIMP_OPERATION_VALUE_MODE_H__
#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_VALUE_MODE (gimp_operation_value_mode_get_type ())
#define GIMP_OPERATION_VALUE_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_VALUE_MODE, GimpOperationValueMode))
#define GIMP_OPERATION_VALUE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_VALUE_MODE, GimpOperationValueModeClass))
#define GIMP_IS_OPERATION_VALUE_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_VALUE_MODE))
#define GIMP_IS_OPERATION_VALUE_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_VALUE_MODE))
#define GIMP_OPERATION_VALUE_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_VALUE_MODE, GimpOperationValueModeClass))
typedef struct _GimpOperationValueModeClass GimpOperationValueModeClass;
struct _GimpOperationValueMode
{
GimpOperationLayerMode parent_instance;
};
struct _GimpOperationValueModeClass
{
GimpOperationLayerModeClass parent_class;
};
GType gimp_operation_value_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_VALUE_MODE_H__ */