[gimp] app: rename GimpOperationPointLayerMode to GimpOperationLayerMode
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] app: rename GimpOperationPointLayerMode to GimpOperationLayerMode
- Date: Sat, 21 Jan 2017 20:36:39 +0000 (UTC)
commit 05f3d38acbe3c5a8634b1f410527d2ad158bb089
Author: Michael Natterer <mitch gimp org>
Date: Sat Jan 21 21:35:52 2017 +0100
app: rename GimpOperationPointLayerMode to GimpOperationLayerMode
and formatting cleanup.
.../gimpoperationadditionlegacy.c | 14 ++-
.../gimpoperationadditionlegacy.h | 24 +++---
.../layer-modes-legacy/gimpoperationburnlegacy.c | 11 ++-
.../layer-modes-legacy/gimpoperationburnlegacy.h | 24 +++---
.../gimpoperationdarkenonlylegacy.c | 12 ++-
.../gimpoperationdarkenonlylegacy.h | 24 +++---
.../gimpoperationdifferencelegacy.c | 13 ++-
.../gimpoperationdifferencelegacy.h | 24 +++---
.../layer-modes-legacy/gimpoperationdividelegacy.c | 12 ++-
.../layer-modes-legacy/gimpoperationdividelegacy.h | 24 +++---
.../layer-modes-legacy/gimpoperationdodgelegacy.c | 13 ++-
.../layer-modes-legacy/gimpoperationdodgelegacy.h | 24 +++---
.../gimpoperationgrainextractlegacy.c | 13 ++-
.../gimpoperationgrainextractlegacy.h | 24 +++---
.../gimpoperationgrainmergelegacy.c | 13 ++-
.../gimpoperationgrainmergelegacy.h | 24 +++---
.../gimpoperationhardlightlegacy.c | 27 +++---
.../gimpoperationhardlightlegacy.h | 24 +++---
.../gimpoperationhsvcolorlegacy.c | 28 +++---
.../gimpoperationhsvcolorlegacy.h | 24 +++---
.../layer-modes-legacy/gimpoperationhsvhuelegacy.c | 11 ++-
.../layer-modes-legacy/gimpoperationhsvhuelegacy.h | 24 +++---
.../gimpoperationhsvsaturationlegacy.c | 11 ++-
.../gimpoperationhsvsaturationlegacy.h | 24 +++---
.../gimpoperationhsvvaluelegacy.c | 28 +++---
.../gimpoperationhsvvaluelegacy.h | 24 +++---
.../gimpoperationlightenonlylegacy.c | 11 ++-
.../gimpoperationlightenonlylegacy.h | 24 +++---
.../gimpoperationmultiplylegacy.c | 29 +++---
.../gimpoperationmultiplylegacy.h | 24 +++---
.../layer-modes-legacy/gimpoperationscreenlegacy.c | 12 ++-
.../layer-modes-legacy/gimpoperationscreenlegacy.h | 24 +++---
.../gimpoperationsoftlightlegacy.c | 15 ++-
.../gimpoperationsoftlightlegacy.h | 24 +++---
.../gimpoperationsubtractlegacy.c | 14 ++-
.../gimpoperationsubtractlegacy.h | 24 +++---
app/operations/layer-modes/Makefile.am | 4 +-
app/operations/layer-modes/gimpblendcomposite.h | 11 +-
app/operations/layer-modes/gimpoperationaddition.c | 7 +-
app/operations/layer-modes/gimpoperationaddition.h | 24 +++---
.../layer-modes/gimpoperationantierase.c | 29 +++---
.../layer-modes/gimpoperationantierase.h | 24 +++---
app/operations/layer-modes/gimpoperationbehind.c | 13 ++-
app/operations/layer-modes/gimpoperationbehind.h | 24 +++---
app/operations/layer-modes/gimpoperationburn.c | 4 +-
app/operations/layer-modes/gimpoperationburn.h | 24 +++---
.../layer-modes/gimpoperationcolorerase.c | 14 ++-
.../layer-modes/gimpoperationcolorerase.h | 24 +++---
.../layer-modes/gimpoperationdarkenonly.c | 19 ++--
.../layer-modes/gimpoperationdarkenonly.h | 24 +++---
.../layer-modes/gimpoperationdifference.c | 18 ++--
.../layer-modes/gimpoperationdifference.h | 24 +++---
app/operations/layer-modes/gimpoperationdissolve.c | 49 +++++----
app/operations/layer-modes/gimpoperationdissolve.h | 24 +++---
app/operations/layer-modes/gimpoperationdivide.c | 21 ++--
app/operations/layer-modes/gimpoperationdivide.h | 24 +++---
app/operations/layer-modes/gimpoperationdodge.c | 5 +-
app/operations/layer-modes/gimpoperationdodge.h | 24 +++---
app/operations/layer-modes/gimpoperationerase.c | 30 +++---
app/operations/layer-modes/gimpoperationerase.h | 24 +++---
.../layer-modes/gimpoperationgrainextract.c | 18 ++--
.../layer-modes/gimpoperationgrainextract.h | 24 +++---
.../layer-modes/gimpoperationgrainmerge.c | 19 ++--
.../layer-modes/gimpoperationgrainmerge.h | 24 +++---
.../layer-modes/gimpoperationhardlight.c | 18 ++--
.../layer-modes/gimpoperationhardlight.h | 24 +++---
app/operations/layer-modes/gimpoperationhsvcolor.c | 18 ++--
app/operations/layer-modes/gimpoperationhsvcolor.h | 24 +++---
app/operations/layer-modes/gimpoperationhsvhue.c | 3 +-
app/operations/layer-modes/gimpoperationhsvhue.h | 24 +++---
.../layer-modes/gimpoperationhsvsaturation.c | 20 ++--
.../layer-modes/gimpoperationhsvsaturation.h | 24 +++---
app/operations/layer-modes/gimpoperationhsvvalue.c | 18 ++--
app/operations/layer-modes/gimpoperationhsvvalue.h | 24 +++---
...onpointlayermode.c => gimpoperationlayermode.c} | 104 ++++++++++----------
.../layer-modes/gimpoperationlayermode.h | 59 +++++++++++
.../layer-modes/gimpoperationlchchroma.c | 21 ++--
.../layer-modes/gimpoperationlchchroma.h | 24 +++---
app/operations/layer-modes/gimpoperationlchcolor.c | 21 ++--
app/operations/layer-modes/gimpoperationlchcolor.h | 24 +++---
app/operations/layer-modes/gimpoperationlchhue.c | 5 +-
app/operations/layer-modes/gimpoperationlchhue.h | 25 +++---
.../layer-modes/gimpoperationlchlightness.c | 21 ++--
.../layer-modes/gimpoperationlchlightness.h | 24 +++---
.../layer-modes/gimpoperationlightenonly.c | 3 +-
.../layer-modes/gimpoperationlightenonly.h | 24 +++---
app/operations/layer-modes/gimpoperationmultiply.c | 22 +++--
app/operations/layer-modes/gimpoperationmultiply.h | 24 +++---
.../layer-modes/gimpoperationnormal-sse2.c | 20 ++--
.../layer-modes/gimpoperationnormal-sse4.c | 20 ++--
app/operations/layer-modes/gimpoperationnormal.c | 57 ++++++-----
app/operations/layer-modes/gimpoperationnormal.h | 60 ++++++------
app/operations/layer-modes/gimpoperationoverlay.c | 3 +-
app/operations/layer-modes/gimpoperationoverlay.h | 24 +++---
.../layer-modes/gimpoperationpointlayermode.h | 59 -----------
app/operations/layer-modes/gimpoperationreplace.c | 14 ++-
app/operations/layer-modes/gimpoperationreplace.h | 24 +++---
app/operations/layer-modes/gimpoperationscreen.c | 3 +-
app/operations/layer-modes/gimpoperationscreen.h | 24 +++---
.../layer-modes/gimpoperationsoftlight.c | 5 +-
.../layer-modes/gimpoperationsoftlight.h | 24 +++---
app/operations/layer-modes/gimpoperationsubtract.c | 3 +-
app/operations/layer-modes/gimpoperationsubtract.h | 24 +++---
app/operations/operations-types.h | 2 +-
app/paint/gimppaintcore-loops.c | 24 +++--
105 files changed, 1194 insertions(+), 1086 deletions(-)
---
diff --git a/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.c
index 0338442..3279028 100644
--- a/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.c
@@ -27,8 +27,9 @@
#include "gimpoperationadditionlegacy.h"
+
G_DEFINE_TYPE (GimpOperationAdditionLegacy, gimp_operation_addition_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -63,10 +64,13 @@ gimp_operation_addition_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.h
index 21b5ea7..730a5dc 100644
--- a/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationadditionlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_ADDITION_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ADDITION_LEGACY (gimp_operation_addition_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationAdditionLegacyClass GimpOperationAdditionLegacyClas
struct _GimpOperationAdditionLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationAdditionLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_addition_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_addition_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_addition_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_addition_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_ADDITION_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationburnlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationburnlegacy.c
index d7e1088..a00a131 100644
--- a/app/operations/layer-modes-legacy/gimpoperationburnlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationburnlegacy.c
@@ -28,7 +28,7 @@
#include "gimpoperationburnlegacy.h"
G_DEFINE_TYPE (GimpOperationBurnLegacy, gimp_operation_burn_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -63,9 +63,12 @@ gimp_operation_burn_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationburnlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationburnlegacy.h
index 22853f7..5e350d9 100644
--- a/app/operations/layer-modes-legacy/gimpoperationburnlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationburnlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_BURN_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_BURN_LEGACY (gimp_operation_burn_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationBurnLegacyClass GimpOperationBurnLegacyClass;
struct _GimpOperationBurnLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationBurnLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_burn_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_burn_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_burn_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_burn_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_BURN_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.c
b/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.c
index a30fa57..a35abbd 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.c
@@ -29,7 +29,7 @@
G_DEFINE_TYPE (GimpOperationDarkenOnlyLegacy, gimp_operation_darken_only_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -64,10 +64,12 @@ gimp_operation_darken_only_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
-
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.h
b/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.h
index 55f7d50..5f416b3 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationdarkenonlylegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_DARKEN_ONLY_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DARKEN_ONLY_LEGACY (gimp_operation_darken_only_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationDarkenOnlyLegacyClass GimpOperationDarkenOnlyLegacy
struct _GimpOperationDarkenOnlyLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDarkenOnlyLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_darken_only_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_darken_only_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_darken_only_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_darken_only_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DARKEN_ONLY_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.c
b/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.c
index c4de0e9..1fa5ffa 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.c
@@ -27,8 +27,10 @@
#include "gimpoperationdifferencelegacy.h"
+
G_DEFINE_TYPE (GimpOperationDifferenceLegacy, gimp_operation_difference_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static void
gimp_operation_difference_legacy_class_init (GimpOperationDifferenceLegacyClass *klass)
@@ -63,9 +65,12 @@ gimp_operation_difference_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.h
b/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.h
index b046c1e..727a623 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationdifferencelegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_DIFFERENCE_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DIFFERENCE_LEGACY (gimp_operation_difference_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationDifferenceLegacyClass GimpOperationDifferenceLegacy
struct _GimpOperationDifferenceLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDifferenceLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_difference_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_difference_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_difference_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_difference_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DIFFERENCE_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationdividelegacy.c
b/app/operations/layer-modes-legacy/gimpoperationdividelegacy.c
index 4e8e691..b20a89a 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdividelegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationdividelegacy.c
@@ -27,8 +27,9 @@
#include "gimpoperationdividelegacy.h"
+
G_DEFINE_TYPE (GimpOperationDivideLegacy, gimp_operation_divide_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -63,9 +64,12 @@ gimp_operation_divide_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationdividelegacy.h
b/app/operations/layer-modes-legacy/gimpoperationdividelegacy.h
index 3d01ab2..cd5589d 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdividelegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationdividelegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_DIVIDE_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DIVIDE_LEGACY (gimp_operation_divide_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationDivideLegacyClass GimpOperationDivideLegacyClass;
struct _GimpOperationDivideLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDivideLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_divide_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_divide_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_divide_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_divide_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DIVIDE_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.c
b/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.c
index 480a6eb..01b25f2 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.c
@@ -23,13 +23,13 @@
#include <gegl-plugin.h>
-#include "operations/operations-types.h"
+#include "../operations-types.h"
#include "gimpoperationdodgelegacy.h"
G_DEFINE_TYPE (GimpOperationDodgeLegacy, gimp_operation_dodge_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -64,9 +64,12 @@ gimp_operation_dodge_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.h
b/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.h
index 6d53efa..2eafabd 100644
--- a/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationdodgelegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_DODGE_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DODGE_LEGACY (gimp_operation_dodge_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationDodgeLegacyClass GimpOperationDodgeLegacyClass;
struct _GimpOperationDodgeLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDodgeLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_dodge_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_dodge_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_dodge_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_dodge_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DODGE_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.c
index f38d0e7..802fde2 100644
--- a/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.c
@@ -27,8 +27,9 @@
#include "gimpoperationgrainextractlegacy.h"
+
G_DEFINE_TYPE (GimpOperationGrainExtractLegacy, gimp_operation_grain_extract_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -53,7 +54,6 @@ gimp_operation_grain_extract_legacy_init (GimpOperationGrainExtractLegacy *self)
{
}
-
gboolean
gimp_operation_grain_extract_legacy_process (GeglOperation *op,
void *in_p,
@@ -64,9 +64,12 @@ gimp_operation_grain_extract_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.h
index 2fe6c51..7c86455 100644
--- a/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationgrainextractlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_GRAIN_EXTRACT_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_GRAIN_EXTRACT_LEGACY (gimp_operation_grain_extract_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationGrainExtractLegacyClass GimpOperationGrainExtractLe
struct _GimpOperationGrainExtractLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationGrainExtractLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_grain_extract_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_grain_extract_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_grain_extract_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_grain_extract_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_GRAIN_EXTRACT_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.c
b/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.c
index c71e4fb..a5e0117 100644
--- a/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.c
@@ -27,8 +27,10 @@
#include "gimpoperationgrainmergelegacy.h"
+
G_DEFINE_TYPE (GimpOperationGrainMergeLegacy, gimp_operation_grain_merge_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static void
gimp_operation_grain_merge_legacy_class_init (GimpOperationGrainMergeLegacyClass *klass)
@@ -62,9 +64,12 @@ gimp_operation_grain_merge_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.h
b/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.h
index fdc4dc3..579f545 100644
--- a/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationgrainmergelegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_GRAIN_MERGE_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_GRAIN_MERGE_LEGACY (gimp_operation_grain_merge_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationGrainMergeLegacyClass GimpOperationGrainMergeLegacy
struct _GimpOperationGrainMergeLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationGrainMergeLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_grain_merge_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_grain_merge_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_grain_merge_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_grain_merge_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_GRAIN_MERGE_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.c
index 189448b..acc7798 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.c
@@ -29,7 +29,7 @@
G_DEFINE_TYPE (GimpOperationHardlightLegacy, gimp_operation_hardlight_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -55,18 +55,21 @@ gimp_operation_hardlight_legacy_init (GimpOperationHardlightLegacy *self)
}
gboolean
-gimp_operation_hardlight_legacy_process (GeglOperation *op,
- void *in_p,
- void *layer_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hardlight_legacy_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.h
index 0e15be1..1a82e95 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationhardlightlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_HARDLIGHT_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HARDLIGHT_LEGACY (gimp_operation_hardlight_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationHardlightLegacyClass GimpOperationHardlightLegacyCl
struct _GimpOperationHardlightLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHardlightLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hardlight_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hardlight_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hardlight_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hardlight_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HARDLIGHT_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.c
index 25f564b..1024fe9 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.c
@@ -31,8 +31,9 @@
#include "gimpoperationhsvcolorlegacy.h"
+
G_DEFINE_TYPE (GimpOperationHsvColorLegacy, gimp_operation_hsv_color_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -58,18 +59,21 @@ gimp_operation_hsv_color_legacy_init (GimpOperationHsvColorLegacy *self)
}
gboolean
-gimp_operation_hsv_color_legacy_process (GeglOperation *op,
- void *in_p,
- void *layer_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hsv_color_legacy_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.h
index 9ef93be..e34f4ca 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvcolorlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_HSV_COLOR_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_COLOR_LEGACY (gimp_operation_hsv_color_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationHsvColorLegacyClass GimpOperationHsvColorLegacyClas
struct _GimpOperationHsvColorLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvColorLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_color_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_color_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_color_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_color_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_COLOR_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.c
b/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.c
index ccfc631..863ee39 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.c
@@ -33,7 +33,7 @@
G_DEFINE_TYPE (GimpOperationHsvHueLegacy, gimp_operation_hsv_hue_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -68,9 +68,12 @@ gimp_operation_hsv_hue_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.h
b/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.h
index a1cf5dc..8f353b4 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvhuelegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_HSV_HUE_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_HUE_LEGACY (gimp_operation_hsv_hue_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationHsvHueLegacyClass GimpOperationHsvHueLegacyClass;
struct _GimpOperationHsvHueLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvHueLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_hue_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_hue_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_hue_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_hue_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_HUE_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.c
index 029fab1..9d8d18c 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.c
@@ -33,7 +33,7 @@
G_DEFINE_TYPE (GimpOperationHsvSaturationLegacy, gimp_operation_hsv_saturation_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -68,9 +68,12 @@ gimp_operation_hsv_saturation_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.h
index 5fb2459..71cc96e 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvsaturationlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_HSV_SATURATION_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_SATURATION_LEGACY (gimp_operation_hsv_saturation_legacy_get_type
())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationHsvSaturationLegacyClass GimpOperationHsvSaturation
struct _GimpOperationHsvSaturationLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvSaturationLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_saturation_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_saturation_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_saturation_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_saturation_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_SATURATION_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.c
b/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.c
index 9aa369d..5091dfa 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.c
@@ -31,8 +31,9 @@
#include "gimpoperationhsvvaluelegacy.h"
+
G_DEFINE_TYPE (GimpOperationHsvValueLegacy, gimp_operation_hsv_value_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -58,18 +59,21 @@ gimp_operation_hsv_value_legacy_init (GimpOperationHsvValueLegacy *self)
}
gboolean
-gimp_operation_hsv_value_legacy_process (GeglOperation *op,
- void *in_p,
- void *layer_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hsv_value_legacy_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.h
b/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.h
index bbef81c..439c22f 100644
--- a/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationhsvvaluelegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_HSV_VALUE_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_VALUE_LEGACY (gimp_operation_hsv_value_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationHsvValueLegacyClass GimpOperationHsvValueLegacyClas
struct _GimpOperationHsvValueLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvValueLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_value_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_value_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_value_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_value_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_VALUE_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.c
b/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.c
index 3a555ae..a696aca 100644
--- a/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.c
@@ -29,7 +29,7 @@
G_DEFINE_TYPE (GimpOperationLightenOnlyLegacy, gimp_operation_lighten_only_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -64,9 +64,12 @@ gimp_operation_lighten_only_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.h
b/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.h
index 9b6ada2..d9570af 100644
--- a/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationlightenonlylegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_LIGHTEN_ONLY_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LIGHTEN_ONLY_LEGACY (gimp_operation_lighten_only_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationLightenOnlyLegacyClass GimpOperationLightenOnlyLega
struct _GimpOperationLightenOnlyLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLightenOnlyLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_lighten_only_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_lighten_only_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_lighten_only_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_lighten_only_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_LIGHTEN_ONLY_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.c
b/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.c
index 6445752..74e59a0 100644
--- a/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.c
@@ -27,8 +27,9 @@
#include "gimpoperationmultiplylegacy.h"
+
G_DEFINE_TYPE (GimpOperationMultiplyLegacy, gimp_operation_multiply_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -54,19 +55,21 @@ gimp_operation_multiply_legacy_init (GimpOperationMultiplyLegacy *self)
}
gboolean
-gimp_operation_multiply_legacy_process (GeglOperation *op,
- void *in_p,
- void *layer_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_multiply_legacy_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
-
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.h
b/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.h
index dbeb9cd..70779a5 100644
--- a/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationmultiplylegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_MULTIPLY_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_MULTIPLY_LEGACY (gimp_operation_multiply_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationMultiplyLegacyClass GimpOperationMultiplyLegacyClas
struct _GimpOperationMultiplyLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationMultiplyLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_multiply_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_multiply_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_multiply_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_multiply_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_MULTIPLY_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.c
index 88e4402..e8ed506 100644
--- a/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.c
@@ -27,8 +27,9 @@
#include "gimpoperationscreenlegacy.h"
+
G_DEFINE_TYPE (GimpOperationScreenLegacy, gimp_operation_screen_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -63,9 +64,12 @@ gimp_operation_screen_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.h
index 5a16a59..f8d0830 100644
--- a/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationscreenlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_SCREEN_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SCREEN_LEGACY (gimp_operation_screen_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationScreenLegacyClass GimpOperationScreenLegacyClass;
struct _GimpOperationScreenLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationScreenLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_screen_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_screen_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_screen_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_screen_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_SCREEN_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.c
index 55cd819..4a65354 100644
--- a/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.c
@@ -27,12 +27,14 @@
#include "gimpoperationsoftlightlegacy.h"
+
G_DEFINE_TYPE (GimpOperationSoftlightLegacy, gimp_operation_softlight_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static const gchar* reference_xml = "<?xml version='1.0' encoding='UTF-8'?>"
"<gegl>"
-"<node operation='gimp:softlight-mode'>"
+"<node operation='gimp:softlight-legacy'>"
" <node operation='gegl:load'>"
" <params>"
" <param name='path'>B.png</param>"
@@ -81,9 +83,12 @@ gimp_operation_softlight_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.h
index d760e41..77516bb 100644
--- a/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationsoftlightlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_SOFTLIGHT_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SOFTLIGHT_LEGACY (gimp_operation_softlight_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationSoftlightLegacyClass GimpOperationSoftlightLegacyCl
struct _GimpOperationSoftlightLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSoftlightLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_softlight_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_softlight_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_softlight_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_softlight_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_SOFTLIGHT_LEGACY_H__ */
diff --git a/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.c
b/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.c
index a19d070..5e11adf 100644
--- a/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.c
+++ b/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.c
@@ -27,8 +27,10 @@
#include "gimpoperationsubtractlegacy.h"
+
G_DEFINE_TYPE (GimpOperationSubtractLegacy, gimp_operation_subtract_legacy,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static void
gimp_operation_subtract_legacy_class_init (GimpOperationSubtractLegacyClass *klass)
@@ -52,7 +54,6 @@ gimp_operation_subtract_legacy_init (GimpOperationSubtractLegacy *self)
{
}
-
gboolean
gimp_operation_subtract_legacy_process (GeglOperation *op,
void *in_p,
@@ -63,9 +64,12 @@ gimp_operation_subtract_legacy_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *out = out_p, *layer = layer_p, *mask = mask_p;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
while (samples--)
{
diff --git a/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.h
b/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.h
index ff39e0e..ba1021b 100644
--- a/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.h
+++ b/app/operations/layer-modes-legacy/gimpoperationsubtractlegacy.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_SUBTRACT_LEGACY_H__
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SUBTRACT_LEGACY (gimp_operation_subtract_legacy_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationSubtractLegacyClass GimpOperationSubtractLegacyClas
struct _GimpOperationSubtractLegacy
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSubtractLegacyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_subtract_legacy_get_type (void) G_GNUC_CONST;
+GType gimp_operation_subtract_legacy_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_subtract_legacy_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_subtract_legacy_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_SUBTRACT_LEGACY_H__ */
diff --git a/app/operations/layer-modes/Makefile.am b/app/operations/layer-modes/Makefile.am
index 2f4d531..5559930 100644
--- a/app/operations/layer-modes/Makefile.am
+++ b/app/operations/layer-modes/Makefile.am
@@ -18,8 +18,8 @@ noinst_LIBRARIES = \
libapplayermodes.a
libapplayermodes_generic_a_sources = \
- gimpoperationpointlayermode.c \
- gimpoperationpointlayermode.h \
+ gimpoperationlayermode.c \
+ gimpoperationlayermode.h \
gimplayermodefunctions.c \
gimplayermodefunctions.h \
gimpblendcomposite.h \
diff --git a/app/operations/layer-modes/gimpblendcomposite.h b/app/operations/layer-modes/gimpblendcomposite.h
index c57bbd5..c0b6769 100644
--- a/app/operations/layer-modes/gimpblendcomposite.h
+++ b/app/operations/layer-modes/gimpblendcomposite.h
@@ -211,12 +211,11 @@ gimp_composite_blend (gpointer op,
glong samples,
GimpBlendFunc blend_func)
{
- GimpOperationPointLayerMode *layer_mode = op;
-
- gfloat opacity = layer_mode->opacity;
- GimpLayerColorSpace blend_trc = layer_mode->blend_trc;
- GimpLayerColorSpace composite_trc = layer_mode->composite_trc;
- GimpLayerCompositeMode composite_mode = layer_mode->composite_mode;
+ GimpOperationLayerMode *layer_mode = op;
+ gfloat opacity = layer_mode->opacity;
+ GimpLayerColorSpace blend_trc = layer_mode->blend_trc;
+ GimpLayerColorSpace composite_trc = layer_mode->composite_trc;
+ GimpLayerCompositeMode composite_mode = layer_mode->composite_mode;
gfloat *blend_in = in;
gfloat *blend_layer = layer;
diff --git a/app/operations/layer-modes/gimpoperationaddition.c
b/app/operations/layer-modes/gimpoperationaddition.c
index c915dd6..a7f2b51 100644
--- a/app/operations/layer-modes/gimpoperationaddition.c
+++ b/app/operations/layer-modes/gimpoperationaddition.c
@@ -29,8 +29,9 @@
#include "gimpoperationaddition.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationAddition, gimp_operation_addition,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -65,6 +66,8 @@ gimp_operation_addition_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- gimp_composite_blend (op, in, layer, mask, out, samples, blendfun_addition);
+ gimp_composite_blend (op, in, layer, mask, out, samples,
+ blendfun_addition);
+
return TRUE;
}
diff --git a/app/operations/layer-modes/gimpoperationaddition.h
b/app/operations/layer-modes/gimpoperationaddition.h
index 4772ff7..53d23cb 100644
--- a/app/operations/layer-modes/gimpoperationaddition.h
+++ b/app/operations/layer-modes/gimpoperationaddition.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_ADDITION_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ADDITION (gimp_operation_addition_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationAdditionClass GimpOperationAdditionClass;
struct _GimpOperationAddition
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationAdditionClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_addition_get_type (void) G_GNUC_CONST;
+GType gimp_operation_addition_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_addition_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_addition_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_ADDITION_H__ */
diff --git a/app/operations/layer-modes/gimpoperationantierase.c
b/app/operations/layer-modes/gimpoperationantierase.c
index c968707..2cb408d 100644
--- a/app/operations/layer-modes/gimpoperationantierase.c
+++ b/app/operations/layer-modes/gimpoperationantierase.c
@@ -27,8 +27,9 @@
#include "gimpoperationantierase.h"
+
G_DEFINE_TYPE (GimpOperationAntiErase, gimp_operation_anti_erase,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -54,18 +55,22 @@ gimp_operation_anti_erase_init (GimpOperationAntiErase *self)
}
gboolean
-gimp_operation_anti_erase_process (GeglOperation *op,
- void *in_p,
- void *layer_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_anti_erase_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- gfloat *out = out_p, *in = in_p, *layer = layer_p, *mask = mask_p;
- gfloat opacity = ((GimpOperationPointLayerMode*)(op))->opacity;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
diff --git a/app/operations/layer-modes/gimpoperationantierase.h
b/app/operations/layer-modes/gimpoperationantierase.h
index 77d3303..8e275fe 100644
--- a/app/operations/layer-modes/gimpoperationantierase.h
+++ b/app/operations/layer-modes/gimpoperationantierase.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_ANTI_ERASE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ANTI_ERASE (gimp_operation_anti_erase_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationAntiEraseClass GimpOperationAntiEraseClass;
struct _GimpOperationAntiErase
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationAntiEraseClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_anti_erase_get_type (void) G_GNUC_CONST;
+GType gimp_operation_anti_erase_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_anti_erase_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_anti_erase_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_ANTI_ERASE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationbehind.c
b/app/operations/layer-modes/gimpoperationbehind.c
index 788d492..92c9590 100644
--- a/app/operations/layer-modes/gimpoperationbehind.c
+++ b/app/operations/layer-modes/gimpoperationbehind.c
@@ -27,8 +27,9 @@
#include "gimpoperationbehind.h"
+
G_DEFINE_TYPE (GimpOperationBehind, gimp_operation_behind,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -63,9 +64,13 @@ gimp_operation_behind_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- gfloat opacity = ((GimpOperationPointLayerMode *)(op))->opacity;
- gfloat *in = in_p, *layer = layer_p, *mask = mask_p, *out = out_p;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
diff --git a/app/operations/layer-modes/gimpoperationbehind.h
b/app/operations/layer-modes/gimpoperationbehind.h
index da9f274..17b4f64 100644
--- a/app/operations/layer-modes/gimpoperationbehind.h
+++ b/app/operations/layer-modes/gimpoperationbehind.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_BEHIND_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_BEHIND (gimp_operation_behind_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationBehindClass GimpOperationBehindClass;
struct _GimpOperationBehind
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationBehindClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_behind_get_type (void) G_GNUC_CONST;
+GType gimp_operation_behind_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_behind_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_behind_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_BEHIND_H__ */
diff --git a/app/operations/layer-modes/gimpoperationburn.c b/app/operations/layer-modes/gimpoperationburn.c
index 7adb3ee..943a959 100644
--- a/app/operations/layer-modes/gimpoperationburn.c
+++ b/app/operations/layer-modes/gimpoperationburn.c
@@ -29,8 +29,9 @@
#include "gimpoperationburn.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationBurn, gimp_operation_burn,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -55,7 +56,6 @@ gimp_operation_burn_init (GimpOperationBurn *self)
{
}
-
gboolean
gimp_operation_burn_process (GeglOperation *operation,
void *in,
diff --git a/app/operations/layer-modes/gimpoperationburn.h b/app/operations/layer-modes/gimpoperationburn.h
index 6fad8e1..08db05f 100644
--- a/app/operations/layer-modes/gimpoperationburn.h
+++ b/app/operations/layer-modes/gimpoperationburn.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_BURN_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_BURN (gimp_operation_burn_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationBurnClass GimpOperationBurnClass;
struct _GimpOperationBurn
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationBurnClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_burn_get_type (void) G_GNUC_CONST;
+GType gimp_operation_burn_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_burn_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_burn_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_BURN_H__ */
diff --git a/app/operations/layer-modes/gimpoperationcolorerase.c
b/app/operations/layer-modes/gimpoperationcolorerase.c
index faf99c1..9a855b5 100644
--- a/app/operations/layer-modes/gimpoperationcolorerase.c
+++ b/app/operations/layer-modes/gimpoperationcolorerase.c
@@ -31,8 +31,9 @@
#include "gimpoperationcolorerase.h"
+
G_DEFINE_TYPE (GimpOperationColorErase, gimp_operation_color_erase,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -67,10 +68,13 @@ gimp_operation_color_erase_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer) op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *layer = layer_p, *mask = mask_p, *out = out_p;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
diff --git a/app/operations/layer-modes/gimpoperationcolorerase.h
b/app/operations/layer-modes/gimpoperationcolorerase.h
index cee4154..64d0697 100644
--- a/app/operations/layer-modes/gimpoperationcolorerase.h
+++ b/app/operations/layer-modes/gimpoperationcolorerase.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_COLOR_ERASE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_COLOR_ERASE (gimp_operation_color_erase_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationColorEraseClass GimpOperationColorEraseClass;
struct _GimpOperationColorErase
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationColorEraseClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_color_erase_get_type (void) G_GNUC_CONST;
+GType gimp_operation_color_erase_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_color_erase_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_color_erase_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_COLOR_ERASE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationdarkenonly.c
b/app/operations/layer-modes/gimpoperationdarkenonly.c
index ab15d54..1565f27 100644
--- a/app/operations/layer-modes/gimpoperationdarkenonly.c
+++ b/app/operations/layer-modes/gimpoperationdarkenonly.c
@@ -29,8 +29,9 @@
#include "gimpoperationdarkenonly.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationDarkenOnly, gimp_operation_darken_only,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -56,14 +57,14 @@ gimp_operation_darken_only_init (GimpOperationDarkenOnly *self)
}
gboolean
-gimp_operation_darken_only_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_darken_only_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_darken_only);
diff --git a/app/operations/layer-modes/gimpoperationdarkenonly.h
b/app/operations/layer-modes/gimpoperationdarkenonly.h
index 1407c9e..d964dc0 100644
--- a/app/operations/layer-modes/gimpoperationdarkenonly.h
+++ b/app/operations/layer-modes/gimpoperationdarkenonly.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_DARKEN_ONLY_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DARKEN_ONLY (gimp_operation_darken_only_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationDarkenOnlyClass GimpOperationDarkenOnlyClass;
struct _GimpOperationDarkenOnly
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDarkenOnlyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_darken_only_get_type (void) G_GNUC_CONST;
+GType gimp_operation_darken_only_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_darken_only_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_darken_only_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DARKEN_ONLY_H__ */
diff --git a/app/operations/layer-modes/gimpoperationdifference.c
b/app/operations/layer-modes/gimpoperationdifference.c
index 314cfa2..084c873 100644
--- a/app/operations/layer-modes/gimpoperationdifference.c
+++ b/app/operations/layer-modes/gimpoperationdifference.c
@@ -31,7 +31,7 @@
G_DEFINE_TYPE (GimpOperationDifference, gimp_operation_difference,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -57,14 +57,14 @@ gimp_operation_difference_init (GimpOperationDifference *self)
}
gboolean
-gimp_operation_difference_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_difference_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_difference);
diff --git a/app/operations/layer-modes/gimpoperationdifference.h
b/app/operations/layer-modes/gimpoperationdifference.h
index 3bbe3fd..0817368 100644
--- a/app/operations/layer-modes/gimpoperationdifference.h
+++ b/app/operations/layer-modes/gimpoperationdifference.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_DIFFERENCE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DIFFERENCE (gimp_operation_difference_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationDifferenceClass GimpOperationDifferenceClass;
struct _GimpOperationDifference
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDifferenceClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_difference_get_type (void) G_GNUC_CONST;
+GType gimp_operation_difference_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_difference_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_difference_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DIFFERENCE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationdissolve.c
b/app/operations/layer-modes/gimpoperationdissolve.c
index 2992c5c..c71019d 100644
--- a/app/operations/layer-modes/gimpoperationdissolve.c
+++ b/app/operations/layer-modes/gimpoperationdissolve.c
@@ -33,7 +33,8 @@
G_DEFINE_TYPE (GimpOperationDissolve, gimp_operation_dissolve,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static gint32 random_table[RANDOM_TABLE_SIZE];
@@ -71,20 +72,23 @@ gimp_operation_dissolve_init (GimpOperationDissolve *self)
}
gboolean
-gimp_operation_dissolve_process (GeglOperation *op,
- void *in_p,
- void *aux_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *result,
- gint level)
+gimp_operation_dissolve_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *result,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer) op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *aux = aux_p, *mask = mask_p, *out = out_p;
- const gboolean has_mask = mask != NULL;
- gint x, y;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
+ gint x, y;
for (y = result->y; y < result->y + result->height; y++)
{
@@ -96,7 +100,7 @@ gimp_operation_dissolve_process (GeglOperation *op,
for (x = result->x; x < result->x + result->width; x++)
{
- gfloat value = aux[ALPHA] * opacity * 255;
+ gfloat value = layer[ALPHA] * opacity * 255;
if (has_mask)
value *= *mask;
@@ -110,19 +114,20 @@ gimp_operation_dissolve_process (GeglOperation *op,
}
else
{
- out[0] = aux[0];
- out[1] = aux[1];
- out[2] = aux[2];
+ out[0] = layer[0];
+ out[1] = layer[1];
+ out[2] = layer[2];
out[3] = 1.0;
}
- in += 4;
- out += 4;
- aux += 4;
+ in += 4;
+ layer += 4;
+ out += 4;
if (has_mask)
- mask ++;
+ mask++;
}
+
g_rand_free (gr);
}
diff --git a/app/operations/layer-modes/gimpoperationdissolve.h
b/app/operations/layer-modes/gimpoperationdissolve.h
index 7a07075..8b89ca1 100644
--- a/app/operations/layer-modes/gimpoperationdissolve.h
+++ b/app/operations/layer-modes/gimpoperationdissolve.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_DISSOLVE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DISSOLVE (gimp_operation_dissolve_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationDissolveClass GimpOperationDissolveClass;
struct _GimpOperationDissolveClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
struct _GimpOperationDissolve
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
-GType gimp_operation_dissolve_get_type (void) G_GNUC_CONST;
+GType gimp_operation_dissolve_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_dissolve_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *result,
- gint level);
+gboolean gimp_operation_dissolve_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *result,
+ gint level);
#endif /* __GIMP_OPERATION_DISSOLVE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationdivide.c
b/app/operations/layer-modes/gimpoperationdivide.c
index 150adc6..b7d11af 100644
--- a/app/operations/layer-modes/gimpoperationdivide.c
+++ b/app/operations/layer-modes/gimpoperationdivide.c
@@ -31,7 +31,7 @@
G_DEFINE_TYPE (GimpOperationDivide, gimp_operation_divide,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -57,15 +57,16 @@ gimp_operation_divide_init (GimpOperationDivide *self)
}
gboolean
-gimp_operation_divide_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_divide_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- gimp_composite_blend (op, in, layer, mask, out, samples, blendfun_divide);
+ gimp_composite_blend (op, in, layer, mask, out, samples,
+ blendfun_divide);
return TRUE;
}
diff --git a/app/operations/layer-modes/gimpoperationdivide.h
b/app/operations/layer-modes/gimpoperationdivide.h
index fd9d6de..70a6dab 100644
--- a/app/operations/layer-modes/gimpoperationdivide.h
+++ b/app/operations/layer-modes/gimpoperationdivide.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_DIVIDE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DIVIDE (gimp_operation_divide_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationDivideClass GimpOperationDivideClass;
struct _GimpOperationDivide
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDivideClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_divide_get_type (void) G_GNUC_CONST;
+GType gimp_operation_divide_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_divide_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_divide_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DIVIDE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationdodge.c b/app/operations/layer-modes/gimpoperationdodge.c
index 671fd93..2365cf1 100644
--- a/app/operations/layer-modes/gimpoperationdodge.c
+++ b/app/operations/layer-modes/gimpoperationdodge.c
@@ -31,7 +31,7 @@
G_DEFINE_TYPE (GimpOperationDodge, gimp_operation_dodge,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -66,6 +66,7 @@ gimp_operation_dodge_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- gimp_composite_blend (op, in, layer, mask, out, samples, blendfun_dodge);
+ gimp_composite_blend (op, in, layer, mask, out, samples,
+ blendfun_dodge);
return TRUE;
}
diff --git a/app/operations/layer-modes/gimpoperationdodge.h b/app/operations/layer-modes/gimpoperationdodge.h
index 648e5e3..8a8bfb2 100644
--- a/app/operations/layer-modes/gimpoperationdodge.h
+++ b/app/operations/layer-modes/gimpoperationdodge.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_DODGE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_DODGE (gimp_operation_dodge_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationDodgeClass GimpOperationDodgeClass;
struct _GimpOperationDodge
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationDodgeClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_dodge_get_type (void) G_GNUC_CONST;
+GType gimp_operation_dodge_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_dodge_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_dodge_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_DODGE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationerase.c b/app/operations/layer-modes/gimpoperationerase.c
index f305a5e..8b46cef 100644
--- a/app/operations/layer-modes/gimpoperationerase.c
+++ b/app/operations/layer-modes/gimpoperationerase.c
@@ -27,8 +27,9 @@
#include "gimpoperationerase.h"
+
G_DEFINE_TYPE (GimpOperationErase, gimp_operation_erase,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -54,19 +55,22 @@ gimp_operation_erase_init (GimpOperationErase *self)
}
gboolean
-gimp_operation_erase_process (GeglOperation *op,
- void *in_p,
- void *layer_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_erase_process (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *layer = layer_p, *mask = mask_p, *out = out_p;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
diff --git a/app/operations/layer-modes/gimpoperationerase.h b/app/operations/layer-modes/gimpoperationerase.h
index bb800c7..0d15ab1 100644
--- a/app/operations/layer-modes/gimpoperationerase.h
+++ b/app/operations/layer-modes/gimpoperationerase.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_ERASE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_ERASE (gimp_operation_erase_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationEraseClass GimpOperationEraseClass;
struct _GimpOperationErase
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationEraseClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_erase_get_type (void) G_GNUC_CONST;
+GType gimp_operation_erase_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_erase_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_erase_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_ERASE_MODE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationgrainextract.c
b/app/operations/layer-modes/gimpoperationgrainextract.c
index c26cd12..8e226c1 100644
--- a/app/operations/layer-modes/gimpoperationgrainextract.c
+++ b/app/operations/layer-modes/gimpoperationgrainextract.c
@@ -31,7 +31,7 @@
G_DEFINE_TYPE (GimpOperationGrainExtract, gimp_operation_grain_extract,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -57,14 +57,14 @@ gimp_operation_grain_extract_init (GimpOperationGrainExtract *self)
}
gboolean
-gimp_operation_grain_extract_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_grain_extract_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_grain_extract);
diff --git a/app/operations/layer-modes/gimpoperationgrainextract.h
b/app/operations/layer-modes/gimpoperationgrainextract.h
index bc15ffe..b3b2a75 100644
--- a/app/operations/layer-modes/gimpoperationgrainextract.h
+++ b/app/operations/layer-modes/gimpoperationgrainextract.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_GRAIN_EXTRACT_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_GRAIN_EXTRACT (gimp_operation_grain_extract_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationGrainExtractClass GimpOperationGrainExtractClass;
struct _GimpOperationGrainExtract
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationGrainExtractClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_grain_extract_get_type (void) G_GNUC_CONST;
+GType gimp_operation_grain_extract_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_grain_extract_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_grain_extract_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_GRAIN_EXTRACT_H__ */
diff --git a/app/operations/layer-modes/gimpoperationgrainmerge.c
b/app/operations/layer-modes/gimpoperationgrainmerge.c
index 67b702a..581daf3 100644
--- a/app/operations/layer-modes/gimpoperationgrainmerge.c
+++ b/app/operations/layer-modes/gimpoperationgrainmerge.c
@@ -29,8 +29,9 @@
#include "gimpoperationgrainmerge.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationGrainMerge, gimp_operation_grain_merge,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -56,14 +57,14 @@ gimp_operation_grain_merge_init (GimpOperationGrainMerge *self)
}
gboolean
-gimp_operation_grain_merge_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_grain_merge_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_grain_merge);
diff --git a/app/operations/layer-modes/gimpoperationgrainmerge.h
b/app/operations/layer-modes/gimpoperationgrainmerge.h
index e8123d5..b862ffa 100644
--- a/app/operations/layer-modes/gimpoperationgrainmerge.h
+++ b/app/operations/layer-modes/gimpoperationgrainmerge.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_GRAIN_MERGE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_GRAIN_MERGE (gimp_operation_grain_merge_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationGrainMergeClass GimpOperationGrainMergeClass;
struct _GimpOperationGrainMerge
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationGrainMergeClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_grain_merge_get_type (void) G_GNUC_CONST;
+GType gimp_operation_grain_merge_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_grain_merge_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_grain_merge_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_GRAIN_MERGE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationhardlight.c
b/app/operations/layer-modes/gimpoperationhardlight.c
index 965c332..bdb8e13 100644
--- a/app/operations/layer-modes/gimpoperationhardlight.c
+++ b/app/operations/layer-modes/gimpoperationhardlight.c
@@ -30,7 +30,7 @@
G_DEFINE_TYPE (GimpOperationHardlight, gimp_operation_hardlight,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -56,14 +56,14 @@ gimp_operation_hardlight_init (GimpOperationHardlight *self)
}
gboolean
-gimp_operation_hardlight_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hardlight_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_hardlight);
diff --git a/app/operations/layer-modes/gimpoperationhardlight.h
b/app/operations/layer-modes/gimpoperationhardlight.h
index 7a4af0d..3a39ac3 100644
--- a/app/operations/layer-modes/gimpoperationhardlight.h
+++ b/app/operations/layer-modes/gimpoperationhardlight.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_HARDLIGHT_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HARDLIGHT (gimp_operation_hardlight_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationHardlightClass GimpOperationHardlightClass;
struct _GimpOperationHardlight
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHardlightClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hardlight_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hardlight_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hardlight_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hardlight_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HARDLIGHT_H__ */
diff --git a/app/operations/layer-modes/gimpoperationhsvcolor.c
b/app/operations/layer-modes/gimpoperationhsvcolor.c
index 7612e5f..f59ecc6 100644
--- a/app/operations/layer-modes/gimpoperationhsvcolor.c
+++ b/app/operations/layer-modes/gimpoperationhsvcolor.c
@@ -35,7 +35,7 @@
G_DEFINE_TYPE (GimpOperationHsvColor, gimp_operation_hsv_color,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -61,14 +61,14 @@ gimp_operation_hsv_color_init (GimpOperationHsvColor *self)
}
gboolean
-gimp_operation_hsv_color_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hsv_color_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_hsv_color);
diff --git a/app/operations/layer-modes/gimpoperationhsvcolor.h
b/app/operations/layer-modes/gimpoperationhsvcolor.h
index a79b518..3314e3a 100644
--- a/app/operations/layer-modes/gimpoperationhsvcolor.h
+++ b/app/operations/layer-modes/gimpoperationhsvcolor.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_HSV_COLOR_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_COLOR (gimp_operation_hsv_color_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationHsvColorClass GimpOperationHsvColorClass;
struct _GimpOperationHsvColor
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvColorClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_color_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_color_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_color_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_color_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_COLOR_H__ */
diff --git a/app/operations/layer-modes/gimpoperationhsvhue.c
b/app/operations/layer-modes/gimpoperationhsvhue.c
index e38ce10..3a05aa5 100644
--- a/app/operations/layer-modes/gimpoperationhsvhue.c
+++ b/app/operations/layer-modes/gimpoperationhsvhue.c
@@ -33,8 +33,9 @@
#include "gimpoperationhsvhue.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationHsvHue, gimp_operation_hsv_hue,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
diff --git a/app/operations/layer-modes/gimpoperationhsvhue.h
b/app/operations/layer-modes/gimpoperationhsvhue.h
index 8c6df24..8c32280 100644
--- a/app/operations/layer-modes/gimpoperationhsvhue.h
+++ b/app/operations/layer-modes/gimpoperationhsvhue.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_HSV_HUE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_HUE (gimp_operation_hsv_hue_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationHsvHueClass GimpOperationHsvHueClass;
struct _GimpOperationHsvHue
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvHueClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_hue_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_hue_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_hue_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_hue_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_HUE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationhsvsaturation.c
b/app/operations/layer-modes/gimpoperationhsvsaturation.c
index 29ddf22..ca51f47 100644
--- a/app/operations/layer-modes/gimpoperationhsvsaturation.c
+++ b/app/operations/layer-modes/gimpoperationhsvsaturation.c
@@ -33,8 +33,10 @@
#include "gimpoperationhsvsaturation.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationHsvSaturation, gimp_operation_hsv_saturation,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static void
gimp_operation_hsv_saturation_class_init (GimpOperationHsvSaturationClass *klass)
@@ -59,14 +61,14 @@ gimp_operation_hsv_saturation_init (GimpOperationHsvSaturation *self)
}
gboolean
-gimp_operation_hsv_saturation_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hsv_saturation_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_hsv_saturation);
diff --git a/app/operations/layer-modes/gimpoperationhsvsaturation.h
b/app/operations/layer-modes/gimpoperationhsvsaturation.h
index d838ca9..33a7073 100644
--- a/app/operations/layer-modes/gimpoperationhsvsaturation.h
+++ b/app/operations/layer-modes/gimpoperationhsvsaturation.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_HSV_SATURATION_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_SATURATION (gimp_operation_hsv_saturation_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationHsvSaturationClass GimpOperationHsvSaturationClass;
struct _GimpOperationHsvSaturation
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvSaturationClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_saturation_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_saturation_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_saturation_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_saturation_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_SATURATION_H__ */
diff --git a/app/operations/layer-modes/gimpoperationhsvvalue.c
b/app/operations/layer-modes/gimpoperationhsvvalue.c
index c2dd25d..14a4a82 100644
--- a/app/operations/layer-modes/gimpoperationhsvvalue.c
+++ b/app/operations/layer-modes/gimpoperationhsvvalue.c
@@ -35,7 +35,7 @@
G_DEFINE_TYPE (GimpOperationHsvValue, gimp_operation_hsv_value,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -61,14 +61,14 @@ gimp_operation_hsv_value_init (GimpOperationHsvValue *self)
}
gboolean
-gimp_operation_hsv_value_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_hsv_value_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_hsv_value);
diff --git a/app/operations/layer-modes/gimpoperationhsvvalue.h
b/app/operations/layer-modes/gimpoperationhsvvalue.h
index f5bf94e..408ab0b 100644
--- a/app/operations/layer-modes/gimpoperationhsvvalue.h
+++ b/app/operations/layer-modes/gimpoperationhsvvalue.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_HSV_VALUE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_HSV_VALUE (gimp_operation_hsv_value_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationHsvValueClass GimpOperationHsvValueClass;
struct _GimpOperationHsvValue
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationHsvValueClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_hsv_value_get_type (void) G_GNUC_CONST;
+GType gimp_operation_hsv_value_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_hsv_value_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_hsv_value_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_HSV_VALUE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationpointlayermode.c
b/app/operations/layer-modes/gimpoperationlayermode.c
similarity index 62%
rename from app/operations/layer-modes/gimpoperationpointlayermode.c
rename to app/operations/layer-modes/gimpoperationlayermode.c
index fc23b04..1f6e391 100644
--- a/app/operations/layer-modes/gimpoperationpointlayermode.c
+++ b/app/operations/layer-modes/gimpoperationlayermode.c
@@ -1,7 +1,7 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
- * gimpoperationpointlayermode.c
+ * gimpoperationlayermode.c
* Copyright (C) 2008 Michael Natterer <mitch gimp org>
* Copyright (C) 2008 Martin Nordholts <martinn svn gnome org>
*
@@ -29,7 +29,7 @@
#include "../operations-types.h"
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
enum
@@ -43,27 +43,27 @@ enum
};
-static void gimp_operation_point_layer_mode_set_property (GObject *object,
- guint property_id,
- const GValue *value,
- GParamSpec *pspec);
-static void gimp_operation_point_layer_mode_get_property (GObject *object,
- guint property_id,
- GValue *value,
- GParamSpec *pspec);
+static void gimp_operation_layer_mode_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gimp_operation_layer_mode_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
-static void gimp_operation_point_layer_mode_prepare (GeglOperation *operation);
-static gboolean gimp_operation_point_layer_mode_process (GeglOperation *operation,
- GeglOperationContext *context,
- const gchar *output_prop,
- const GeglRectangle *result,
- gint level);
+static void gimp_operation_layer_mode_prepare (GeglOperation *operation);
+static gboolean gimp_operation_layer_mode_process (GeglOperation *operation,
+ GeglOperationContext *context,
+ const gchar *output_prop,
+ const GeglRectangle *result,
+ gint level);
-G_DEFINE_TYPE (GimpOperationPointLayerMode, gimp_operation_point_layer_mode,
+G_DEFINE_TYPE (GimpOperationLayerMode, gimp_operation_layer_mode,
GEGL_TYPE_OPERATION_POINT_COMPOSER3)
-#define parent_class gimp_operation_point_layer_mode_parent_class
+#define parent_class gimp_operation_layer_mode_parent_class
const Babl *_gimp_fish_rgba_to_perceptual = NULL;
@@ -75,16 +75,16 @@ const Babl *_gimp_fish_laba_to_perceptual = NULL;
static void
-gimp_operation_point_layer_mode_class_init (GimpOperationPointLayerModeClass *klass)
+gimp_operation_layer_mode_class_init (GimpOperationLayerModeClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
- object_class->set_property = gimp_operation_point_layer_mode_set_property;
- object_class->get_property = gimp_operation_point_layer_mode_get_property;
+ object_class->set_property = gimp_operation_layer_mode_set_property;
+ object_class->get_property = gimp_operation_layer_mode_get_property;
- operation_class->prepare = gimp_operation_point_layer_mode_prepare;
- operation_class->process = gimp_operation_point_layer_mode_process;
+ operation_class->prepare = gimp_operation_layer_mode_prepare;
+ operation_class->process = gimp_operation_layer_mode_process;
g_object_class_install_property (object_class, PROP_LINEAR,
g_param_spec_boolean ("linear",
@@ -125,29 +125,27 @@ gimp_operation_point_layer_mode_class_init (GimpOperationPointLayerModeClass *kl
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
- if (_gimp_fish_rgba_to_perceptual == NULL)
- {
- _gimp_fish_rgba_to_perceptual = babl_fish ("RGBA float", "R'G'B'A float");
- _gimp_fish_perceptual_to_rgba = babl_fish ("R'G'B'A float", "RGBA float");
- _gimp_fish_perceptual_to_laba = babl_fish ("R'G'B'A float", "CIE Lab alpha float");
- _gimp_fish_rgba_to_laba = babl_fish ("RGBA float", "CIE Lab alpha float");
- _gimp_fish_laba_to_rgba = babl_fish ("CIE Lab alpha float", "RGBA float");
- _gimp_fish_laba_to_perceptual = babl_fish ("CIE Lab alpha float", "R'G'B'A float");
- }
+ _gimp_fish_rgba_to_perceptual = babl_fish ("RGBA float", "R'G'B'A float");
+ _gimp_fish_perceptual_to_rgba = babl_fish ("R'G'B'A float", "RGBA float");
+ _gimp_fish_perceptual_to_laba = babl_fish ("R'G'B'A float", "CIE Lab alpha float");
+
+ _gimp_fish_rgba_to_laba = babl_fish ("RGBA float", "CIE Lab alpha float");
+ _gimp_fish_laba_to_rgba = babl_fish ("CIE Lab alpha float", "RGBA float");
+ _gimp_fish_laba_to_perceptual = babl_fish ("CIE Lab alpha float", "R'G'B'A float");
}
static void
-gimp_operation_point_layer_mode_init (GimpOperationPointLayerMode *self)
+gimp_operation_layer_mode_init (GimpOperationLayerMode *self)
{
}
static void
-gimp_operation_point_layer_mode_set_property (GObject *object,
- guint property_id,
- const GValue *value,
- GParamSpec *pspec)
+gimp_operation_layer_mode_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- GimpOperationPointLayerMode *self = GIMP_OPERATION_POINT_LAYER_MODE (object);
+ GimpOperationLayerMode *self = GIMP_OPERATION_LAYER_MODE (object);
switch (property_id)
{
@@ -178,12 +176,12 @@ gimp_operation_point_layer_mode_set_property (GObject *object,
}
static void
-gimp_operation_point_layer_mode_get_property (GObject *object,
- guint property_id,
- GValue *value,
- GParamSpec *pspec)
+gimp_operation_layer_mode_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GimpOperationPointLayerMode *self = GIMP_OPERATION_POINT_LAYER_MODE (object);
+ GimpOperationLayerMode *self = GIMP_OPERATION_LAYER_MODE (object);
switch (property_id)
{
@@ -214,10 +212,10 @@ gimp_operation_point_layer_mode_get_property (GObject *object,
}
static void
-gimp_operation_point_layer_mode_prepare (GeglOperation *operation)
+gimp_operation_layer_mode_prepare (GeglOperation *operation)
{
- GimpOperationPointLayerMode *self = GIMP_OPERATION_POINT_LAYER_MODE (operation);
- const Babl *format;
+ GimpOperationLayerMode *self = GIMP_OPERATION_LAYER_MODE (operation);
+ const Babl *format;
if (self->linear)
format = babl_format ("RGBA float");
@@ -231,15 +229,13 @@ gimp_operation_point_layer_mode_prepare (GeglOperation *operation)
}
static gboolean
-gimp_operation_point_layer_mode_process (GeglOperation *operation,
- GeglOperationContext *context,
- const gchar *output_prop,
- const GeglRectangle *result,
- gint level)
+gimp_operation_layer_mode_process (GeglOperation *operation,
+ GeglOperationContext *context,
+ const gchar *output_prop,
+ const GeglRectangle *result,
+ gint level)
{
- GimpOperationPointLayerMode *point;
-
- point = GIMP_OPERATION_POINT_LAYER_MODE (operation);
+ GimpOperationLayerMode *point = GIMP_OPERATION_LAYER_MODE (operation);
if (point->opacity == 0.0 ||
! gegl_operation_context_get_object (context, "aux"))
diff --git a/app/operations/layer-modes/gimpoperationlayermode.h
b/app/operations/layer-modes/gimpoperationlayermode.h
new file mode 100644
index 0000000..4976529
--- /dev/null
+++ b/app/operations/layer-modes/gimpoperationlayermode.h
@@ -0,0 +1,59 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpoperationlayermode.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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GIMP_OPERATION_LAYER_MODE_H__
+#define __GIMP_OPERATION_LAYER_MODE_H__
+
+
+#include <gegl-plugin.h>
+
+
+#define GIMP_TYPE_OPERATION_LAYER_MODE (gimp_operation_layer_mode_get_type ())
+#define GIMP_OPERATION_LAYER_MODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),
GIMP_TYPE_OPERATION_LAYER_MODE, GimpOperationLayerMode))
+#define GIMP_OPERATION_LAYER_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),
GIMP_TYPE_OPERATION_LAYER_MODE, GimpOperationLayerModeClass))
+#define GIMP_IS_OPERATION_LAYER_MODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),
GIMP_TYPE_OPERATION_LAYER_MODE))
+#define GIMP_IS_OPERATION_LAYER_MODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),
GIMP_TYPE_OPERATION_LAYER_MODE))
+#define GIMP_OPERATION_LAYER_MODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),
GIMP_TYPE_OPERATION_LAYER_MODE, GimpOperationLayerModeClass))
+
+
+typedef struct _GimpOperationLayerModeClass GimpOperationLayerModeClass;
+
+struct _GimpOperationLayerModeClass
+{
+ GeglOperationPointComposer3Class parent_class;
+};
+
+struct _GimpOperationLayerMode
+{
+ GeglOperationPointComposer3 parent_instance;
+
+ gboolean linear;
+ gdouble opacity;
+ GimpLayerColorSpace blend_trc;
+ GimpLayerColorSpace composite_trc;
+ GimpLayerCompositeMode composite_mode;
+ GimpBlendFunc blend_func;
+};
+
+
+GType gimp_operation_layer_mode_get_type (void) G_GNUC_CONST;
+
+
+#endif /* __GIMP_OPERATION_LAYER_MODE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationlchchroma.c
b/app/operations/layer-modes/gimpoperationlchchroma.c
index 4503046..6a9cccd 100644
--- a/app/operations/layer-modes/gimpoperationlchchroma.c
+++ b/app/operations/layer-modes/gimpoperationlchchroma.c
@@ -30,10 +30,9 @@
#include "gimpoperationlchchroma.h"
#include "gimpblendcomposite.h"
-G_DEFINE_TYPE (GimpOperationLchChroma, gimp_operation_lch_chroma,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
-#define parent_class gimp_operation_lch_chroma_parent_class
+G_DEFINE_TYPE (GimpOperationLchChroma, gimp_operation_lch_chroma,
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -61,14 +60,14 @@ gimp_operation_lch_chroma_init (GimpOperationLchChroma *self)
}
gboolean
-gimp_operation_lch_chroma_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_lch_chroma_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_lch_chroma);
diff --git a/app/operations/layer-modes/gimpoperationlchchroma.h
b/app/operations/layer-modes/gimpoperationlchchroma.h
index 67a1d63..52d850d 100644
--- a/app/operations/layer-modes/gimpoperationlchchroma.h
+++ b/app/operations/layer-modes/gimpoperationlchchroma.h
@@ -24,7 +24,7 @@
#define __GIMP_OPERATION_LCH_CHROMA_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LCH_CHROMA (gimp_operation_lch_chroma_get_type ())
@@ -40,25 +40,25 @@ typedef struct _GimpOperationLchChromaClass GimpOperationLchChromaClass;
struct _GimpOperationLchChroma
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLchChromaClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_lch_chroma_get_type (void) G_GNUC_CONST;
+GType gimp_operation_lch_chroma_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_lch_chroma_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_lch_chroma_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_LCH_CHROMA_H__ */
diff --git a/app/operations/layer-modes/gimpoperationlchcolor.c
b/app/operations/layer-modes/gimpoperationlchcolor.c
index cc37eee..d64cd6d 100644
--- a/app/operations/layer-modes/gimpoperationlchcolor.c
+++ b/app/operations/layer-modes/gimpoperationlchcolor.c
@@ -30,10 +30,9 @@
#include "gimpoperationlchcolor.h"
#include "gimpblendcomposite.h"
-G_DEFINE_TYPE (GimpOperationLchColor, gimp_operation_lch_color,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
-#define parent_class gimp_operation_lch_color_parent_class
+G_DEFINE_TYPE (GimpOperationLchColor, gimp_operation_lch_color,
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -61,14 +60,14 @@ gimp_operation_lch_color_init (GimpOperationLchColor *self)
}
gboolean
-gimp_operation_lch_color_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_lch_color_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_lch_color);
diff --git a/app/operations/layer-modes/gimpoperationlchcolor.h
b/app/operations/layer-modes/gimpoperationlchcolor.h
index 84c9dd8..ca0007d 100644
--- a/app/operations/layer-modes/gimpoperationlchcolor.h
+++ b/app/operations/layer-modes/gimpoperationlchcolor.h
@@ -24,7 +24,7 @@
#define __GIMP_OPERATION_LCH_COLOR_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LCH_COLOR (gimp_operation_lch_color_get_type ())
@@ -40,25 +40,25 @@ typedef struct _GimpOperationLchColorClass GimpOperationLchColorClass;
struct _GimpOperationLchColor
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLchColorClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_lch_color_get_type (void) G_GNUC_CONST;
+GType gimp_operation_lch_color_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_lch_color_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_lch_color_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_LCH_COLOR_H__ */
diff --git a/app/operations/layer-modes/gimpoperationlchhue.c
b/app/operations/layer-modes/gimpoperationlchhue.c
index 32bf3e9..0545554 100644
--- a/app/operations/layer-modes/gimpoperationlchhue.c
+++ b/app/operations/layer-modes/gimpoperationlchhue.c
@@ -30,10 +30,9 @@
#include "gimpoperationlchhue.h"
#include "gimpblendcomposite.h"
-G_DEFINE_TYPE (GimpOperationLchHue, gimp_operation_lch_hue,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
-#define parent_class gimp_operation_lch_hue_parent_class
+G_DEFINE_TYPE (GimpOperationLchHue, gimp_operation_lch_hue,
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
diff --git a/app/operations/layer-modes/gimpoperationlchhue.h
b/app/operations/layer-modes/gimpoperationlchhue.h
index d3e3487..c692a89 100644
--- a/app/operations/layer-modes/gimpoperationlchhue.h
+++ b/app/operations/layer-modes/gimpoperationlchhue.h
@@ -24,7 +24,7 @@
#define __GIMP_OPERATION_LCH_HUE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LCH_HUE (gimp_operation_lch_hue_get_type ())
@@ -40,24 +40,25 @@ typedef struct _GimpOperationLchHueClass GimpOperationLchHueClass;
struct _GimpOperationLchHue
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLchHueClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_lch_hue_get_type (void) G_GNUC_CONST;
+GType gimp_operation_lch_hue_get_type (void) G_GNUC_CONST;
+
+gboolean gimp_operation_lch_hue_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
-gboolean gimp_operation_lch_hue_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
#endif /* __GIMP_OPERATION_LCH_HUE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationlchlightness.c
b/app/operations/layer-modes/gimpoperationlchlightness.c
index 3743a53..ee83a0f 100644
--- a/app/operations/layer-modes/gimpoperationlchlightness.c
+++ b/app/operations/layer-modes/gimpoperationlchlightness.c
@@ -30,10 +30,9 @@
#include "gimpoperationlchlightness.h"
#include "gimpblendcomposite.h"
-G_DEFINE_TYPE (GimpOperationLchLightness, gimp_operation_lch_lightness,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
-#define parent_class gimp_operation_lch_lightness_parent_class
+G_DEFINE_TYPE (GimpOperationLchLightness, gimp_operation_lch_lightness,
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -61,14 +60,14 @@ gimp_operation_lch_lightness_init (GimpOperationLchLightness *self)
}
gboolean
-gimp_operation_lch_lightness_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_lch_lightness_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_lch_lightness);
diff --git a/app/operations/layer-modes/gimpoperationlchlightness.h
b/app/operations/layer-modes/gimpoperationlchlightness.h
index 7fcd814..e862b4b 100644
--- a/app/operations/layer-modes/gimpoperationlchlightness.h
+++ b/app/operations/layer-modes/gimpoperationlchlightness.h
@@ -24,7 +24,7 @@
#define __GIMP_OPERATION_LCH_LIGHTNESS_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LCH_LIGHTNESS (gimp_operation_lch_lightness_get_type ())
@@ -40,25 +40,25 @@ typedef struct _GimpOperationLchLightnessClass GimpOperationLchLightnessClass;
struct _GimpOperationLchLightness
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLchLightnessClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_lch_lightness_get_type (void) G_GNUC_CONST;
+GType gimp_operation_lch_lightness_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_lch_lightness_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_lch_lightness_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_LCH_LIGHTNESS_H__ */
diff --git a/app/operations/layer-modes/gimpoperationlightenonly.c
b/app/operations/layer-modes/gimpoperationlightenonly.c
index 2fd0cfc..bc4dfa0 100644
--- a/app/operations/layer-modes/gimpoperationlightenonly.c
+++ b/app/operations/layer-modes/gimpoperationlightenonly.c
@@ -29,8 +29,9 @@
#include "gimpoperationlightenonly.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationLightenOnly, gimp_operation_lighten_only,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
diff --git a/app/operations/layer-modes/gimpoperationlightenonly.h
b/app/operations/layer-modes/gimpoperationlightenonly.h
index 779be0b..fe8c785 100644
--- a/app/operations/layer-modes/gimpoperationlightenonly.h
+++ b/app/operations/layer-modes/gimpoperationlightenonly.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_LIGHTEN_ONLY_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_LIGHTEN_ONLY (gimp_operation_lighten_only_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationLightenOnlyClass GimpOperationLightenOnlyClass;
struct _GimpOperationLightenOnly
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationLightenOnlyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_lighten_only_get_type (void) G_GNUC_CONST;
+GType gimp_operation_lighten_only_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_lighten_only_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_lighten_only_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_LIGHTEN_ONLY_H__ */
diff --git a/app/operations/layer-modes/gimpoperationmultiply.c
b/app/operations/layer-modes/gimpoperationmultiply.c
index a87ed30..383d477 100644
--- a/app/operations/layer-modes/gimpoperationmultiply.c
+++ b/app/operations/layer-modes/gimpoperationmultiply.c
@@ -24,13 +24,15 @@
#include <gegl-plugin.h>
-#include "operations/operations-types.h"
+#include "../operations-types.h"
#include "gimpoperationmultiply.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationMultiply, gimp_operation_multiply,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static void
gimp_operation_multiply_class_init (GimpOperationMultiplyClass *klass)
@@ -55,14 +57,14 @@ gimp_operation_multiply_init (GimpOperationMultiply *self)
}
gboolean
-gimp_operation_multiply_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_multiply_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
gimp_composite_blend (op, in, layer, mask, out, samples,
blendfun_multiply);
diff --git a/app/operations/layer-modes/gimpoperationmultiply.h
b/app/operations/layer-modes/gimpoperationmultiply.h
index 5ee76fa..5e83669 100644
--- a/app/operations/layer-modes/gimpoperationmultiply.h
+++ b/app/operations/layer-modes/gimpoperationmultiply.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_MULTIPLY_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_MULTIPLY (gimp_operation_multiply_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationMultiplyClass GimpOperationMultiplyClass;
struct _GimpOperationMultiply
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationMultiplyClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_multiply_get_type (void) G_GNUC_CONST;
+GType gimp_operation_multiply_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_multiply_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_multiply_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_MULTIPLY_H__ */
diff --git a/app/operations/layer-modes/gimpoperationnormal-sse2.c
b/app/operations/layer-modes/gimpoperationnormal-sse2.c
index 9e3b048..b6ab493 100644
--- a/app/operations/layer-modes/gimpoperationnormal-sse2.c
+++ b/app/operations/layer-modes/gimpoperationnormal-sse2.c
@@ -28,18 +28,19 @@
#if COMPILE_SSE2_INTRINISICS
+
/* SSE2 */
#include <emmintrin.h>
gboolean
-gimp_operation_normal_process_sse2 (GeglOperation *operation,
- void *in,
- void *aux,
- void *mask_p,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_normal_process_sse2 (GeglOperation *operation,
+ void *in,
+ void *aux,
+ void *mask_p,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
/* check alignment */
if ((((uintptr_t)in) | ((uintptr_t)aux) | ((uintptr_t)out)) & 0x0F)
@@ -50,7 +51,7 @@ gimp_operation_normal_process_sse2 (GeglOperation *operation,
}
else
{
- gfloat opacity = ((GimpOperationPointLayerMode*)(operation))->opacity;
+ gfloat opacity = ((GimpOperationLayerMode *)(operation))->opacity;
gfloat *mask = mask_p;
const __v4sf *v_in = (const __v4sf*) in;
const __v4sf *v_aux = (const __v4sf*) aux;
@@ -116,4 +117,5 @@ gimp_operation_normal_process_sse2 (GeglOperation *operation,
return TRUE;
}
+
#endif /* COMPILE_SSE2_INTRINISICS */
diff --git a/app/operations/layer-modes/gimpoperationnormal-sse4.c
b/app/operations/layer-modes/gimpoperationnormal-sse4.c
index 890a4ed..1e91c06 100644
--- a/app/operations/layer-modes/gimpoperationnormal-sse4.c
+++ b/app/operations/layer-modes/gimpoperationnormal-sse4.c
@@ -28,18 +28,19 @@
#if COMPILE_SSE4_1_INTRINISICS
+
/* SSE4 */
#include <smmintrin.h>
gboolean
-gimp_operation_normal_process_sse4 (GeglOperation *operation,
- void *in,
- void *aux,
- void *mask_p,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_normal_process_sse4 (GeglOperation *operation,
+ void *in,
+ void *aux,
+ void *mask_p,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
/* check alignment */
if ((((uintptr_t)in) | ((uintptr_t)aux) | ((uintptr_t)out)) & 0x0F)
@@ -51,7 +52,7 @@ gimp_operation_normal_process_sse4 (GeglOperation *operation,
}
else
{
- gfloat opacity = ((GimpOperationPointLayerMode*)(operation))->opacity;
+ gfloat opacity = ((GimpOperationLayerMode *)(operation))->opacity;
gfloat *mask = mask_p;
const __v4sf *v_in = (const __v4sf*) in;
const __v4sf *v_aux = (const __v4sf*) aux;
@@ -116,4 +117,5 @@ gimp_operation_normal_process_sse4 (GeglOperation *operation,
return TRUE;
}
+
#endif /* COMPILE_SSE4_1_INTRINISICS */
diff --git a/app/operations/layer-modes/gimpoperationnormal.c
b/app/operations/layer-modes/gimpoperationnormal.c
index 9ffa9c9..3495497 100644
--- a/app/operations/layer-modes/gimpoperationnormal.c
+++ b/app/operations/layer-modes/gimpoperationnormal.c
@@ -25,7 +25,7 @@
#include "libgimpbase/gimpbase.h"
-#include "operations/operations-types.h"
+#include "../operations-types.h"
#include "gimpoperationnormal.h"
@@ -37,7 +37,7 @@ static gboolean gimp_operation_normal_parent_process (GeglOperation *oper
gint level);
G_DEFINE_TYPE (GimpOperationNormal, gimp_operation_normal,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
#define parent_class gimp_operation_normal_parent_class
@@ -107,11 +107,9 @@ gimp_operation_normal_parent_process (GeglOperation *operation,
const GeglRectangle *result,
gint level)
{
- GimpOperationPointLayerMode *point;
+ GimpOperationLayerMode *layer_mode = GIMP_OPERATION_LAYER_MODE (operation);
- point = GIMP_OPERATION_POINT_LAYER_MODE (operation);
-
- if (point->opacity == 1.0 &&
+ if (layer_mode->opacity == 1.0 &&
! gegl_operation_context_get_object (context, "aux2"))
{
const GeglRectangle *in_extent = NULL;
@@ -156,39 +154,42 @@ gimp_operation_normal_parent_process (GeglOperation *operation,
}
gboolean
-gimp_operation_normal_process_core (GeglOperation *operation,
- void *in_p,
- void *aux_p,
- void *mask_p,
- void *out_p,
- glong samples,
- const GeglRectangle *roi,
- gint level)
+gimp_operation_normal_process_core (GeglOperation *op,
+ void *in_p,
+ void *layer_p,
+ void *mask_p,
+ void *out_p,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)operation;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *aux = aux_p, *mask = mask_p, *out = out_p;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
- gfloat aux_alpha;
+ gfloat layer_alpha;
- aux_alpha = aux[ALPHA] * opacity;
+ layer_alpha = layer[ALPHA] * opacity;
if (has_mask)
- aux_alpha *= *mask;
+ layer_alpha *= *mask;
- out[ALPHA] = aux_alpha + in[ALPHA] - aux_alpha * in[ALPHA];
+ out[ALPHA] = layer_alpha + in[ALPHA] - layer_alpha * in[ALPHA];
if (out[ALPHA])
{
- gfloat aux_weight = aux_alpha / out[ALPHA];
- gfloat in_weight = 1.0f - aux_weight;
+ gfloat layer_weight = layer_alpha / out[ALPHA];
+ gfloat in_weight = 1.0f - layer_weight;
gint b;
for (b = RED; b < ALPHA; b++)
{
- out[b] = aux[b] * aux_weight + in[b] * in_weight;
+ out[b] = layer[b] * layer_weight + in[b] * in_weight;
}
}
else
@@ -201,9 +202,9 @@ gimp_operation_normal_process_core (GeglOperation *operation,
}
}
- in += 4;
- aux += 4;
- out += 4;
+ in += 4;
+ layer += 4;
+ out += 4;
if (has_mask)
mask++;
diff --git a/app/operations/layer-modes/gimpoperationnormal.h
b/app/operations/layer-modes/gimpoperationnormal.h
index 5ecbd49..3a3e0d0 100644
--- a/app/operations/layer-modes/gimpoperationnormal.h
+++ b/app/operations/layer-modes/gimpoperationnormal.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_NORMAL_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_NORMAL (gimp_operation_normal_get_type ())
@@ -38,45 +38,45 @@ typedef struct _GimpOperationNormalClass GimpOperationNormalClass;
struct _GimpOperationNormal
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationNormalClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_normal_get_type (void) G_GNUC_CONST;
+GType gimp_operation_normal_get_type (void) G_GNUC_CONST;
extern GimpLayerModeFunc gimp_operation_normal_process;
-gboolean gimp_operation_normal_process_core (GeglOperation *op,
- void *in,
- void *aux,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
-
-gboolean gimp_operation_normal_process_sse2 (GeglOperation *op,
- void *in,
- void *aux,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
-
-gboolean gimp_operation_normal_process_sse4 (GeglOperation *op,
- void *in,
- void *aux,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_normal_process_core (GeglOperation *op,
+ void *in,
+ void *aux,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
+
+gboolean gimp_operation_normal_process_sse2 (GeglOperation *op,
+ void *in,
+ void *aux,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
+
+gboolean gimp_operation_normal_process_sse4 (GeglOperation *op,
+ void *in,
+ void *aux,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_NORMAL_H__ */
diff --git a/app/operations/layer-modes/gimpoperationoverlay.c
b/app/operations/layer-modes/gimpoperationoverlay.c
index c849eea..c8de849 100644
--- a/app/operations/layer-modes/gimpoperationoverlay.c
+++ b/app/operations/layer-modes/gimpoperationoverlay.c
@@ -28,8 +28,9 @@
#include "gimpoperationoverlay.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationOverlay, gimp_operation_overlay,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
diff --git a/app/operations/layer-modes/gimpoperationoverlay.h
b/app/operations/layer-modes/gimpoperationoverlay.h
index 01e6319..23f4824 100644
--- a/app/operations/layer-modes/gimpoperationoverlay.h
+++ b/app/operations/layer-modes/gimpoperationoverlay.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_OVERLAY_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_OVERLAY (gimp_operation_overlay_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationOverlayClass GimpOperationOverlayClass;
struct _GimpOperationOverlay
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationOverlayClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_overlay_get_type (void) G_GNUC_CONST;
+GType gimp_operation_overlay_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_overlay_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_overlay_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_OVERLAY_H__ */
diff --git a/app/operations/layer-modes/gimpoperationreplace.c
b/app/operations/layer-modes/gimpoperationreplace.c
index 145f38b..2b1597d 100644
--- a/app/operations/layer-modes/gimpoperationreplace.c
+++ b/app/operations/layer-modes/gimpoperationreplace.c
@@ -26,8 +26,9 @@
#include "gimpoperationreplace.h"
+
G_DEFINE_TYPE (GimpOperationReplace, gimp_operation_replace,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
@@ -62,10 +63,13 @@ gimp_operation_replace_process (GeglOperation *op,
const GeglRectangle *roi,
gint level)
{
- GimpOperationPointLayerMode *layer_mode = (gpointer)op;
- gfloat opacity = layer_mode->opacity;
- gfloat *in = in_p, *layer = layer_p, *mask = mask_p, *out = out_p;
- const gboolean has_mask = mask != NULL;
+ GimpOperationLayerMode *layer_mode = (gpointer) op;
+ gfloat *in = in_p;
+ gfloat *out = out_p;
+ gfloat *layer = layer_p;
+ gfloat *mask = mask_p;
+ gfloat opacity = layer_mode->opacity;
+ const gboolean has_mask = mask != NULL;
while (samples--)
{
diff --git a/app/operations/layer-modes/gimpoperationreplace.h
b/app/operations/layer-modes/gimpoperationreplace.h
index d4b52de..37d30fa 100644
--- a/app/operations/layer-modes/gimpoperationreplace.h
+++ b/app/operations/layer-modes/gimpoperationreplace.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_REPLACE_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_REPLACE (gimp_operation_replace_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationReplaceClass GimpOperationReplaceClass;
struct _GimpOperationReplace
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationReplaceClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_replace_get_type (void) G_GNUC_CONST;
+GType gimp_operation_replace_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_replace_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_replace_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_REPLACE_H__ */
diff --git a/app/operations/layer-modes/gimpoperationscreen.c
b/app/operations/layer-modes/gimpoperationscreen.c
index a1d5273..ed7f786 100644
--- a/app/operations/layer-modes/gimpoperationscreen.c
+++ b/app/operations/layer-modes/gimpoperationscreen.c
@@ -29,8 +29,9 @@
#include "gimpoperationscreen.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationScreen, gimp_operation_screen,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
diff --git a/app/operations/layer-modes/gimpoperationscreen.h
b/app/operations/layer-modes/gimpoperationscreen.h
index 2acb443..af8cd99 100644
--- a/app/operations/layer-modes/gimpoperationscreen.h
+++ b/app/operations/layer-modes/gimpoperationscreen.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_SCREEN_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SCREEN (gimp_operation_screen_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationScreenClass GimpOperationScreenClass;
struct _GimpOperationScreen
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationScreenClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_screen_get_type (void) G_GNUC_CONST;
+GType gimp_operation_screen_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_screen_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_screen_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_SCREEN_H__ */
diff --git a/app/operations/layer-modes/gimpoperationsoftlight.c
b/app/operations/layer-modes/gimpoperationsoftlight.c
index 15c56bd..9676ce5 100644
--- a/app/operations/layer-modes/gimpoperationsoftlight.c
+++ b/app/operations/layer-modes/gimpoperationsoftlight.c
@@ -28,8 +28,10 @@
#include "gimpoperationsoftlight.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationSoftlight, gimp_operation_softlight,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
+
static const gchar* reference_xml = "<?xml version='1.0' encoding='UTF-8'?>"
"<gegl>"
@@ -72,7 +74,6 @@ gimp_operation_softlight_init (GimpOperationSoftlight *self)
{
}
-
gboolean
gimp_operation_softlight_process (GeglOperation *op,
void *in,
diff --git a/app/operations/layer-modes/gimpoperationsoftlight.h
b/app/operations/layer-modes/gimpoperationsoftlight.h
index ddd8ae4..46fb35b 100644
--- a/app/operations/layer-modes/gimpoperationsoftlight.h
+++ b/app/operations/layer-modes/gimpoperationsoftlight.h
@@ -22,7 +22,7 @@
#define __GIMP_OPERATION_SOFTLIGHT_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SOFTLIGHT (gimp_operation_softlight_get_type ())
@@ -38,25 +38,25 @@ typedef struct _GimpOperationSoftlightClass GimpOperationSoftlightClass;
struct _GimpOperationSoftlight
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSoftlightClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_softlight_get_type (void) G_GNUC_CONST;
+GType gimp_operation_softlight_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_softlight_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_softlight_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_SOFTLIGHT_H__ */
diff --git a/app/operations/layer-modes/gimpoperationsubtract.c
b/app/operations/layer-modes/gimpoperationsubtract.c
index 5ac9acc..6e0d250 100644
--- a/app/operations/layer-modes/gimpoperationsubtract.c
+++ b/app/operations/layer-modes/gimpoperationsubtract.c
@@ -29,8 +29,9 @@
#include "gimpoperationsubtract.h"
#include "gimpblendcomposite.h"
+
G_DEFINE_TYPE (GimpOperationSubtract, gimp_operation_subtract,
- GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+ GIMP_TYPE_OPERATION_LAYER_MODE)
static void
diff --git a/app/operations/layer-modes/gimpoperationsubtract.h
b/app/operations/layer-modes/gimpoperationsubtract.h
index 14c53f4..306550b 100644
--- a/app/operations/layer-modes/gimpoperationsubtract.h
+++ b/app/operations/layer-modes/gimpoperationsubtract.h
@@ -23,7 +23,7 @@
#define __GIMP_OPERATION_SUBTRACT_H__
-#include "gimpoperationpointlayermode.h"
+#include "gimpoperationlayermode.h"
#define GIMP_TYPE_OPERATION_SUBTRACT (gimp_operation_subtract_get_type ())
@@ -39,25 +39,25 @@ typedef struct _GimpOperationSubtractClass GimpOperationSubtractClass;
struct _GimpOperationSubtract
{
- GimpOperationPointLayerMode parent_instance;
+ GimpOperationLayerMode parent_instance;
};
struct _GimpOperationSubtractClass
{
- GimpOperationPointLayerModeClass parent_class;
+ GimpOperationLayerModeClass parent_class;
};
-GType gimp_operation_subtract_get_type (void) G_GNUC_CONST;
+GType gimp_operation_subtract_get_type (void) G_GNUC_CONST;
-gboolean gimp_operation_subtract_process (GeglOperation *op,
- void *in,
- void *layer,
- void *mask,
- void *out,
- glong samples,
- const GeglRectangle *roi,
- gint level);
+gboolean gimp_operation_subtract_process (GeglOperation *op,
+ void *in,
+ void *layer,
+ void *mask,
+ void *out,
+ glong samples,
+ const GeglRectangle *roi,
+ gint level);
#endif /* __GIMP_OPERATION_SUBTRACT_H__ */
diff --git a/app/operations/operations-types.h b/app/operations/operations-types.h
index ebee4cd..b1ca7b7 100644
--- a/app/operations/operations-types.h
+++ b/app/operations/operations-types.h
@@ -31,7 +31,7 @@
/* operations */
typedef struct _GimpOperationPointFilter GimpOperationPointFilter;
-typedef struct _GimpOperationPointLayerMode GimpOperationPointLayerMode;
+typedef struct _GimpOperationLayerMode GimpOperationLayerMode;
/* operation config objects */
diff --git a/app/paint/gimppaintcore-loops.c b/app/paint/gimppaintcore-loops.c
index f3c160d..8be68a5 100644
--- a/app/paint/gimppaintcore-loops.c
+++ b/app/paint/gimppaintcore-loops.c
@@ -26,7 +26,7 @@
#include "core/gimptempbuf.h"
#include "operations/layer-modes/gimplayermodefunctions.h"
-#include "operations/layer-modes/gimpoperationpointlayermode.h"
+#include "operations/layer-modes/gimpoperationlayermode.h"
#include "gimppaintcore-loops.h"
@@ -352,16 +352,18 @@ do_layer_blend (GeglBuffer *src_buffer,
while (gegl_buffer_iterator_next (iter))
{
- gfloat *out_pixel = (gfloat *)iter->data[0];
- gfloat *in_pixel = (gfloat *)iter->data[1];
- gfloat *mask_pixel = NULL;
- gfloat *paint_pixel = paint_data + ((iter->roi[0].y - roi.y) * paint_stride + iter->roi[0].x - roi.x)
* 4;
- int iy;
- GimpOperationPointLayerMode layer_data;
-
- layer_data.opacity = opacity;
- layer_data.blend_trc = blend_trc;
- layer_data.composite_trc = composite_trc;
+ GimpOperationLayerMode layer_data;
+ gfloat *out_pixel = (gfloat *) iter->data[0];
+ gfloat *in_pixel = (gfloat *) iter->data[1];
+ gfloat *mask_pixel = NULL;
+ gfloat *paint_pixel;
+ gint iy;
+
+ paint_pixel = paint_data + ((iter->roi[0].y - roi.y) * paint_stride + iter->roi[0].x - roi.x) * 4;
+
+ layer_data.opacity = opacity;
+ layer_data.blend_trc = blend_trc;
+ layer_data.composite_trc = composite_trc;
layer_data.composite_mode = composite_mode;
if (mask_buffer)
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
