[gimp] app: code cleanup in the GEGL ops



commit 53bda86cebb56ae70d851681c3584b6cbfe918ab
Author: Michael Natterer <mitch gimp org>
Date:   Sat Apr 21 00:46:48 2012 +0200

    app: code cleanup in the GEGL ops

 app/gegl/gimpoperationadditionmode.c       |    6 +-
 app/gegl/gimpoperationantierasemode.c      |    6 +-
 app/gegl/gimpoperationbehindmode.c         |    6 +-
 app/gegl/gimpoperationborder.c             |   10 ++--
 app/gegl/gimpoperationbrightnesscontrast.c |    8 ++--
 app/gegl/gimpoperationburnmode.c           |    8 ++--
 app/gegl/gimpoperationcagecoefcalc.c       |   64 ++++++++++++++-------------
 app/gegl/gimpoperationcagetransform.c      |    8 ++--
 app/gegl/gimpoperationcolorbalance.c       |   10 ++--
 app/gegl/gimpoperationcolorerasemode.c     |    6 +-
 app/gegl/gimpoperationcolorize.c           |   10 ++--
 app/gegl/gimpoperationcolormode.c          |    6 +-
 app/gegl/gimpoperationcurves.c             |   10 ++--
 app/gegl/gimpoperationdarkenonlymode.c     |   11 +++--
 app/gegl/gimpoperationdesaturate.c         |   10 ++--
 app/gegl/gimpoperationdifferencemode.c     |    6 +-
 app/gegl/gimpoperationdissolvemode.c       |   25 ++++++-----
 app/gegl/gimpoperationdividemode.c         |    6 +-
 app/gegl/gimpoperationdodgemode.c          |    8 ++--
 app/gegl/gimpoperationequalize.c           |   42 +++++++++---------
 app/gegl/gimpoperationerasemode.c          |    6 +-
 app/gegl/gimpoperationgrainextractmode.c   |    6 +-
 app/gegl/gimpoperationgrainmergemode.c     |    6 +-
 app/gegl/gimpoperationgrow.c               |   51 +++++++++++-----------
 app/gegl/gimpoperationhardlightmode.c      |    6 +-
 app/gegl/gimpoperationhuemode.c            |    6 +-
 app/gegl/gimpoperationhuesaturation.c      |   10 ++--
 app/gegl/gimpoperationlevels.c             |   10 ++--
 app/gegl/gimpoperationlightenonlymode.c    |   11 +++--
 app/gegl/gimpoperationmultiplymode.c       |    8 ++--
 app/gegl/gimpoperationnormalmode.c         |    6 +-
 app/gegl/gimpoperationoverlaymode.c        |   11 +++--
 app/gegl/gimpoperationpointfilter.c        |    4 +-
 app/gegl/gimpoperationposterize.c          |   10 ++--
 app/gegl/gimpoperationreplacemode.c        |    6 +-
 app/gegl/gimpoperationsaturationmode.c     |    6 +-
 app/gegl/gimpoperationscreenmode.c         |    8 ++--
 app/gegl/gimpoperationsetalpha.c           |   46 ++++++++++----------
 app/gegl/gimpoperationshapeburst.c         |   10 ++--
 app/gegl/gimpoperationshrink.c             |   51 +++++++++++-----------
 app/gegl/gimpoperationsoftlightmode.c      |   11 +++--
 app/gegl/gimpoperationsubtractmode.c       |    6 +-
 app/gegl/gimpoperationthreshold.c          |   10 ++--
 app/gegl/gimpoperationvaluemode.c          |    6 +-
 44 files changed, 292 insertions(+), 285 deletions(-)
---
diff --git a/app/gegl/gimpoperationadditionmode.c b/app/gegl/gimpoperationadditionmode.c
index 2685faa..a483b10 100644
--- a/app/gegl/gimpoperationadditionmode.c
+++ b/app/gegl/gimpoperationadditionmode.c
@@ -53,9 +53,9 @@ gimp_operation_addition_mode_class_init (GimpOperationAdditionModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:addition-mode",
-           "description", "GIMP addition mode operation",
-           NULL);
+                                 "name",        "gimp:addition-mode",
+                                 "description", "GIMP addition mode operation",
+                                 NULL);
 
   point_class->process     = gimp_operation_addition_mode_process;
   operation_class->prepare = gimp_operation_addition_mode_prepare;
diff --git a/app/gegl/gimpoperationantierasemode.c b/app/gegl/gimpoperationantierasemode.c
index 23e5302..c4cbf9c 100644
--- a/app/gegl/gimpoperationantierasemode.c
+++ b/app/gegl/gimpoperationantierasemode.c
@@ -51,9 +51,9 @@ gimp_operation_anti_erase_mode_class_init (GimpOperationAntiEraseModeClass *klas
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:anti-erase-mode",
-           "description", "GIMP anti erase mode operation",
-           NULL);
+                                 "name",        "gimp:anti-erase-mode",
+                                 "description", "GIMP anti erase mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_anti_erase_mode_process;
 }
diff --git a/app/gegl/gimpoperationbehindmode.c b/app/gegl/gimpoperationbehindmode.c
index 266c491..cb2fa0d 100644
--- a/app/gegl/gimpoperationbehindmode.c
+++ b/app/gegl/gimpoperationbehindmode.c
@@ -51,9 +51,9 @@ gimp_operation_behind_mode_class_init (GimpOperationBehindModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:behind-mode",
-           "description", "GIMP behind mode operation",
-           NULL);
+                                 "name",        "gimp:behind-mode",
+                                 "description", "GIMP behind mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_behind_mode_process;
 }
diff --git a/app/gegl/gimpoperationborder.c b/app/gegl/gimpoperationborder.c
index 0789cee..5db75e7 100644
--- a/app/gegl/gimpoperationborder.c
+++ b/app/gegl/gimpoperationborder.c
@@ -83,16 +83,16 @@ gimp_operation_border_class_init (GimpOperationBorderClass *klass)
   object_class->get_property   = gimp_operation_border_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-      "name"        , "gimp:border",
-      "categories"  , "gimp",
-      "description" , "GIMP Border operation",
-      NULL);
+                                 "name",        "gimp:border",
+                                 "categories",  "gimp",
+                                 "description", "GIMP Border operation",
+                                 NULL);
 
   operation_class->prepare                 = gimp_operation_border_prepare;
   operation_class->get_required_for_output = gimp_operation_border_get_required_for_output;
   operation_class->get_cached_region       = gimp_operation_border_get_cached_region;
 
-  filter_class->process        = gimp_operation_border_process;
+  filter_class->process                    = gimp_operation_border_process;
 
   g_object_class_install_property (object_class, PROP_RADIUS_X,
                                    g_param_spec_int ("radius-x",
diff --git a/app/gegl/gimpoperationbrightnesscontrast.c b/app/gegl/gimpoperationbrightnesscontrast.c
index cba57b5..74fd8a8 100644
--- a/app/gegl/gimpoperationbrightnesscontrast.c
+++ b/app/gegl/gimpoperationbrightnesscontrast.c
@@ -57,10 +57,10 @@ gimp_operation_brightness_contrast_class_init (GimpOperationBrightnessContrastCl
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-                  "name"       , "gimp:brightness-contrast",
-                  "categories" , "color",
-                  "description", "GIMP Brightness-Contrast operation",
-                  NULL);
+                                 "name",        "gimp:brightness-contrast",
+                                 "categories",  "color",
+                                 "description", "GIMP Brightness-Contrast operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_brightness_contrast_process;
 
diff --git a/app/gegl/gimpoperationburnmode.c b/app/gegl/gimpoperationburnmode.c
index 6893faf..5bf4ed3 100644
--- a/app/gegl/gimpoperationburnmode.c
+++ b/app/gegl/gimpoperationburnmode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationburnmode.h"
 
 
-static void gimp_operation_burn_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_burn_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_burn_mode_process (GeglOperation       *operation,
                                                   void                *in_buf,
                                                   void                *aux_buf,
@@ -53,9 +53,9 @@ gimp_operation_burn_mode_class_init (GimpOperationBurnModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:burn-mode",
-           "description", "GIMP burn mode operation",
-           NULL);
+                                 "name",        "gimp:burn-mode",
+                                 "description", "GIMP burn mode operation",
+                                 NULL);
 
   point_class->process     = gimp_operation_burn_mode_process;
   operation_class->prepare = gimp_operation_burn_mode_prepare;
diff --git a/app/gegl/gimpoperationcagecoefcalc.c b/app/gegl/gimpoperationcagecoefcalc.c
index d11c3de..1172145 100644
--- a/app/gegl/gimpoperationcagecoefcalc.c
+++ b/app/gegl/gimpoperationcagecoefcalc.c
@@ -30,21 +30,23 @@
 
 #include "gimp-intl.h"
 
-static void           gimp_operation_cage_coef_calc_prepare           (GeglOperation        *operation);
-static void           gimp_operation_cage_coef_calc_finalize          (GObject              *object);
-static void           gimp_operation_cage_coef_calc_get_property      (GObject              *object,
-                                                                       guint                 property_id,
-                                                                       GValue               *value,
-                                                                       GParamSpec           *pspec);
-static void           gimp_operation_cage_coef_calc_set_property      (GObject              *object,
-                                                                       guint                 property_id,
-                                                                       const GValue         *value,
-                                                                       GParamSpec           *pspec);
-static GeglRectangle  gimp_operation_cage_coef_calc_get_bounding_box  (GeglOperation        *operation);
-static gboolean       gimp_operation_cage_coef_calc_process           (GeglOperation        *operation,
-                                                                       GeglBuffer           *output,
-                                                                       const GeglRectangle  *roi,
-                                                                       gint                  level);
+
+static void           gimp_operation_cage_coef_calc_finalize         (GObject              *object);
+static void           gimp_operation_cage_coef_calc_get_property     (GObject              *object,
+                                                                      guint                 property_id,
+                                                                      GValue               *value,
+                                                                      GParamSpec           *pspec);
+static void           gimp_operation_cage_coef_calc_set_property     (GObject              *object,
+                                                                      guint                 property_id,
+                                                                      const GValue         *value,
+                                                                      GParamSpec           *pspec);
+
+static void           gimp_operation_cage_coef_calc_prepare          (GeglOperation        *operation);
+static GeglRectangle  gimp_operation_cage_coef_calc_get_bounding_box (GeglOperation        *operation);
+static gboolean       gimp_operation_cage_coef_calc_process          (GeglOperation        *operation,
+                                                                      GeglBuffer           *output,
+                                                                      const GeglRectangle  *roi,
+                                                                      gint                  level);
 
 
 G_DEFINE_TYPE (GimpOperationCageCoefCalc, gimp_operation_cage_coef_calc,
@@ -61,10 +63,10 @@ gimp_operation_cage_coef_calc_class_init (GimpOperationCageCoefCalcClass *klass)
   GeglOperationClass       *operation_class = GEGL_OPERATION_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-                  "name"              , "gimp:cage-coef-calc",
-                  "categories"        , "transform",
-                  "description"       , _("Compute a set of coefficient buffer for the GIMP cage tool"),
-                  NULL);
+                                 "name",        "gimp:cage-coef-calc",
+                                 "categories",  "transform",
+                                 "description", _("Compute a set of coefficient buffer for the GIMP cage tool"),
+                                 NULL);
 
   operation_class->prepare            = gimp_operation_cage_coef_calc_prepare;
   operation_class->get_bounding_box   = gimp_operation_cage_coef_calc_get_bounding_box;
@@ -93,18 +95,6 @@ gimp_operation_cage_coef_calc_init (GimpOperationCageCoefCalc *self)
 }
 
 static void
-gimp_operation_cage_coef_calc_prepare (GeglOperation *operation)
-{
-  GimpOperationCageCoefCalc *occc   = GIMP_OPERATION_CAGE_COEF_CALC (operation);
-  GimpCageConfig            *config = GIMP_CAGE_CONFIG (occc->config);
-
-  gegl_operation_set_format (operation,
-                             "output",
-                             babl_format_n (babl_type ("float"),
-                                            2 * gimp_cage_config_get_n_points (config)));
-}
-
-static void
 gimp_operation_cage_coef_calc_finalize (GObject *object)
 {
   GimpOperationCageCoefCalc *self = GIMP_OPERATION_CAGE_COEF_CALC (object);
@@ -181,6 +171,18 @@ gimp_operation_cage_coef_calc_is_on_straight (GimpVector2 *d1,
   return (deter < 0.000000001) && (deter > -0.000000001);
 }
 
+static void
+gimp_operation_cage_coef_calc_prepare (GeglOperation *operation)
+{
+  GimpOperationCageCoefCalc *occc   = GIMP_OPERATION_CAGE_COEF_CALC (operation);
+  GimpCageConfig            *config = GIMP_CAGE_CONFIG (occc->config);
+
+  gegl_operation_set_format (operation,
+                             "output",
+                             babl_format_n (babl_type ("float"),
+                                            2 * gimp_cage_config_get_n_points (config)));
+}
+
 static GeglRectangle
 gimp_operation_cage_coef_calc_get_bounding_box (GeglOperation *operation)
 {
diff --git a/app/gegl/gimpoperationcagetransform.c b/app/gegl/gimpoperationcagetransform.c
index edc1f01..7f7a2a0 100644
--- a/app/gegl/gimpoperationcagetransform.c
+++ b/app/gegl/gimpoperationcagetransform.c
@@ -100,10 +100,10 @@ gimp_operation_cage_transform_class_init (GimpOperationCageTransformClass *klass
   object_class->finalize                   = gimp_operation_cage_transform_finalize;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"                   , "gimp:cage-transform",
-           "categories"             , "transform",
-           "description"            , _("Convert a set of coefficient buffer to a coordinate buffer for the GIMP cage tool"),
-           NULL);
+                                 "name",        "gimp:cage-transform",
+                                 "categories",  "transform",
+                                 "description", _("Convert a set of coefficient buffer to a coordinate buffer for the GIMP cage tool"),
+                                 NULL);
 
   operation_class->prepare                 = gimp_operation_cage_transform_prepare;
 
diff --git a/app/gegl/gimpoperationcolorbalance.c b/app/gegl/gimpoperationcolorbalance.c
index 0cbfda9..d04380c 100644
--- a/app/gegl/gimpoperationcolorbalance.c
+++ b/app/gegl/gimpoperationcolorbalance.c
@@ -57,12 +57,12 @@ gimp_operation_color_balance_class_init (GimpOperationColorBalanceClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-                  "name"       , "gimp:color-balance",
-                  "categories" , "color",
-                  "description", "GIMP Color Balance operation",
-                  NULL);
+                                 "name",        "gimp:color-balance",
+                                 "categories",  "color",
+                                 "description", "GIMP Color Balance operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_color_balance_process;
+  point_class->process = gimp_operation_color_balance_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationcolorerasemode.c b/app/gegl/gimpoperationcolorerasemode.c
index 0efc05f..cc8addf 100644
--- a/app/gegl/gimpoperationcolorerasemode.c
+++ b/app/gegl/gimpoperationcolorerasemode.c
@@ -51,9 +51,9 @@ gimp_operation_color_erase_mode_class_init (GimpOperationColorEraseModeClass *kl
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:color-erase-mode",
-           "description", "GIMP color erase mode operation",
-           NULL);
+                                 "name",        "gimp:color-erase-mode",
+                                 "description", "GIMP color erase mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_color_erase_mode_process;
 }
diff --git a/app/gegl/gimpoperationcolorize.c b/app/gegl/gimpoperationcolorize.c
index c748096..b96f713 100644
--- a/app/gegl/gimpoperationcolorize.c
+++ b/app/gegl/gimpoperationcolorize.c
@@ -56,12 +56,12 @@ gimp_operation_colorize_class_init (GimpOperationColorizeClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-                  "name"       , "gimp:colorize",
-                  "categories" , "color",
-                  "description", "GIMP Colorize operation",
-                  NULL);
+                                 "name",        "gimp:colorize",
+                                 "categories",  "color",
+                                 "description", "GIMP Colorize operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_colorize_process;
+  point_class->process = gimp_operation_colorize_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationcolormode.c b/app/gegl/gimpoperationcolormode.c
index 2989995..59a7f02 100644
--- a/app/gegl/gimpoperationcolormode.c
+++ b/app/gegl/gimpoperationcolormode.c
@@ -51,9 +51,9 @@ gimp_operation_color_mode_class_init (GimpOperationColorModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:color-mode",
-           "description", "GIMP color mode operation",
-           NULL);
+                                 "name",        "gimp:color-mode",
+                                 "description", "GIMP color mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_color_mode_process;
 }
diff --git a/app/gegl/gimpoperationcurves.c b/app/gegl/gimpoperationcurves.c
index ea8c48c..e6089b1 100644
--- a/app/gegl/gimpoperationcurves.c
+++ b/app/gegl/gimpoperationcurves.c
@@ -60,12 +60,12 @@ gimp_operation_curves_class_init (GimpOperationCurvesClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:curves",
-           "categories" , "color",
-           "description", "GIMP Curves operation",
-           NULL);
+                                 "name",        "gimp:curves",
+                                 "categories",  "color",
+                                 "description", "GIMP Curves operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_curves_process;
+  point_class->process = gimp_operation_curves_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationdarkenonlymode.c b/app/gegl/gimpoperationdarkenonlymode.c
index 43c9942..77113a7 100644
--- a/app/gegl/gimpoperationdarkenonlymode.c
+++ b/app/gegl/gimpoperationdarkenonlymode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationdarkenonlymode.h"
 
 
-static void gimp_operation_darken_only_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_darken_only_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_darken_only_mode_process (GeglOperation       *operation,
                                                          void                *in_buf,
                                                          void                *aux_buf,
@@ -53,12 +53,13 @@ gimp_operation_darken_only_mode_class_init (GimpOperationDarkenOnlyModeClass *kl
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:darken-only-mode",
-           "description", "GIMP darken only mode operation",
-           NULL);
+                                 "name",        "gimp:darken-only-mode",
+                                 "description", "GIMP darken only mode operation",
+                                 NULL);
 
-  point_class->process     = gimp_operation_darken_only_mode_process;
   operation_class->prepare = gimp_operation_darken_only_mode_prepare;
+
+  point_class->process     = gimp_operation_darken_only_mode_process;
 }
 
 static void
diff --git a/app/gegl/gimpoperationdesaturate.c b/app/gegl/gimpoperationdesaturate.c
index 5abc4ae..b213ea9 100644
--- a/app/gegl/gimpoperationdesaturate.c
+++ b/app/gegl/gimpoperationdesaturate.c
@@ -56,12 +56,12 @@ gimp_operation_desaturate_class_init (GimpOperationDesaturateClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:desaturate",
-           "categories" , "color",
-           "description", "GIMP Desaturate operation",
-           NULL);
+                                 "name",        "gimp:desaturate",
+                                 "categories",  "color",
+                                 "description", "GIMP Desaturate operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_desaturate_process;
+  point_class->process = gimp_operation_desaturate_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationdifferencemode.c b/app/gegl/gimpoperationdifferencemode.c
index cb9be87..35bea77 100644
--- a/app/gegl/gimpoperationdifferencemode.c
+++ b/app/gegl/gimpoperationdifferencemode.c
@@ -51,9 +51,9 @@ gimp_operation_difference_mode_class_init (GimpOperationDifferenceModeClass *kla
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:difference-mode",
-           "description", "GIMP difference mode operation",
-           NULL);
+                                 "name",        "gimp:difference-mode",
+                                 "description", "GIMP difference mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_difference_mode_process;
 }
diff --git a/app/gegl/gimpoperationdissolvemode.c b/app/gegl/gimpoperationdissolvemode.c
index 06ef48b..c32c573 100644
--- a/app/gegl/gimpoperationdissolvemode.c
+++ b/app/gegl/gimpoperationdissolvemode.c
@@ -29,23 +29,24 @@
 
 #include "gimpoperationdissolvemode.h"
 
+
+#define RANDOM_TABLE_SIZE 4096
+
+static void     gimp_operation_dissolve_mode_prepare (GeglOperation       *operation);
+static gboolean gimp_operation_dissolve_mode_process (GeglOperation       *operation,
+                                                      void                *in_buf,
+                                                      void                *aux_buf,
+                                                      void                *out_buf,
+                                                      glong                samples,
+                                                      const GeglRectangle *result,
+                                                      gint                 level);
+
+
 G_DEFINE_TYPE (GimpOperationDissolveMode, gimp_operation_dissolve_mode,
                GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
 
-#define RANDOM_TABLE_SIZE 4096
 static gint32 random_table[RANDOM_TABLE_SIZE];
 
-static void     gimp_operation_dissolve_mode_prepare (
-                                                GeglOperation       *operation);
-static gboolean gimp_operation_dissolve_mode_process (
-                                                GeglOperation       *operation,
-                                                void                *in_buf,
-                                                void                *aux_buf,
-                                                void                *out_buf,
-                                                glong                samples,
-                                                const GeglRectangle *result,
-                                                gint                 level);
-
 
 static void
 gimp_operation_dissolve_mode_class_init (GimpOperationDissolveModeClass *klass)
diff --git a/app/gegl/gimpoperationdividemode.c b/app/gegl/gimpoperationdividemode.c
index 818d02c..2ad9c0d 100644
--- a/app/gegl/gimpoperationdividemode.c
+++ b/app/gegl/gimpoperationdividemode.c
@@ -51,9 +51,9 @@ gimp_operation_divide_mode_class_init (GimpOperationDivideModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:divide-mode",
-           "description", "GIMP divide mode operation",
-           NULL);
+                                 "name",        "gimp:divide-mode",
+                                 "description", "GIMP divide mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_divide_mode_process;
 }
diff --git a/app/gegl/gimpoperationdodgemode.c b/app/gegl/gimpoperationdodgemode.c
index acf6afe..e53e6ec 100644
--- a/app/gegl/gimpoperationdodgemode.c
+++ b/app/gegl/gimpoperationdodgemode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationdodgemode.h"
 
 
-static void gimp_operation_dodge_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_dodge_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_dodge_mode_process (GeglOperation       *operation,
                                                    void                *in_buf,
                                                    void                *aux_buf,
@@ -53,9 +53,9 @@ gimp_operation_dodge_mode_class_init (GimpOperationDodgeModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:dodge-mode",
-           "description", "GIMP dodge mode operation",
-           NULL);
+                                 "name",        "gimp:dodge-mode",
+                                 "description", "GIMP dodge mode operation",
+                                 NULL);
 
   point_class->process     = gimp_operation_dodge_mode_process;
   operation_class->prepare = gimp_operation_dodge_mode_prepare;
diff --git a/app/gegl/gimpoperationequalize.c b/app/gegl/gimpoperationequalize.c
index 06bff53..c83951e 100644
--- a/app/gegl/gimpoperationequalize.c
+++ b/app/gegl/gimpoperationequalize.c
@@ -40,22 +40,22 @@ enum
 };
 
 
-static void   gimp_operation_equalize_finalize     (GObject    *object);
-static void   gimp_operation_equalize_get_property (GObject    *object,
-                                                    guint       property_id,
-                                                    GValue     *value,
-                                                    GParamSpec *pspec);
-static void   gimp_operation_equalize_set_property (GObject      *object,
-                                                    guint         property_id,
-                                                    const GValue *value,
-                                                    GParamSpec   *pspec);
-
-static gboolean gimp_operation_equalize_process (GeglOperation       *operation,
-                                                 void                *in_buf,
-                                                 void                *out_buf,
-                                                 glong                samples,
-                                                 const GeglRectangle *roi,
-                                                 gint                 level);
+static void     gimp_operation_equalize_finalize     (GObject             *object);
+static void     gimp_operation_equalize_get_property (GObject             *object,
+                                                      guint                property_id,
+                                                      GValue              *value,
+                                                      GParamSpec          *pspec);
+static void     gimp_operation_equalize_set_property (GObject             *object,
+                                                      guint                property_id,
+                                                      const GValue        *value,
+                                                      GParamSpec          *pspec);
+
+static gboolean gimp_operation_equalize_process      (GeglOperation       *operation,
+                                                      void                *in_buf,
+                                                      void                *out_buf,
+                                                      glong                samples,
+                                                      const GeglRectangle *roi,
+                                                      gint                 level);
 
 
 G_DEFINE_TYPE (GimpOperationEqualize, gimp_operation_equalize,
@@ -76,12 +76,12 @@ gimp_operation_equalize_class_init (GimpOperationEqualizeClass *klass)
   object_class->get_property   = gimp_operation_equalize_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-          "name"        , "gimp:equalize",
-          "categories"  , "color",
-          "description" , "GIMP Equalize operation",
-          NULL);
+                                 "name",        "gimp:equalize",
+                                 "categories",  "color",
+                                 "description", "GIMP Equalize operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_equalize_process;
+  point_class->process = gimp_operation_equalize_process;
 
   g_object_class_install_property (object_class, PROP_HISTOGRAM,
                                    g_param_spec_pointer ("histogram",
diff --git a/app/gegl/gimpoperationerasemode.c b/app/gegl/gimpoperationerasemode.c
index 6900dda..7324d7b 100644
--- a/app/gegl/gimpoperationerasemode.c
+++ b/app/gegl/gimpoperationerasemode.c
@@ -51,9 +51,9 @@ gimp_operation_erase_mode_class_init (GimpOperationEraseModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:erase-mode",
-           "description", "GIMP erase mode operation",
-           NULL);
+                                 "name",        "gimp:erase-mode",
+                                 "description", "GIMP erase mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_erase_mode_process;
 }
diff --git a/app/gegl/gimpoperationgrainextractmode.c b/app/gegl/gimpoperationgrainextractmode.c
index db0b002..b76cd7b 100644
--- a/app/gegl/gimpoperationgrainextractmode.c
+++ b/app/gegl/gimpoperationgrainextractmode.c
@@ -51,9 +51,9 @@ gimp_operation_grain_extract_mode_class_init (GimpOperationGrainExtractModeClass
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-             "name"       , "gimp:grain-extract-mode",
-             "description", "GIMP grain extract mode operation",
-             NULL);
+                                 "name",        "gimp:grain-extract-mode",
+                                 "description", "GIMP grain extract mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_grain_extract_mode_process;
 }
diff --git a/app/gegl/gimpoperationgrainmergemode.c b/app/gegl/gimpoperationgrainmergemode.c
index b88ddd4..d1cea9d 100644
--- a/app/gegl/gimpoperationgrainmergemode.c
+++ b/app/gegl/gimpoperationgrainmergemode.c
@@ -51,9 +51,9 @@ gimp_operation_grain_merge_mode_class_init (GimpOperationGrainMergeModeClass *kl
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:grain-merge-mode",
-           "description", "GIMP grain merge mode operation",
-           NULL);
+                                 "name",        "gimp:grain-merge-mode",
+                                 "description", "GIMP grain merge mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_grain_merge_mode_process;
 }
diff --git a/app/gegl/gimpoperationgrow.c b/app/gegl/gimpoperationgrow.c
index 40f692c..ae96c7b 100644
--- a/app/gegl/gimpoperationgrow.c
+++ b/app/gegl/gimpoperationgrow.c
@@ -40,28 +40,29 @@ enum
 };
 
 
-static void     gimp_operation_grow_get_property (GObject      *object,
-                                                  guint         property_id,
-                                                  GValue       *value,
-                                                  GParamSpec   *pspec);
-static void     gimp_operation_grow_set_property (GObject      *object,
-                                                  guint         property_id,
-                                                  const GValue *value,
-                                                  GParamSpec   *pspec);
-
+static void          gimp_operation_grow_get_property (GObject             *object,
+                                                       guint                property_id,
+                                                       GValue              *value,
+                                                       GParamSpec          *pspec);
+static void          gimp_operation_grow_set_property (GObject             *object,
+                                                       guint                property_id,
+                                                       const GValue        *value,
+                                                       GParamSpec          *pspec);
+
+static void          gimp_operation_grow_prepare      (GeglOperation       *operation);
 static GeglRectangle
-gimp_operation_grow_get_required_for_output (GeglOperation       *self,
-                                             const gchar         *input_pad,
-                                             const GeglRectangle *roi);
+          gimp_operation_grow_get_required_for_output (GeglOperation       *self,
+                                                       const gchar         *input_pad,
+                                                       const GeglRectangle *roi);
 static GeglRectangle
-      gimp_operation_grow_get_cached_region (GeglOperation       *self,
-                                             const GeglRectangle *roi);
-static void     gimp_operation_grow_prepare (GeglOperation       *operation);
-static gboolean gimp_operation_grow_process (GeglOperation       *operation,
-                                             GeglBuffer          *input,
-                                             GeglBuffer          *output,
-                                             const GeglRectangle *roi,
-                                             gint                 level);
+                gimp_operation_grow_get_cached_region (GeglOperation       *self,
+                                                       const GeglRectangle *roi);
+
+static gboolean gimp_operation_grow_process           (GeglOperation       *operation,
+                                                       GeglBuffer          *input,
+                                                       GeglBuffer          *output,
+                                                       const GeglRectangle *roi,
+                                                       gint                 level);
 
 
 G_DEFINE_TYPE (GimpOperationGrow, gimp_operation_grow,
@@ -81,16 +82,16 @@ gimp_operation_grow_class_init (GimpOperationGrowClass *klass)
   object_class->get_property   = gimp_operation_grow_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-        "name"        , "gimp:grow",
-        "categories"  , "gimp",
-        "description" , "GIMP Grow operation",
-        NULL);
+                                 "name",        "gimp:grow",
+                                 "categories",  "gimp",
+                                 "description", "GIMP Grow operation",
+                                 NULL);
 
   operation_class->prepare                 = gimp_operation_grow_prepare;
   operation_class->get_required_for_output = gimp_operation_grow_get_required_for_output;
   operation_class->get_cached_region       = gimp_operation_grow_get_cached_region;
 
-  filter_class->process        = gimp_operation_grow_process;
+  filter_class->process                    = gimp_operation_grow_process;
 
   g_object_class_install_property (object_class, PROP_RADIUS_X,
                                    g_param_spec_int ("radius-x",
diff --git a/app/gegl/gimpoperationhardlightmode.c b/app/gegl/gimpoperationhardlightmode.c
index 0e647e8..4de5f0f 100644
--- a/app/gegl/gimpoperationhardlightmode.c
+++ b/app/gegl/gimpoperationhardlightmode.c
@@ -51,9 +51,9 @@ gimp_operation_hardlight_mode_class_init (GimpOperationHardlightModeClass *klass
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:hardlight-mode",
-           "description", "GIMP hardlight mode operation",
-           NULL);
+                                 "name",        "gimp:hardlight-mode",
+                                 "description", "GIMP hardlight mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_hardlight_mode_process;
 }
diff --git a/app/gegl/gimpoperationhuemode.c b/app/gegl/gimpoperationhuemode.c
index c7e48ca..22c2ecf 100644
--- a/app/gegl/gimpoperationhuemode.c
+++ b/app/gegl/gimpoperationhuemode.c
@@ -51,9 +51,9 @@ gimp_operation_hue_mode_class_init (GimpOperationHueModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:hue-mode",
-           "description", "GIMP hue mode operation",
-           NULL);
+                                 "name",        "gimp:hue-mode",
+                                 "description", "GIMP hue mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_hue_mode_process;
 }
diff --git a/app/gegl/gimpoperationhuesaturation.c b/app/gegl/gimpoperationhuesaturation.c
index 12d73f5..4d8e8e0 100644
--- a/app/gegl/gimpoperationhuesaturation.c
+++ b/app/gegl/gimpoperationhuesaturation.c
@@ -57,12 +57,12 @@ gimp_operation_hue_saturation_class_init (GimpOperationHueSaturationClass *klass
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:hue-saturation",
-           "categories" , "color",
-           "description", "GIMP Hue-Saturation operation",
-           NULL);
+                                 "name",        "gimp:hue-saturation",
+                                 "categories",  "color",
+                                 "description", "GIMP Hue-Saturation operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_hue_saturation_process;
+  point_class->process = gimp_operation_hue_saturation_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationlevels.c b/app/gegl/gimpoperationlevels.c
index 91e0b16..07602c7 100644
--- a/app/gegl/gimpoperationlevels.c
+++ b/app/gegl/gimpoperationlevels.c
@@ -57,12 +57,12 @@ gimp_operation_levels_class_init (GimpOperationLevelsClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:levels",
-           "categories" , "color",
-           "description", "GIMP Levels operation",
-           NULL);
+                                 "name",        "gimp:levels",
+                                 "categories",  "color",
+                                 "description", "GIMP Levels operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_levels_process;
+  point_class->process = gimp_operation_levels_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationlightenonlymode.c b/app/gegl/gimpoperationlightenonlymode.c
index e4cb137..1de48cd 100644
--- a/app/gegl/gimpoperationlightenonlymode.c
+++ b/app/gegl/gimpoperationlightenonlymode.c
@@ -28,7 +28,7 @@
 
 #include "gimpoperationlightenonlymode.h"
 
-static void gimp_operation_lighten_only_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_lighten_only_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_lighten_only_mode_process (GeglOperation       *operation,
                                                           void                *in_buf,
                                                           void                *aux_buf,
@@ -52,12 +52,13 @@ gimp_operation_lighten_only_mode_class_init (GimpOperationLightenOnlyModeClass *
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:lighten-only-mode",
-           "description", "GIMP lighten only mode operation",
-           NULL);
+                                 "name",        "gimp:lighten-only-mode",
+                                 "description", "GIMP lighten only mode operation",
+                                 NULL);
 
-  point_class->process     = gimp_operation_lighten_only_mode_process;
   operation_class->prepare = gimp_operation_lighten_only_mode_prepare;
+
+  point_class->process     = gimp_operation_lighten_only_mode_process;
 }
 
 static void
diff --git a/app/gegl/gimpoperationmultiplymode.c b/app/gegl/gimpoperationmultiplymode.c
index 11e118b..5964a20 100644
--- a/app/gegl/gimpoperationmultiplymode.c
+++ b/app/gegl/gimpoperationmultiplymode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationmultiplymode.h"
 
 
-static void gimp_operation_multiply_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_multiply_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_multiply_mode_process (GeglOperation       *operation,
                                                       void                *in_buf,
                                                       void                *aux_buf,
@@ -53,9 +53,9 @@ gimp_operation_multiply_mode_class_init (GimpOperationMultiplyModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:multiply-mode",
-           "description", "GIMP multiply mode operation",
-           NULL);
+                                 "name",        "gimp:multiply-mode",
+                                 "description", "GIMP multiply mode operation",
+                                 NULL);
 
   point_class->process     = gimp_operation_multiply_mode_process;
   operation_class->prepare = gimp_operation_multiply_mode_prepare;
diff --git a/app/gegl/gimpoperationnormalmode.c b/app/gegl/gimpoperationnormalmode.c
index 1b531d5..96be5a4 100644
--- a/app/gegl/gimpoperationnormalmode.c
+++ b/app/gegl/gimpoperationnormalmode.c
@@ -58,9 +58,9 @@ gimp_operation_normal_mode_class_init (GimpOperationNormalModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-        "name"        , "gimp:normal-mode",
-        "description" , "GIMP normal mode operation",
-        NULL);
+                                 "name",        "gimp:normal-mode",
+                                 "description", "GIMP normal mode operation",
+                                 NULL);
 
 
   operation_class->process     = gimp_operation_normal_parent_process;
diff --git a/app/gegl/gimpoperationoverlaymode.c b/app/gegl/gimpoperationoverlaymode.c
index 640362f..680e3c8 100644
--- a/app/gegl/gimpoperationoverlaymode.c
+++ b/app/gegl/gimpoperationoverlaymode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationoverlaymode.h"
 
 
-static void gimp_operation_overlay_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_overlay_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_overlay_mode_process (GeglOperation       *operation,
                                                      void                *in_buf,
                                                      void                *aux_buf,
@@ -53,12 +53,13 @@ gimp_operation_overlay_mode_class_init (GimpOperationOverlayModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:overlay-mode",
-           "description", "GIMP overlay mode operation",
-           NULL);
+                                 "name",        "gimp:overlay-mode",
+                                 "description", "GIMP overlay mode operation",
+                                 NULL);
 
-  point_class->process     = gimp_operation_overlay_mode_process;
   operation_class->prepare = gimp_operation_overlay_mode_prepare;
+
+  point_class->process     = gimp_operation_overlay_mode_process;
 }
 
 static void
diff --git a/app/gegl/gimpoperationpointfilter.c b/app/gegl/gimpoperationpointfilter.c
index b13076a..2ef2f52 100644
--- a/app/gegl/gimpoperationpointfilter.c
+++ b/app/gegl/gimpoperationpointfilter.c
@@ -112,9 +112,7 @@ gimp_operation_point_filter_set_property (GObject      *object,
 static void
 gimp_operation_point_filter_prepare (GeglOperation *operation)
 {
-  const Babl *format;
-
-  format = babl_format ("R'G'B'A float");
+  const Babl *format = babl_format ("R'G'B'A float");
 
   gegl_operation_set_format (operation, "input",  format);
   gegl_operation_set_format (operation, "output", format);
diff --git a/app/gegl/gimpoperationposterize.c b/app/gegl/gimpoperationposterize.c
index 1ef9b7e..b08413a 100644
--- a/app/gegl/gimpoperationposterize.c
+++ b/app/gegl/gimpoperationposterize.c
@@ -57,12 +57,12 @@ gimp_operation_posterize_class_init (GimpOperationPosterizeClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:posterize",
-           "categories" , "color",
-           "description", "GIMP Posterize operation",
-           NULL);
+                                 "name",        "gimp:posterize",
+                                 "categories",  "color",
+                                 "description", "GIMP Posterize operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_posterize_process;
+  point_class->process = gimp_operation_posterize_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationreplacemode.c b/app/gegl/gimpoperationreplacemode.c
index 26e4a97..e8cd21c 100644
--- a/app/gegl/gimpoperationreplacemode.c
+++ b/app/gegl/gimpoperationreplacemode.c
@@ -51,9 +51,9 @@ gimp_operation_replace_mode_class_init (GimpOperationReplaceModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:replace-mode",
-           "description", "GIMP replace mode operation",
-           NULL);
+                                 "name",        "gimp:replace-mode",
+                                 "description", "GIMP replace mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_replace_mode_process;
 }
diff --git a/app/gegl/gimpoperationsaturationmode.c b/app/gegl/gimpoperationsaturationmode.c
index 739d592..bd16ada 100644
--- a/app/gegl/gimpoperationsaturationmode.c
+++ b/app/gegl/gimpoperationsaturationmode.c
@@ -51,9 +51,9 @@ gimp_operation_saturation_mode_class_init (GimpOperationSaturationModeClass *kla
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:saturation-mode",
-           "description", "GIMP saturation mode operation",
-           NULL);
+                                 "name",        "gimp:saturation-mode",
+                                 "description", "GIMP saturation mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_saturation_mode_process;
 }
diff --git a/app/gegl/gimpoperationscreenmode.c b/app/gegl/gimpoperationscreenmode.c
index a23d3bb..c3205f7 100644
--- a/app/gegl/gimpoperationscreenmode.c
+++ b/app/gegl/gimpoperationscreenmode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationscreenmode.h"
 
 
-static void gimp_operation_screen_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_screen_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_screen_mode_process (GeglOperation       *operation,
                                                     void                *in_buf,
                                                     void                *aux_buf,
@@ -53,9 +53,9 @@ gimp_operation_screen_mode_class_init (GimpOperationScreenModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:screen-mode",
-           "description", "GIMP screen mode operation",
-           NULL);
+                                 "name",        "gimp:screen-mode",
+                                 "description", "GIMP screen mode operation",
+                                 NULL);
 
   point_class->process     = gimp_operation_screen_mode_process;
   operation_class->prepare = gimp_operation_screen_mode_prepare;
diff --git a/app/gegl/gimpoperationsetalpha.c b/app/gegl/gimpoperationsetalpha.c
index 55d44c0..1756d86 100644
--- a/app/gegl/gimpoperationsetalpha.c
+++ b/app/gegl/gimpoperationsetalpha.c
@@ -34,23 +34,23 @@ enum
 };
 
 
-static void   gimp_operation_set_alpha_get_property (GObject    *object,
-                                                     guint       property_id,
-                                                     GValue     *value,
-                                                     GParamSpec *pspec);
-static void   gimp_operation_set_alpha_set_property (GObject      *object,
-                                                     guint         property_id,
-                                                     const GValue *value,
-                                                     GParamSpec   *pspec);
-
-static void   gimp_operation_set_alpha_prepare      (GeglOperation       *operation);
-static gboolean   gimp_operation_set_alpha_process  (GeglOperation       *operation,
-                                                     void                *in_buf,
-                                                     void                *aux_buf,
-                                                     void                *out_buf,
-                                                     glong                samples,
-                                                     const GeglRectangle *roi,
-                                                     gint                 level);
+static void       gimp_operation_set_alpha_get_property (GObject             *object,
+                                                         guint                property_id,
+                                                         GValue              *value,
+                                                         GParamSpec          *pspec);
+static void       gimp_operation_set_alpha_set_property (GObject             *object,
+                                                         guint                property_id,
+                                                         const GValue        *value,
+                                                         GParamSpec          *pspec);
+
+static void       gimp_operation_set_alpha_prepare      (GeglOperation       *operation);
+static gboolean   gimp_operation_set_alpha_process      (GeglOperation       *operation,
+                                                         void                *in_buf,
+                                                         void                *aux_buf,
+                                                         void                *out_buf,
+                                                         glong                samples,
+                                                         const GeglRectangle *roi,
+                                                         gint                 level);
 
 
 G_DEFINE_TYPE (GimpOperationSetAlpha, gimp_operation_set_alpha,
@@ -70,14 +70,14 @@ gimp_operation_set_alpha_class_init (GimpOperationSetAlphaClass *klass)
   object_class->get_property = gimp_operation_set_alpha_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-            "name"        , "gimp:set-alpha",
-            "categories"  , "color",
-            "description" , "Set a buffer's alpha channel to a value",
-            NULL);
+                                 "name",        "gimp:set-alpha",
+                                 "categories",  "color",
+                                 "description", "Set a buffer's alpha channel to a value",
+                                 NULL);
 
-  operation_class->prepare     = gimp_operation_set_alpha_prepare;
+  operation_class->prepare = gimp_operation_set_alpha_prepare;
 
-  point_class->process         = gimp_operation_set_alpha_process;
+  point_class->process     = gimp_operation_set_alpha_process;
 
   g_object_class_install_property (object_class, PROP_VALUE,
                                    g_param_spec_double ("value",
diff --git a/app/gegl/gimpoperationshapeburst.c b/app/gegl/gimpoperationshapeburst.c
index ff43564..73aa446 100644
--- a/app/gegl/gimpoperationshapeburst.c
+++ b/app/gegl/gimpoperationshapeburst.c
@@ -81,16 +81,16 @@ gimp_operation_shapeburst_class_init (GimpOperationShapeburstClass *klass)
   object_class->get_property   = gimp_operation_shapeburst_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-    "name"        , "gimp:shapeburst",
-    "categories"  , "gimp",
-    "description" , "GIMP Shapeburst operation",
-    NULL);
+                                 "name",        "gimp:shapeburst",
+                                 "categories",  "gimp",
+                                 "description", "GIMP Shapeburst operation",
+                                 NULL);
 
   operation_class->prepare                 = gimp_operation_shapeburst_prepare;
   operation_class->get_required_for_output = gimp_operation_shapeburst_get_required_for_output;
   operation_class->get_cached_region       = gimp_operation_shapeburst_get_cached_region;
 
-  filter_class->process        = gimp_operation_shapeburst_process;
+  filter_class->process                    = gimp_operation_shapeburst_process;
 
   g_object_class_install_property (object_class, PROP_MAX_ITERATIONS,
                                    g_param_spec_double ("max-iterations",
diff --git a/app/gegl/gimpoperationshrink.c b/app/gegl/gimpoperationshrink.c
index fe82d1a..e43064b 100644
--- a/app/gegl/gimpoperationshrink.c
+++ b/app/gegl/gimpoperationshrink.c
@@ -41,28 +41,29 @@ enum
 };
 
 
-static void     gimp_operation_shrink_get_property (GObject      *object,
-                                                    guint         property_id,
-                                                    GValue       *value,
-                                                    GParamSpec   *pspec);
-static void     gimp_operation_shrink_set_property (GObject      *object,
-                                                    guint         property_id,
-                                                    const GValue *value,
-                                                    GParamSpec   *pspec);
-
+static void     gimp_operation_shrink_get_property (GObject             *object,
+                                                    guint                property_id,
+                                                    GValue              *value,
+                                                    GParamSpec          *pspec);
+static void     gimp_operation_shrink_set_property (GObject             *object,
+                                                    guint                property_id,
+                                                    const GValue        *value,
+                                                    GParamSpec          *pspec);
+
+static void          gimp_operation_shrink_prepare (GeglOperation       *operation);
 static GeglRectangle
-gimp_operation_shrink_get_required_for_output (GeglOperation       *self,
-                                               const gchar         *input_pad,
-                                               const GeglRectangle *roi);
+     gimp_operation_shrink_get_required_for_output (GeglOperation       *self,
+                                                    const gchar         *input_pad,
+                                                    const GeglRectangle *roi);
 static GeglRectangle
-      gimp_operation_shrink_get_cached_region (GeglOperation       *self,
-                                               const GeglRectangle *roi);
-static void     gimp_operation_shrink_prepare (GeglOperation       *operation);
-static gboolean gimp_operation_shrink_process (GeglOperation       *operation,
-                                               GeglBuffer          *input,
-                                               GeglBuffer          *output,
-                                               const GeglRectangle *roi,
-                                               gint                 level);
+           gimp_operation_shrink_get_cached_region (GeglOperation       *self,
+                                                    const GeglRectangle *roi);
+
+static gboolean      gimp_operation_shrink_process (GeglOperation       *operation,
+                                                    GeglBuffer          *input,
+                                                    GeglBuffer          *output,
+                                                    const GeglRectangle *roi,
+                                                    gint                 level);
 
 
 G_DEFINE_TYPE (GimpOperationShrink, gimp_operation_shrink,
@@ -82,16 +83,16 @@ gimp_operation_shrink_class_init (GimpOperationShrinkClass *klass)
   object_class->get_property   = gimp_operation_shrink_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-          "name"        , "gimp:shrink",
-          "categories"  , "gimp",
-          "description" , "GIMP Shrink operation",
-          NULL);
+                                 "name",        "gimp:shrink",
+                                 "categories",  "gimp",
+                                 "description", "GIMP Shrink operation",
+                                 NULL);
 
   operation_class->prepare                 = gimp_operation_shrink_prepare;
   operation_class->get_required_for_output = gimp_operation_shrink_get_required_for_output;
   operation_class->get_cached_region       = gimp_operation_shrink_get_cached_region;
 
-  filter_class->process        = gimp_operation_shrink_process;
+  filter_class->process                    = gimp_operation_shrink_process;
 
   g_object_class_install_property (object_class, PROP_RADIUS_X,
                                    g_param_spec_int ("radius-x",
diff --git a/app/gegl/gimpoperationsoftlightmode.c b/app/gegl/gimpoperationsoftlightmode.c
index ad3a313..4571a41 100644
--- a/app/gegl/gimpoperationsoftlightmode.c
+++ b/app/gegl/gimpoperationsoftlightmode.c
@@ -29,7 +29,7 @@
 #include "gimpoperationsoftlightmode.h"
 
 
-static void gimp_operation_softlight_mode_prepare     (GeglOperation       *operation);
+static void     gimp_operation_softlight_mode_prepare (GeglOperation       *operation);
 static gboolean gimp_operation_softlight_mode_process (GeglOperation       *operation,
                                                        void                *in_buf,
                                                        void                *aux_buf,
@@ -53,12 +53,13 @@ gimp_operation_softlight_mode_class_init (GimpOperationSoftlightModeClass *klass
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:softlight-mode",
-           "description", "GIMP softlight mode operation",
-           NULL);
+                                 "name",        "gimp:softlight-mode",
+                                 "description", "GIMP softlight mode operation",
+                                 NULL);
 
-  point_class->process     = gimp_operation_softlight_mode_process;
   operation_class->prepare = gimp_operation_softlight_mode_prepare;
+
+  point_class->process     = gimp_operation_softlight_mode_process;
 }
 
 static void
diff --git a/app/gegl/gimpoperationsubtractmode.c b/app/gegl/gimpoperationsubtractmode.c
index 1cc60ed..71a6fd7 100644
--- a/app/gegl/gimpoperationsubtractmode.c
+++ b/app/gegl/gimpoperationsubtractmode.c
@@ -51,9 +51,9 @@ gimp_operation_subtract_mode_class_init (GimpOperationSubtractModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:subtract-mode",
-           "description", "GIMP subtract mode operation",
-           NULL);
+                                 "name",        "gimp:subtract-mode",
+                                 "description", "GIMP subtract mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_subtract_mode_process;
 }
diff --git a/app/gegl/gimpoperationthreshold.c b/app/gegl/gimpoperationthreshold.c
index c23d4c0..0090c0d 100644
--- a/app/gegl/gimpoperationthreshold.c
+++ b/app/gegl/gimpoperationthreshold.c
@@ -56,12 +56,12 @@ gimp_operation_threshold_class_init (GimpOperationThresholdClass *klass)
   object_class->get_property   = gimp_operation_point_filter_get_property;
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:threshold",
-           "categories" , "color",
-           "description", "GIMP Threshold operation",
-           NULL);
+                                 "name",        "gimp:threshold",
+                                 "categories",  "color",
+                                 "description", "GIMP Threshold operation",
+                                 NULL);
 
-  point_class->process         = gimp_operation_threshold_process;
+  point_class->process = gimp_operation_threshold_process;
 
   g_object_class_install_property (object_class,
                                    GIMP_OPERATION_POINT_FILTER_PROP_CONFIG,
diff --git a/app/gegl/gimpoperationvaluemode.c b/app/gegl/gimpoperationvaluemode.c
index b3d4763..dc92805 100644
--- a/app/gegl/gimpoperationvaluemode.c
+++ b/app/gegl/gimpoperationvaluemode.c
@@ -51,9 +51,9 @@ gimp_operation_value_mode_class_init (GimpOperationValueModeClass *klass)
   point_class     = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
 
   gegl_operation_class_set_keys (operation_class,
-           "name"       , "gimp:value-mode",
-           "description", "GIMP value mode operation",
-           NULL);
+                                 "name",        "gimp:value-mode",
+                                 "description", "GIMP value mode operation",
+                                 NULL);
 
   point_class->process         = gimp_operation_value_mode_process;
 }



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]