From cad2218b6a34baad5a1e49883dd30ca4bee16ecf Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Sun, 11 Oct 2009 13:53:59 +0200 Subject: [PATCH] Move GimpDynamicsOutput to its own class ...but use it only as struct to keep GimpDynamics' properties for now. More refactoring later. --- app/core/Makefile.am | 2 + app/core/gimpdynamics.c | 328 +++---------------------- app/core/gimpdynamics.h | 41 +--- app/core/gimpdynamicsoutput.c | 438 ++++++++++++++++++++++++++++++++++ app/core/gimpdynamicsoutput.h | 79 ++++++ app/paint/gimpbrushcore.h | 3 + 6 files changed, 554 insertions(+), 337 deletions(-) create mode 100644 app/core/gimpdynamicsoutput.c create mode 100644 app/core/gimpdynamicsoutput.h diff --git a/app/core/Makefile.am b/app/core/Makefile.am index 796aa3ad27..acbe15b3c4 100644 --- a/app/core/Makefile.am +++ b/app/core/Makefile.am @@ -173,6 +173,8 @@ libappcore_a_sources = \ gimpdynamics-load.h \ gimpdynamics-save.c \ gimpdynamics-save.h \ + gimpdynamicsoutput.c \ + gimpdynamicsoutput.h \ gimperror.c \ gimperror.h \ gimpfilloptions.c \ diff --git a/app/core/gimpdynamics.c b/app/core/gimpdynamics.c index ea696f2e49..8acc1cc0eb 100644 --- a/app/core/gimpdynamics.c +++ b/app/core/gimpdynamics.c @@ -28,6 +28,7 @@ #include "gimpdynamics.h" #include "gimpdynamics-load.h" #include "gimpdynamics-save.h" +#include "gimpdynamicsoutput.h" #include "gimp-intl.h" @@ -150,25 +151,17 @@ enum }; -static void gimp_dynamics_finalize (GObject *object); - -static void gimp_dynamics_set_property (GObject *object, - guint property_id, - const GValue *value, - GParamSpec *pspec); - -static void gimp_dynamics_get_property (GObject *object, - guint property_id, - GValue *value, - GParamSpec *pspec); - -static const gchar* gimp_dynamics_get_extension (GimpData *data); - -static GimpDynamicsOutput* gimp_dynamics_output_init (void); - -static void gimp_dynamics_output_finalize - (GimpDynamicsOutput *dynamics); +static void gimp_dynamics_finalize (GObject *object); +static void gimp_dynamics_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_dynamics_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); +static const gchar * gimp_dynamics_get_extension (GimpData *data); G_DEFINE_TYPE (GimpDynamics, gimp_dynamics, @@ -398,21 +391,14 @@ gimp_dynamics_class_init (GimpDynamicsClass *klass) static void gimp_dynamics_init (GimpDynamics *dynamics) { - dynamics->opacity_dynamics = gimp_dynamics_output_init(); - - dynamics->hardness_dynamics = gimp_dynamics_output_init(); - - dynamics->rate_dynamics = gimp_dynamics_output_init(); - - dynamics->size_dynamics = gimp_dynamics_output_init(); - - dynamics->aspect_ratio_dynamics = gimp_dynamics_output_init(); - - dynamics->color_dynamics = gimp_dynamics_output_init(); - - dynamics->angle_dynamics = gimp_dynamics_output_init(); - - dynamics->jitter_dynamics = gimp_dynamics_output_init(); + dynamics->opacity_dynamics = gimp_dynamics_output_new (""); + dynamics->hardness_dynamics = gimp_dynamics_output_new (""); + dynamics->rate_dynamics = gimp_dynamics_output_new (""); + dynamics->size_dynamics = gimp_dynamics_output_new (""); + dynamics->aspect_ratio_dynamics = gimp_dynamics_output_new (""); + dynamics->color_dynamics = gimp_dynamics_output_new (""); + dynamics->angle_dynamics = gimp_dynamics_output_new (""); + dynamics->jitter_dynamics = gimp_dynamics_output_new (""); } @@ -422,71 +408,18 @@ gimp_dynamics_finalize (GObject *object) { GimpDynamics *dynamics = GIMP_DYNAMICS (object); - gimp_dynamics_output_finalize (dynamics->opacity_dynamics); - - gimp_dynamics_output_finalize (dynamics->hardness_dynamics); - - gimp_dynamics_output_finalize (dynamics->rate_dynamics); - - gimp_dynamics_output_finalize (dynamics->size_dynamics); - - gimp_dynamics_output_finalize (dynamics->aspect_ratio_dynamics); - - gimp_dynamics_output_finalize (dynamics->color_dynamics); - - gimp_dynamics_output_finalize (dynamics->angle_dynamics); - - gimp_dynamics_output_finalize (dynamics->jitter_dynamics); + g_object_unref (dynamics->opacity_dynamics); + g_object_unref (dynamics->hardness_dynamics); + g_object_unref (dynamics->rate_dynamics); + g_object_unref (dynamics->size_dynamics); + g_object_unref (dynamics->aspect_ratio_dynamics); + g_object_unref (dynamics->color_dynamics); + g_object_unref (dynamics->angle_dynamics); + g_object_unref (dynamics->jitter_dynamics); G_OBJECT_CLASS (parent_class)->finalize (object); } -static GimpDynamicsOutput* -gimp_dynamics_output_init(void) -{ - GimpDynamicsOutput * dynamics = g_slice_new0 (GimpDynamicsOutput); - - dynamics->pressure_curve = g_object_new (GIMP_TYPE_CURVE, - "name", "Pressure curve", - NULL); - dynamics->velocity_curve = g_object_new (GIMP_TYPE_CURVE, - "name", "Velocity curve", - NULL); - dynamics->direction_curve = g_object_new (GIMP_TYPE_CURVE, - "name", "Direction curve", - NULL); - dynamics->tilt_curve = g_object_new (GIMP_TYPE_CURVE, - "name", "Tilt curve", - NULL); - dynamics->random_curve = g_object_new (GIMP_TYPE_CURVE, - "name", "Random curve", - NULL); - dynamics->fade_curve = g_object_new (GIMP_TYPE_CURVE, - "name", "Fade curve", - NULL); - return dynamics; -} - -static void -gimp_dynamics_output_finalize (GimpDynamicsOutput *dynamics) -{ - g_object_unref(dynamics->pressure_curve); - - g_object_unref(dynamics->velocity_curve); - - g_object_unref(dynamics->direction_curve); - - g_object_unref(dynamics->tilt_curve); - - g_object_unref(dynamics->random_curve); - - g_object_unref(dynamics->fade_curve); - - g_slice_free (GimpDynamicsOutput, dynamics); - -} - - static void gimp_dynamics_set_property (GObject *object, guint property_id, @@ -964,212 +897,8 @@ gimp_dynamics_get_extension (GimpData *data) return GIMP_DYNAMICS_FILE_EXTENSION; } -gdouble -gimp_dynamics_get_linear_output_val (GimpDynamicsOutput *output, GimpCoords coords, gdouble fade_point) -{ - gdouble total = 0.0; - gdouble factors = 0.0; - - gdouble result = 1.0; - - if (output->pressure) - { - total += coords.pressure; - factors++; - } - - if (output->velocity) - { - total += (1.0 - coords.velocity); - factors++; - } - - if (output->direction) - { - total += coords.direction + 0.5; - factors++; - } - - if (output->tilt) - { - total += 1.0 - sqrt (SQR (coords.xtilt) + SQR (coords.ytilt)); - factors++; - } - - if (output->random) - { - total += g_random_double_range (0.0, 1.0); - factors++; - } - - if (output->fade) - { - total += fade_point; - factors++; - } - - if (factors > 0) - result = total / factors; - - //printf("Dynamics queried(linear). Result: %f, factors: %f, total: %f \n", result, factors, total); - return result; -} - -gdouble -gimp_dynamics_get_angular_output_val (GimpDynamicsOutput *output, GimpCoords coords, gdouble fade_point) -{ - gdouble total = 0.0; - gdouble factors = 0.0; - - gdouble result = 1.0; - - if (output->pressure) - { - total += coords.pressure; - factors++; - } - - if (output->velocity) - { - total += (1.0 - coords.velocity); - factors++; - } - - if (output->direction) - { - total += coords.direction + 0.5; - factors++; - } -/* For tilt to make sense, it needs to be converted to an angle, not just vector */ - if (output->tilt) - { - - gdouble tilt_x = coords.xtilt; - gdouble tilt_y = coords.ytilt; - gdouble tilt = 0.0; - - if (tilt_x == 0.0) - { - if (tilt_y >= 0.0) - tilt = 0.5; - else if (tilt_y < 0.0) - tilt = 0.0; - else tilt = -1.0; - } - else - { - tilt = atan ((- 1.0 * tilt_y) / - tilt_x) / (2 * G_PI); - - if (tilt_x > 0.0) - tilt = tilt + 0.5; - } - - tilt = tilt + 0.5; /* correct the angle, its wrong by 180 degrees */ - - while (tilt > 1.0) - tilt -= 1.0; - - while (tilt < 0.0) - tilt += 1.0; - total += tilt; - factors++; - } - - if (output->random) - { - total += g_random_double_range (0.0, 1.0); - factors++; - } - - if (output->fade) - { - total += fade_point; - factors++; - } - - if (factors > 0) - result = total / factors; - - return result + 0.5; -} - - -gdouble -gimp_dynamics_get_aspect_output_val (GimpDynamicsOutput *output, GimpCoords coords, gdouble fade_point) -{ - gdouble total = 0.0; - gdouble factors = 0.0; - - gdouble result = 1.0; - - if (output->pressure) - { - total += 2 * coords.pressure; - factors++; - } - - if (output->velocity) - { - total += 2 * coords.velocity; - factors++; - } - - if (output->direction) - { - gdouble direction = 0.0; - direction = fmod (1 + coords.direction, 0.5) / 0.25; - - if ((coords.direction > 0.0) && (coords.direction < 0.5)) - direction = 1 / direction; - - total += direction; - factors++; - } - - if (output->tilt) - { - total += sqrt ((1 - fabs (coords.xtilt)) / (1 - fabs (coords.ytilt))); - factors++; - } - - if (output->random) - { - gdouble random = g_random_double_range (0.0, 1.0); - if (random <= 0.5) - { - random = 1 / (random / 0.5 * (2.0 - 1.0) + 1.0); - } - else - { - random = (random - 0.5) / (1.0 - 0.5) * (2.0 - 1.0) + 1.0; - } - total += random; - factors++; - } - - if (output->fade) - { - total += fade_point; - factors++; - } - - if (factors > 0) - result = total / factors; - - /* printf("Dynamics queried(aspect). Result: %f, factors: %f, total: %f \n", result, factors, total);*/ - return result; -} - gboolean -gimp_dynamics_output_is_enabled(GimpDynamicsOutput *output) -{ - return (output->pressure || output->velocity || output->direction || - output->tilt || output->random || output->fade); -} - -gboolean -gimp_dynamics_input_fade_enabled(GimpDynamics *dynamics) +gimp_dynamics_input_fade_enabled (GimpDynamics *dynamics) { return (dynamics->opacity_dynamics->fade || dynamics->hardness_dynamics->fade || @@ -1179,5 +908,4 @@ gimp_dynamics_input_fade_enabled(GimpDynamics *dynamics) dynamics->color_dynamics->fade || dynamics->jitter_dynamics->fade || dynamics->angle_dynamics->fade); - } diff --git a/app/core/gimpdynamics.h b/app/core/gimpdynamics.h index 58deff487a..b96167c685 100644 --- a/app/core/gimpdynamics.h +++ b/app/core/gimpdynamics.h @@ -22,24 +22,6 @@ #include "gimpdata.h" -struct _GimpDynamicsOutput -{ - gboolean pressure; - gboolean velocity; - gboolean direction; - gboolean tilt; - gboolean random; - gboolean fade; - - GimpCurve *pressure_curve; - GimpCurve *velocity_curve; - GimpCurve *direction_curve; - GimpCurve *tilt_curve; - GimpCurve *random_curve; - GimpCurve *fade_curve; -}; - - #define GIMP_TYPE_DYNAMICS (gimp_dynamics_get_type ()) #define GIMP_DYNAMICS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DYNAMICS, GimpDynamics)) #define GIMP_DYNAMICS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DYNAMICS, GimpDynamicsClass)) @@ -70,27 +52,12 @@ struct _GimpDynamicsClass }; -GType gimp_dynamics_get_type (void) G_GNUC_CONST; +GType gimp_dynamics_get_type (void) G_GNUC_CONST; -GimpData * gimp_dynamics_new (const gchar *name); +GimpData * gimp_dynamics_new (const gchar *name); +GimpData * gimp_dynamics_get_standard (void); -GimpData * gimp_dynamics_get_standard (void); - -gdouble gimp_dynamics_get_linear_output_val (GimpDynamicsOutput *output, - GimpCoords coords, - gdouble fade_point); - -gdouble gimp_dynamics_get_angular_output_val (GimpDynamicsOutput *output, - GimpCoords coords, - gdouble fade_point); - -gdouble gimp_dynamics_get_aspect_output_val (GimpDynamicsOutput *output, - GimpCoords coords, - gdouble fade_point); - -gboolean gimp_dynamics_output_is_enabled (GimpDynamicsOutput *output); - -gboolean gimp_dynamics_input_fade_enabled (GimpDynamics *dynamics); +gboolean gimp_dynamics_input_fade_enabled (GimpDynamics *dynamics); #endif /* __GIMP_DYNAMICS_H__ */ diff --git a/app/core/gimpdynamicsoutput.c b/app/core/gimpdynamicsoutput.c new file mode 100644 index 0000000000..7b605c44ed --- /dev/null +++ b/app/core/gimpdynamicsoutput.c @@ -0,0 +1,438 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis + * + * 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 . + */ + +#include "config.h" + +#include + +#include "libgimpmath/gimpmath.h" +#include "libgimpconfig/gimpconfig.h" + +#include "core-types.h" + +#include "gimpcurve.h" +#include "gimpdynamicsoutput.h" + +#include "gimp-intl.h" + + +#define DEFAULT_PRESSURE FALSE +#define DEFAULT_VELOCITY FALSE +#define DEFAULT_DIRECTION FALSE +#define DEFAULT_TILT FALSE +#define DEFAULT_RANDOM FALSE +#define DEFAULT_FADE FALSE + + +enum +{ + PROP_0, + + PROP_PRESSURE, + PROP_VELOCITY, + PROP_DIRECTION, + PROP_TILT, + PROP_RANDOM, + PROP_FADE +}; + + +static void gimp_dynamics_output_finalize (GObject *object); + +static void gimp_dynamics_output_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); + +static void gimp_dynamics_output_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + + +G_DEFINE_TYPE (GimpDynamicsOutput, gimp_dynamics_output, + GIMP_TYPE_OBJECT) + + +#define parent_class gimp_dynamics_output_parent_class + + +static void +gimp_dynamics_output_class_init (GimpDynamicsOutputClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gimp_dynamics_output_finalize; + object_class->set_property = gimp_dynamics_output_set_property; + object_class->get_property = gimp_dynamics_output_get_property; + + GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PRESSURE, + "pressure", NULL, + DEFAULT_PRESSURE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VELOCITY, + "velocity", NULL, + DEFAULT_VELOCITY, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIRECTION, + "direction", NULL, + DEFAULT_DIRECTION, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_TILT, + "tilt", NULL, + DEFAULT_TILT, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_RANDOM, + "random", NULL, + DEFAULT_RANDOM, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FADE, + "fade", NULL, + DEFAULT_FADE, + GIMP_PARAM_STATIC_STRINGS); +} + +static void +gimp_dynamics_output_init (GimpDynamicsOutput *output) +{ + output->pressure_curve = GIMP_CURVE (gimp_curve_new ("Pressure curve")); + output->velocity_curve = GIMP_CURVE (gimp_curve_new ("Velocity curve")); + output->direction_curve = GIMP_CURVE (gimp_curve_new ("Direction curve")); + output->tilt_curve = GIMP_CURVE (gimp_curve_new ("Tilt curve")); + output->random_curve = GIMP_CURVE (gimp_curve_new ("Random curve")); + output->fade_curve = GIMP_CURVE (gimp_curve_new ("Fade curve")); +} + +static void +gimp_dynamics_output_finalize (GObject *object) +{ + GimpDynamicsOutput *output = GIMP_DYNAMICS_OUTPUT (object); + + g_object_unref (output->pressure_curve); + g_object_unref (output->velocity_curve); + g_object_unref (output->direction_curve); + g_object_unref (output->tilt_curve); + g_object_unref (output->random_curve); + g_object_unref (output->fade_curve); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_dynamics_output_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpDynamicsOutput *output = GIMP_DYNAMICS_OUTPUT (object); + + switch (property_id) + { + case PROP_PRESSURE: + output->pressure = g_value_get_boolean (value); + break; + + case PROP_VELOCITY: + output->velocity = g_value_get_boolean (value); + break; + + case PROP_DIRECTION: + output->direction = g_value_get_boolean (value); + break; + + case PROP_TILT: + output->tilt = g_value_get_boolean (value); + break; + + case PROP_RANDOM: + output->random = g_value_get_boolean (value); + break; + + case PROP_FADE: + output->fade = g_value_get_boolean (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_dynamics_output_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpDynamicsOutput *output = GIMP_DYNAMICS_OUTPUT (object); + + switch (property_id) + { + case PROP_PRESSURE: + g_value_set_boolean (value, output->pressure); + break; + + case PROP_VELOCITY: + g_value_set_boolean (value, output->velocity); + break; + + case PROP_DIRECTION: + g_value_set_boolean (value, output->direction); + break; + + case PROP_TILT: + g_value_set_boolean (value, output->tilt); + break; + + case PROP_RANDOM: + g_value_set_boolean (value, output->random); + break; + + case PROP_FADE: + g_value_set_boolean (value, output->fade); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +GimpDynamicsOutput * +gimp_dynamics_output_new (const gchar *name) +{ + g_return_val_if_fail (name != NULL, NULL); + + return g_object_new (GIMP_TYPE_DYNAMICS_OUTPUT, + "name", name, + NULL); +} + +gdouble +gimp_dynamics_get_linear_output_val (GimpDynamicsOutput *output, + GimpCoords coords, + gdouble fade_point) +{ + gdouble total = 0.0; + gdouble factors = 0.0; + + gdouble result = 1.0; + + if (output->pressure) + { + total += coords.pressure; + factors++; + } + + if (output->velocity) + { + total += (1.0 - coords.velocity); + factors++; + } + + if (output->direction) + { + total += coords.direction + 0.5; + factors++; + } + + if (output->tilt) + { + total += 1.0 - sqrt (SQR (coords.xtilt) + SQR (coords.ytilt)); + factors++; + } + + if (output->random) + { + total += g_random_double_range (0.0, 1.0); + factors++; + } + + if (output->fade) + { + total += fade_point; + factors++; + } + + if (factors > 0) + result = total / factors; + + //printf("Dynamics queried(linear). Result: %f, factors: %f, total: %f \n", result, factors, total); + return result; +} + +gdouble +gimp_dynamics_get_angular_output_val (GimpDynamicsOutput *output, + GimpCoords coords, + gdouble fade_point) +{ + gdouble total = 0.0; + gdouble factors = 0.0; + + gdouble result = 1.0; + + if (output->pressure) + { + total += coords.pressure; + factors++; + } + + if (output->velocity) + { + total += (1.0 - coords.velocity); + factors++; + } + + if (output->direction) + { + total += coords.direction + 0.5; + factors++; + } +/* For tilt to make sense, it needs to be converted to an angle, not just vector */ + if (output->tilt) + { + + gdouble tilt_x = coords.xtilt; + gdouble tilt_y = coords.ytilt; + gdouble tilt = 0.0; + + if (tilt_x == 0.0) + { + if (tilt_y >= 0.0) + tilt = 0.5; + else if (tilt_y < 0.0) + tilt = 0.0; + else tilt = -1.0; + } + else + { + tilt = atan ((- 1.0 * tilt_y) / + tilt_x) / (2 * G_PI); + + if (tilt_x > 0.0) + tilt = tilt + 0.5; + } + + tilt = tilt + 0.5; /* correct the angle, its wrong by 180 degrees */ + + while (tilt > 1.0) + tilt -= 1.0; + + while (tilt < 0.0) + tilt += 1.0; + total += tilt; + factors++; + } + + if (output->random) + { + total += g_random_double_range (0.0, 1.0); + factors++; + } + + if (output->fade) + { + total += fade_point; + factors++; + } + + if (factors > 0) + result = total / factors; + + return result + 0.5; +} + + +gdouble +gimp_dynamics_get_aspect_output_val (GimpDynamicsOutput *output, + GimpCoords coords, + gdouble fade_point) +{ + gdouble total = 0.0; + gdouble factors = 0.0; + + gdouble result = 1.0; + + if (output->pressure) + { + total += 2 * coords.pressure; + factors++; + } + + if (output->velocity) + { + total += 2 * coords.velocity; + factors++; + } + + if (output->direction) + { + gdouble direction = 0.0; + direction = fmod (1 + coords.direction, 0.5) / 0.25; + + if ((coords.direction > 0.0) && (coords.direction < 0.5)) + direction = 1 / direction; + + total += direction; + factors++; + } + + if (output->tilt) + { + total += sqrt ((1 - fabs (coords.xtilt)) / (1 - fabs (coords.ytilt))); + factors++; + } + + if (output->random) + { + gdouble random = g_random_double_range (0.0, 1.0); + if (random <= 0.5) + { + random = 1 / (random / 0.5 * (2.0 - 1.0) + 1.0); + } + else + { + random = (random - 0.5) / (1.0 - 0.5) * (2.0 - 1.0) + 1.0; + } + total += random; + factors++; + } + + if (output->fade) + { + total += fade_point; + factors++; + } + + if (factors > 0) + result = total / factors; + + /* printf("Dynamics queried(aspect). Result: %f, factors: %f, total: %f \n", result, factors, total);*/ + return result; +} + +gboolean +gimp_dynamics_output_is_enabled (GimpDynamicsOutput *output) +{ + return (output->pressure || output->velocity || output->direction || + output->tilt || output->random || output->fade); +} diff --git a/app/core/gimpdynamicsoutput.h b/app/core/gimpdynamicsoutput.h new file mode 100644 index 0000000000..e27147bf29 --- /dev/null +++ b/app/core/gimpdynamicsoutput.h @@ -0,0 +1,79 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis + * + * 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 . + */ + +#ifndef __GIMP_DYNAMICS_OUTPUT_H__ +#define __GIMP_DYNAMICS_OUTPUT_H__ + + +#include "gimpobject.h" + + +#define GIMP_TYPE_DYNAMICS_OUTPUT (gimp_dynamics_output_get_type ()) +#define GIMP_DYNAMICS_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DYNAMICS_OUTPUT, GimpDynamicsOutput)) +#define GIMP_DYNAMICS_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DYNAMICS_OUTPUT, GimpDynamicsOutputClass)) +#define GIMP_IS_DYNAMICS_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DYNAMICS_OUTPUT)) +#define GIMP_IS_DYNAMICS_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DYNAMICS_OUTPUT)) +#define GIMP_DYNAMICS_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DYNAMICS_OUTPUT, GimpDynamicsOutputClass)) + + +typedef struct _GimpDynamicsOutputClass GimpDynamicsOutputClass; + +struct _GimpDynamicsOutput +{ + GimpObject parent_instance; + + gboolean pressure; + gboolean velocity; + gboolean direction; + gboolean tilt; + gboolean random; + gboolean fade; + + GimpCurve *pressure_curve; + GimpCurve *velocity_curve; + GimpCurve *direction_curve; + GimpCurve *tilt_curve; + GimpCurve *random_curve; + GimpCurve *fade_curve; +}; + +struct _GimpDynamicsOutputClass +{ + GimpObjectClass parent_class; +}; + + +GType gimp_dynamics_output_get_type (void) G_GNUC_CONST; + +GimpDynamicsOutput * gimp_dynamics_output_new (const gchar *name); + +gdouble gimp_dynamics_get_linear_output_val (GimpDynamicsOutput *output, + GimpCoords coords, + gdouble fade_point); + +gdouble gimp_dynamics_get_angular_output_val (GimpDynamicsOutput *output, + GimpCoords coords, + gdouble fade_point); + +gdouble gimp_dynamics_get_aspect_output_val (GimpDynamicsOutput *output, + GimpCoords coords, + gdouble fade_point); + +gboolean gimp_dynamics_output_is_enabled (GimpDynamicsOutput *output); + + +#endif /* __GIMP_DYNAMICS_OUTPUT_H__ */ diff --git a/app/paint/gimpbrushcore.h b/app/paint/gimpbrushcore.h index c82b450177..b2bfc74c9b 100644 --- a/app/paint/gimpbrushcore.h +++ b/app/paint/gimpbrushcore.h @@ -20,7 +20,10 @@ #include "gimppaintcore.h" + +#warning FIXME: remove these asap! #include "core/gimpdynamics.h" +#include "core/gimpdynamicsoutput.h" #define BRUSH_CORE_SUBSAMPLE 4 #define BRUSH_CORE_SOLID_SUBSAMPLE 2