dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add an empty abstract GeglOperationPointComposer subclass which can be 

2008-10-11  Michael Natterer  <mitch@gimp.org>

	* app/gegl/gimpoperationpointcomposer.[ch]: add an empty abstract
	GeglOperationPointComposer subclass which can be used to hook in
	common debug or test or whatever code for below layer modes.

	* app/gegl/gimpoperation*mode.[ch]: add empty stubs of layer mode
	operations which do nothing but copying input to output.

	* app/gegl/Makefile.am
	* app/gegl/gegl-types.h: add them here and reordered things a bit.

	* app/gegl/gimp-gegl.c (gimp_gegl_init): register the new
	operations.

	* app/gegl/gimp-gegl-utils.c (gimp_layer_mode_to_gegl_operation):
	return the new operations.


svn path=/trunk/; revision=27239
This commit is contained in:
Michael Natterer 2008-10-11 17:20:20 +00:00 committed by Michael Natterer
parent d61aab0131
commit 414cc45abf
59 changed files with 3891 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ChangeLog
View File

@ -1,3 +1,21 @@
2008-10-11 Michael Natterer <mitch@gimp.org>
* app/gegl/gimpoperationpointcomposer.[ch]: add an empty abstract
GeglOperationPointComposer subclass which can be used to hook in
common debug or test or whatever code for below layer modes.
* app/gegl/gimpoperation*mode.[ch]: add empty stubs of layer mode
operations which do nothing but copying input to output.
* app/gegl/Makefile.am
* app/gegl/gegl-types.h: add them here and reordered things a bit.
* app/gegl/gimp-gegl.c (gimp_gegl_init): register the new
operations.
* app/gegl/gimp-gegl-utils.c (gimp_layer_mode_to_gegl_operation):
return the new operations.
2008-10-11 Michael Natterer <mitch@gimp.org> 2008-10-11 Michael Natterer <mitch@gimp.org>
* app/gegl/gimpoperationpointfilter.c: make it abstract. * app/gegl/gimpoperationpointfilter.c: make it abstract.

66
app/gegl/Makefile.am
View File

@ -40,6 +40,13 @@ libappgegl_a_SOURCES = \
gimpthresholdconfig.c \ gimpthresholdconfig.c \
gimpthresholdconfig.h \ gimpthresholdconfig.h \
\ \
gimpoperationtilesink.c \
gimpoperationtilesink.h \
gimpoperationtilesource.c \
gimpoperationtilesource.h \
\
gimpoperationpointfilter.c \
gimpoperationpointfilter.h \
gimpoperationcolorbalance.c \ gimpoperationcolorbalance.c \
gimpoperationcolorbalance.h \ gimpoperationcolorbalance.h \
gimpoperationcolorize.c \ gimpoperationcolorize.c \
@ -52,13 +59,60 @@ libappgegl_a_SOURCES = \
gimpoperationhuesaturation.h \ gimpoperationhuesaturation.h \
gimpoperationlevels.c \ gimpoperationlevels.c \
gimpoperationlevels.h \ gimpoperationlevels.h \
gimpoperationpointfilter.c \
gimpoperationpointfilter.h \
gimpoperationposterize.c \ gimpoperationposterize.c \
gimpoperationposterize.h \ gimpoperationposterize.h \
gimpoperationthreshold.c \ gimpoperationthreshold.c \
gimpoperationthreshold.h \ gimpoperationthreshold.h \
gimpoperationtilesink.c \ \
gimpoperationtilesink.h \ gimpoperationpointcomposer.c \
gimpoperationtilesource.c \ gimpoperationpointcomposer.h \
gimpoperationtilesource.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

34
app/gegl/gegl-types.h
View File

@ -27,17 +27,45 @@
/* operations */ /* operations */
typedef struct _GimpOperationTileSink GimpOperationTileSink;
typedef struct _GimpOperationTileSource GimpOperationTileSource;
typedef struct _GimpOperationPointFilter GimpOperationPointFilter;
typedef struct _GimpOperationColorBalance GimpOperationColorBalance; typedef struct _GimpOperationColorBalance GimpOperationColorBalance;
typedef struct _GimpOperationColorize GimpOperationColorize; typedef struct _GimpOperationColorize GimpOperationColorize;
typedef struct _GimpOperationCurves GimpOperationCurves; typedef struct _GimpOperationCurves GimpOperationCurves;
typedef struct _GimpOperationDesaturate GimpOperationDesaturate; typedef struct _GimpOperationDesaturate GimpOperationDesaturate;
typedef struct _GimpOperationHueSaturation GimpOperationHueSaturation; typedef struct _GimpOperationHueSaturation GimpOperationHueSaturation;
typedef struct _GimpOperationLevels GimpOperationLevels; typedef struct _GimpOperationLevels GimpOperationLevels;
typedef struct _GimpOperationPointFilter GimpOperationPointFilter;
typedef struct _GimpOperationPosterize GimpOperationPosterize; typedef struct _GimpOperationPosterize GimpOperationPosterize;
typedef struct _GimpOperationThreshold GimpOperationThreshold; typedef struct _GimpOperationThreshold GimpOperationThreshold;
typedef struct _GimpOperationTileSink GimpOperationTileSink;
typedef struct _GimpOperationTileSource GimpOperationTileSource; typedef struct _GimpOperationPointComposer GimpOperationPointComposer;
typedef struct _GimpOperationDissolveMode GimpOperationDissolveMode;
typedef struct _GimpOperationBehindMode GimpOperationBehindMode;
typedef struct _GimpOperationMultiplyMode GimpOperationMultiplyMode;
typedef struct _GimpOperationScreenMode GimpOperationScreenMode;
typedef struct _GimpOperationOverlayMode GimpOperationOverlayMode;
typedef struct _GimpOperationDifferenceMode GimpOperationDifferenceMode;
typedef struct _GimpOperationAdditionMode GimpOperationAdditionMode;
typedef struct _GimpOperationSubtractMode GimpOperationSubtractMode;
typedef struct _GimpOperationDarkenOnlyMode GimpOperationDarkenOnlyMode;
typedef struct _GimpOperationLightenOnlyMode GimpOperationLightenOnlyMode;
typedef struct _GimpOperationHueMode GimpOperationHueMode;
typedef struct _GimpOperationSaturationMode GimpOperationSaturationMode;
typedef struct _GimpOperationColorMode GimpOperationColorMode;
typedef struct _GimpOperationValueMode GimpOperationValueMode;
typedef struct _GimpOperationDivideMode GimpOperationDivideMode;
typedef struct _GimpOperationDodgeMode GimpOperationDodgeMode;
typedef struct _GimpOperationBurnMode GimpOperationBurnMode;
typedef struct _GimpOperationHardlightMode GimpOperationHardlightMode;
typedef struct _GimpOperationSoftlightMode GimpOperationSoftlightMode;
typedef struct _GimpOperationGrainExtractMode GimpOperationGrainExtractMode;
typedef struct _GimpOperationGrainMergeMode GimpOperationGrainMergeMode;
typedef struct _GimpOperationColorEraseMode GimpOperationColorEraseMode;
typedef struct _GimpOperationEraseMode GimpOperationEraseMode;
typedef struct _GimpOperationReplaceMode GimpOperationReplaceMode;
typedef struct _GimpOperationAntiEraseMode GimpOperationAntiEraseMode;
/* operation config objects */ /* operation config objects */

44
app/gegl/gimp-gegl-utils.c
View File

@ -96,28 +96,28 @@ gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode)
switch (mode) switch (mode)
{ {
case GIMP_NORMAL_MODE: return "normal"; case GIMP_NORMAL_MODE: return "normal";
case GIMP_DISSOLVE_MODE: return "normal"; /* "gimp-dissolve-mode" */ case GIMP_DISSOLVE_MODE: return "gimp-dissolve-mode";
case GIMP_BEHIND_MODE: return "normal"; /* "gimp-behind-mode" */ case GIMP_BEHIND_MODE: return "gimp-behind-mode";
case GIMP_MULTIPLY_MODE: return "normal"; /* "gimp-multiply-mode" */ case GIMP_MULTIPLY_MODE: return "gimp-multiply-mode";
case GIMP_SCREEN_MODE: return "normal"; /* "gimp-screen_mode" */ case GIMP_SCREEN_MODE: return "gimp-screen_mode";
case GIMP_OVERLAY_MODE: return "normal"; /* "gimp-overlay-mode" */ case GIMP_OVERLAY_MODE: return "gimp-overlay-mode";
case GIMP_DIFFERENCE_MODE: return "normal"; /* "gimp-difference-mode" */ case GIMP_DIFFERENCE_MODE: return "gimp-difference-mode";
case GIMP_ADDITION_MODE: return "normal"; /* "gimp-addition-mode" */ case GIMP_ADDITION_MODE: return "gimp-addition-mode";
case GIMP_SUBTRACT_MODE: return "normal"; /* "gimp-subtract-mode" */ case GIMP_SUBTRACT_MODE: return "gimp-subtract-mode";
case GIMP_DARKEN_ONLY_MODE: return "normal"; /* "gimp-darken-mode" */ case GIMP_DARKEN_ONLY_MODE: return "gimp-darken-mode";
case GIMP_LIGHTEN_ONLY_MODE: return "normal"; /* "gimp-lighten-mode" */ case GIMP_LIGHTEN_ONLY_MODE: return "gimp-lighten-mode";
case GIMP_HUE_MODE: return "normal"; /* "gimp-hue-mode" */ case GIMP_HUE_MODE: return "gimp-hue-mode";
case GIMP_SATURATION_MODE: return "normal"; /* "gimp-saturation-mode" */ case GIMP_SATURATION_MODE: return "gimp-saturation-mode";
case GIMP_COLOR_MODE: return "normal"; /* "gimp-color-mode" */ case GIMP_COLOR_MODE: return "gimp-color-mode";
case GIMP_VALUE_MODE: return "normal"; /* "gimp-value-mode" */ case GIMP_VALUE_MODE: return "gimp-value-mode";
case GIMP_DIVIDE_MODE: return "normal"; /* "gimp-divide-mode" */ case GIMP_DIVIDE_MODE: return "gimp-divide-mode";
case GIMP_DODGE_MODE: return "normal"; /* "gimp-dodge-mode" */ case GIMP_DODGE_MODE: return "gimp-dodge-mode";
case GIMP_BURN_MODE: return "normal"; /* "gimp-burn-mode" */ case GIMP_BURN_MODE: return "gimp-burn-mode";
case GIMP_HARDLIGHT_MODE: return "normal"; /* "gimp-hardlight-mode" */ case GIMP_HARDLIGHT_MODE: return "gimp-hardlight-mode";
case GIMP_SOFTLIGHT_MODE: return "normal"; /* "gimp-softlight-mode" */ case GIMP_SOFTLIGHT_MODE: return "gimp-softlight-mode";
case GIMP_GRAIN_EXTRACT_MODE: return "normal"; /* "gimp-grain-extract-mode" */ case GIMP_GRAIN_EXTRACT_MODE: return "gimp-grain-extract-mode";
case GIMP_GRAIN_MERGE_MODE: return "normal"; /* "gimp-grain-merge-mode" */ case GIMP_GRAIN_MERGE_MODE: return "gimp-grain-merge-mode";
case GIMP_COLOR_ERASE_MODE: return "normal"; /* "gimp-color-erase-mode" */ case GIMP_COLOR_ERASE_MODE: return "gimp-color-erase-mode";
default: default:
break; break;
} }

57
app/gegl/gimp-gegl.c
View File

@ -39,6 +39,32 @@
#include "gimpoperationtilesink.h" #include "gimpoperationtilesink.h"
#include "gimpoperationtilesource.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"
void void
gimp_gegl_init (void) gimp_gegl_init (void)
@ -48,6 +74,9 @@ gimp_gegl_init (void)
"tile-height", TILE_HEIGHT, "tile-height", TILE_HEIGHT,
NULL); NULL);
g_type_class_ref (GIMP_TYPE_OPERATION_TILE_SINK);
g_type_class_ref (GIMP_TYPE_OPERATION_TILE_SOURCE);
g_type_class_ref (GIMP_TYPE_OPERATION_COLOR_BALANCE); g_type_class_ref (GIMP_TYPE_OPERATION_COLOR_BALANCE);
g_type_class_ref (GIMP_TYPE_OPERATION_COLORIZE); g_type_class_ref (GIMP_TYPE_OPERATION_COLORIZE);
g_type_class_ref (GIMP_TYPE_OPERATION_CURVES); g_type_class_ref (GIMP_TYPE_OPERATION_CURVES);
@ -56,6 +85,30 @@ gimp_gegl_init (void)
g_type_class_ref (GIMP_TYPE_OPERATION_LEVELS); g_type_class_ref (GIMP_TYPE_OPERATION_LEVELS);
g_type_class_ref (GIMP_TYPE_OPERATION_POSTERIZE); g_type_class_ref (GIMP_TYPE_OPERATION_POSTERIZE);
g_type_class_ref (GIMP_TYPE_OPERATION_THRESHOLD); g_type_class_ref (GIMP_TYPE_OPERATION_THRESHOLD);
g_type_class_ref (GIMP_TYPE_OPERATION_TILE_SINK);
g_type_class_ref (GIMP_TYPE_OPERATION_TILE_SOURCE); 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);
} }

85
app/gegl/gimpoperationadditionmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_addition_mode_class_init (GimpOperationAdditionModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-addition-mode";
operation_class->description = "GIMP addition mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationadditionmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationAdditionModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_addition_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_ADDITION_MODE_H__ */

85
app/gegl/gimpoperationantierasemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_anti_erase_mode_class_init (GimpOperationAntiEraseModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-anti-erase-mode";
operation_class->description = "GIMP anti erase mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationantierasemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationAntiEraseModeClass
{
GimpOperationPointComposerClass 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 Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_behind_mode_class_init (GimpOperationBehindModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-behind-mode";
operation_class->description = "GIMP behind mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationbehindmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationBehindModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_behind_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_BEHIND_MODE_H__ */

85
app/gegl/gimpoperationburnmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_burn_mode_class_init (GimpOperationBurnModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-burn-mode";
operation_class->description = "GIMP burn mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationburnmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationBurnModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_burn_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_BURN_MODE_H__ */

85
app/gegl/gimpoperationcolorerasemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_color_erase_mode_class_init (GimpOperationColorEraseModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-color-erase-mode";
operation_class->description = "GIMP color erase mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationcolorerasemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationColorEraseModeClass
{
GimpOperationPointComposerClass 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 Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_color_mode_class_init (GimpOperationColorModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-color-mode";
operation_class->description = "GIMP color mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationcolormode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationColorModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_color_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_COLOR_MODE_H__ */

85
app/gegl/gimpoperationdarkenonlymode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_darken_only_mode_class_init (GimpOperationDarkenOnlyModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-darken-only-mode";
operation_class->description = "GIMP darken only mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdarkenonlymode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationDarkenOnlyModeClass
{
GimpOperationPointComposerClass 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 Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_difference_mode_class_init (GimpOperationDifferenceModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-difference-mode";
operation_class->description = "GIMP difference mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdifferencemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationDifferenceModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_difference_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DIFFERENCE_MODE_H__ */

85
app/gegl/gimpoperationdissolvemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_dissolve_mode_class_init (GimpOperationDissolveModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-dissolve-mode";
operation_class->description = "GIMP dissolve mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdissolvemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationDissolveModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_dissolve_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DISSOLVE_MODE_H__ */

85
app/gegl/gimpoperationdividemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_divide_mode_class_init (GimpOperationDivideModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-divide-mode";
operation_class->description = "GIMP divide mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdividemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationDivideModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_divide_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DIVIDE_MODE_H__ */

85
app/gegl/gimpoperationdodgemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_dodge_mode_class_init (GimpOperationDodgeModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-dodge-mode";
operation_class->description = "GIMP dodge mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationdodgemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationDodgeModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_dodge_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DODGE_MODE_H__ */

85
app/gegl/gimpoperationerasemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_erase_mode_class_init (GimpOperationEraseModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-erase-mode";
operation_class->description = "GIMP erase mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationerasemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationEraseModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_erase_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_ERASE_MODE_H__ */

85
app/gegl/gimpoperationgrainextractmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_grain_extract_mode_class_init (GimpOperationGrainExtractModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-grain-extract-mode";
operation_class->description = "GIMP grain extract mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationgrainextractmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationGrainExtractModeClass
{
GimpOperationPointComposerClass 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 Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_grain_merge_mode_class_init (GimpOperationGrainMergeModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-grain-merge-mode";
operation_class->description = "GIMP grain merge mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationgrainmergemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationGrainMergeModeClass
{
GimpOperationPointComposerClass 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 Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_hardlight_mode_class_init (GimpOperationHardlightModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-hardlight-mode";
operation_class->description = "GIMP hardlight mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationhardlightmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationHardlightModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_hardlight_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_HARDLIGHT_MODE_H__ */

85
app/gegl/gimpoperationhuemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_hue_mode_class_init (GimpOperationHueModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-hue-mode";
operation_class->description = "GIMP hue mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationhuemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationHueModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_hue_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_HUE_MODE_H__ */

85
app/gegl/gimpoperationlightenonlymode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_lighten_only_mode_class_init (GimpOperationLightenOnlyModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-lighten-only-mode";
operation_class->description = "GIMP lighten only mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationlightenonlymode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationLightenOnlyModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_lighten_only_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_LIGHTEN_ONLY_MODE_H__ */

85
app/gegl/gimpoperationmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_dissolve_mode_class_init (GimpOperationDissolveModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-dissolve-mode";
operation_class->description = "GIMP dissolve mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationDissolveModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_dissolve_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_DISSOLVE_MODE_H__ */

85
app/gegl/gimpoperationmultiplymode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_multiply_mode_class_init (GimpOperationMultiplyModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-multiply-mode";
operation_class->description = "GIMP multiply mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationmultiplymode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationMultiplyModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_multiply_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_MULTIPLY_MODE_H__ */

85
app/gegl/gimpoperationoverlaymode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_overlay_mode_class_init (GimpOperationOverlayModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-overlay-mode";
operation_class->description = "GIMP overlay mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationoverlaymode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationOverlayModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_overlay_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_OVERLAY_MODE_H__ */

46
app/gegl/gimpoperationpointcomposer.c Normal file
View File

@ -0,0 +1,46 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationpointcomposer.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 "gimpoperationpointcomposer.h"
G_DEFINE_ABSTRACT_TYPE (GimpOperationPointComposer, gimp_operation_point_composer,
GEGL_TYPE_OPERATION_POINT_COMPOSER)
static void
gimp_operation_point_composer_class_init (GimpOperationPointComposerClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
operation_class->categories = "compositors";
}
static void
gimp_operation_point_composer_init (GimpOperationPointComposer *self)
{
}

54
app/gegl/gimpoperationpointcomposer.h Normal file
View File

@ -0,0 +1,54 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationpointcomposer.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_POINT_COMPOSER_H__
#define __GIMP_OPERATION_POINT_COMPOSER_H__
#include <gegl-plugin.h>
#include <operation/gegl-operation-point-composer.h>
#define GIMP_TYPE_OPERATION_POINT_COMPOSER (gimp_operation_point_composer_get_type ())
#define GIMP_OPERATION_POINT_COMPOSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_POINT_COMPOSER, GimpOperationPointComposer))
#define GIMP_OPERATION_POINT_COMPOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_POINT_COMPOSER, GimpOperationPointComposerClass))
#define GIMP_IS_OPERATION_POINT_COMPOSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_POINT_COMPOSER))
#define GIMP_IS_OPERATION_POINT_COMPOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_POINT_COMPOSER))
#define GIMP_OPERATION_POINT_COMPOSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_POINT_COMPOSER, GimpOperationPointComposerClass))
typedef struct _GimpOperationPointComposerClass GimpOperationPointComposerClass;
struct _GimpOperationPointComposer
{
GeglOperationPointComposer parent_instance;
};
struct _GimpOperationPointComposerClass
{
GeglOperationPointComposerClass parent_class;
};
GType gimp_operation_point_composer_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_POINT_COMPOSER_H__ */

85
app/gegl/gimpoperationreplacemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_replace_mode_class_init (GimpOperationReplaceModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-replace-mode";
operation_class->description = "GIMP replace mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationreplacemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationReplaceModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_replace_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_REPLACE_MODE_H__ */

85
app/gegl/gimpoperationsaturationmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_saturation_mode_class_init (GimpOperationSaturationModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-saturation-mode";
operation_class->description = "GIMP saturation mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationsaturationmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationSaturationModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_saturation_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SATURATION_MODE_H__ */

85
app/gegl/gimpoperationscreenmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_screen_mode_class_init (GimpOperationScreenModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-screen-mode";
operation_class->description = "GIMP screen mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationscreenmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationScreenModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_screen_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SCREEN_MODE_H__ */

85
app/gegl/gimpoperationsoftlightmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_softlight_mode_class_init (GimpOperationSoftlightModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-softlight-mode";
operation_class->description = "GIMP softlight mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationsoftlightmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationSoftlightModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_softlight_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SOFTLIGHT_MODE_H__ */

85
app/gegl/gimpoperationsubtractmode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_subtract_mode_class_init (GimpOperationSubtractModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-subtract-mode";
operation_class->description = "GIMP subtract mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationsubtractmode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationSubtractModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_subtract_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_SUBTRACT_MODE_H__ */

85
app/gegl/gimpoperationvaluemode.c Normal file
View File

@ -0,0 +1,85 @@
/* 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_POINT_COMPOSER)
static void
gimp_operation_value_mode_class_init (GimpOperationValueModeClass *klass)
{
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
operation_class->name = "gimp-value-mode";
operation_class->description = "GIMP value mode operation";
point_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 *src = in_buf;
gfloat *aux = aux_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED_PIX] = src[RED_PIX];
dest[GREEN_PIX] = src[GREEN_PIX];
dest[BLUE_PIX] = src[BLUE_PIX];
dest[ALPHA_PIX] = src[ALPHA_PIX];
src += 4;
aux += 4;
dest += 4;
}
return TRUE;
}

53
app/gegl/gimpoperationvaluemode.h Normal file
View File

@ -0,0 +1,53 @@
/* 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 "gimpoperationpointcomposer.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
{
GimpOperationPointComposer parent_instance;
};
struct _GimpOperationValueModeClass
{
GimpOperationPointComposerClass parent_class;
};
GType gimp_operation_value_mode_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_VALUE_MODE_H__ */