dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Gimp/plug-ins/common/van-gogh-lic.c
Jehan 2e0d9504ed app, libgimp, plug-ins: move our code to use only non-deprecated code. 
- Though GimpDrawableChooser itself is deprecated, make it call the
  new items popup API, which will work just as well.
- gimp_procedure_dialog_get_widget() will now return a GimpItemChooser
  widget by default. I did hesitate if for API behavior stability, it
  should not still return a GimpDrawableChooser, but considered that if
  someone set G_TYPE_NONE, they want our "best choice" and are not
  considering tweaking it. If someone wants to make sure this function
  always returns a specific widget type, they should specify said type.
  So I also added a note in the function docs related to this
  assumption.
- Van Gogh plug-in must now use the GimpItemChooser API to set the item
  to show. Also I am specifying the widget type, even though it is now
  the new default, because of the previous point. Since we tweak further
  the widget with its API, let's specify so that any further defaults
  update doesn't break this code.
- Adding some pragma to ignore warnings on the few pieces of code where
  we have to call deprecated functions (because inside other deprecated
  functions themselves).
- gui_pdb_dialog_*() API should just always create GimpItemSelect
  dialogs now. Also I ref rather than peek the class, because even if
  the class has not been instanciated yet (a case I ran into), we still
  want to obtain the class structure.
2025-11-17 12:47:20 +01:00

944 lines
27 KiB
C
Raw Permalink Blame History

/* LIC 0.14 -- image filter plug-in for GIMP
* Copyright (C) 1996 Tom Bech
*
* E-mail: tomb@gimp.org
* You can contact the original GIMP authors at gimp@xcf.berkeley.edu
*
* 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 <https://www.gnu.org/licenses/>.
*
* In other words, you can't sue me for whatever happens while using this ;)
*
* Changes (post 0.10):
* -> 0.11: Fixed a bug in the convolution kernels (Tom).
* -> 0.12: Added Quartic's bilinear interpolation stuff (Tom).
* -> 0.13 Changed some UI stuff causing trouble with the 0.60 release, added
* the (GIMP) tags and changed random() calls to rand() (Tom)
* -> 0.14 Ported to 0.99.11 (Tom)
*
* This plug-in implements the Line Integral Convolution (LIC) as described in
* Cabral et al. "Imaging vector fields using line integral convolution" in the
* Proceedings of ACM SIGGRAPH 93. Publ. by ACM, New York, NY, USA. p. 263-270.
* (See http://www8.cs.umu.se/kurser/TDBD13/VT00/extra/p263-cabral.pdf)
*
* Some of the code is based on code by Steinar Haugen (thanks!), the Perlin
* noise function is practically ripped as is :)
*/
#include "config.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
/************/
/* Typedefs */
/************/
#define numx 40 /* Pseudo-random vector grid size */
#define numy 40
#define PLUG_IN_PROC "plug-in-lic"
#define PLUG_IN_BINARY "van-gogh-lic"
#define PLUG_IN_ROLE "gimp-van-gogh-lic"
typedef enum
{
LIC_HUE,
LIC_SATURATION,
LIC_BRIGHTNESS
} LICEffectChannel;
typedef struct _Lic Lic;
typedef struct _LicClass LicClass;
struct _Lic
{
GimpPlugIn parent_instance;
};
struct _LicClass
{
GimpPlugInClass parent_class;
};
#define LIC_TYPE (lic_get_type ())
#define LIC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LIC_TYPE, Lic))
GType lic_get_type (void) G_GNUC_CONST;
static GList * lic_query_procedures (GimpPlugIn *plug_in);
static GimpProcedure * lic_create_procedure (GimpPlugIn *plug_in,
const gchar *name);
static GimpValueArray * lic_run (GimpProcedure *procedure,
GimpRunMode run_mode,
GimpImage *image,
GimpDrawable **drawables,
GimpProcedureConfig *config,
gpointer run_data);
static gboolean create_main_dialog (GimpProcedure *procedure,
GimpProcedureConfig *config,
GimpDrawable *drawable);
static void compute_image (GimpProcedureConfig *config,
GimpDrawable *drawable);
G_DEFINE_TYPE (Lic, lic, GIMP_TYPE_PLUG_IN)
GIMP_MAIN (LIC_TYPE)
DEFINE_STD_SET_I18N
static void
lic_class_init (LicClass *klass)
{
GimpPlugInClass *plug_in_class = GIMP_PLUG_IN_CLASS (klass);
plug_in_class->query_procedures = lic_query_procedures;
plug_in_class->create_procedure = lic_create_procedure;
plug_in_class->set_i18n = STD_SET_I18N;
}
static void
lic_init (Lic *lic)
{
}
static GList *
lic_query_procedures (GimpPlugIn *plug_in)
{
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
}
static GimpProcedure *
lic_create_procedure (GimpPlugIn *plug_in,
const gchar *name)
{
GimpProcedure *procedure = NULL;
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
lic_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,
GIMP_PROCEDURE_SENSITIVE_DRAWABLE);
gimp_procedure_set_menu_label (procedure, _("_Van Gogh (LIC)..."));
gimp_procedure_add_menu_path (procedure, "<Image>/Filters/Artistic");
gimp_procedure_set_documentation (procedure,
_("Special effects that nobody "
"understands"),
"No help yet",
name);
gimp_procedure_set_attribution (procedure,
"Tom Bech & Federico Mena Quintero",
"Tom Bech & Federico Mena Quintero",
"Version 0.14, September 24 1997");
gimp_procedure_add_choice_argument (procedure, "effect-channel",
_("E_ffect Channel"),
_("Effect Channel"),
gimp_choice_new_with_values ("hue", LIC_HUE, _("Hue"), NULL,
"saturation", LIC_SATURATION, _("Saturation"), NULL,
"brightness", LIC_BRIGHTNESS, _("Brightness"), NULL,
NULL),
"brightness",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "effect-operator",
_("Effect O_perator"),
_("Effect Operator"),
gimp_choice_new_with_values ("derivative", 0, _("Derivative"), NULL,
"gradient", 1, _("Gradient"), NULL,
NULL),
"gradient",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "effect-convolve",
_("Con_volve"),
_("Convolve"),
gimp_choice_new_with_values ("with-white-noise", 0, _("With white noise"), NULL,
"with-source-image", 1, _("With source image"), NULL,
NULL),
"with-source-image",
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "effect-image",
_("Effect i_mage"),
_("Effect image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "filter-length",
_("Fil_ter length"),
_("Filter length"),
0.1, 64.0, 5.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "noise-magnitude",
_("_Noise magnitude"),
_("Noise magnitude"),
1.0, 5.0, 2.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "integration-steps",
_("Inte_gration steps"),
_("Integration steps"),
1.0, 40.0, 25.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "min-value",
_("Minimum v_alue"),
_("Minimum value"),
-100.0, 0, -25.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "max-value",
_("Ma_ximum value"),
_("Maximum value"),
0.0, 100, 25.0,
G_PARAM_READWRITE);
}
return procedure;
}
static GimpValueArray *
lic_run (GimpProcedure *procedure,
GimpRunMode run_mode,
GimpImage *image,
GimpDrawable **drawables,
GimpProcedureConfig *config,
gpointer run_data)
{
GimpDrawable *drawable;
gegl_init (NULL, NULL);
if (gimp_core_object_array_get_length ((GObject **) drawables) != 1)
{
GError *error = NULL;
g_set_error (&error, GIMP_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
return gimp_procedure_new_return_values (procedure,
GIMP_PDB_CALLING_ERROR,
error);
}
else
{
drawable = drawables[0];
}
/* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */
if (gimp_drawable_is_rgb (drawable))
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
if (! create_main_dialog (procedure, config, drawable))
{
return gimp_procedure_new_return_values (procedure,
GIMP_PDB_CANCEL,
NULL);
}
/* fallthrough */
case GIMP_RUN_WITH_LAST_VALS:
compute_image (config, drawable);
break;
default:
break;
}
}
else
{
return gimp_procedure_new_return_values (procedure,
GIMP_PDB_EXECUTION_ERROR,
NULL);
}
return gimp_procedure_new_return_values (procedure, GIMP_PDB_SUCCESS, NULL);
}
/*****************************/
/* Global variables and such */
/*****************************/
static gdouble G[numx][numy][2];
static gdouble l = 10.0;
static gdouble dx = 2.0;
static gdouble dy = 2.0;
static gdouble minv = -2.5;
static gdouble maxv = 2.5;
static gdouble isteps = 20.0;
static gboolean source_drw_has_alpha = FALSE;
static gint effect_width, effect_height;
static gint border_x, border_y, border_w, border_h;
/************************/
/* Convenience routines */
/************************/
static void
peek (GeglBuffer *buffer,
gint x,
gint y,
gdouble *color)
{
gegl_buffer_sample (buffer, x, y, NULL,
color, babl_format ("RGBA double"),
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
}
static void
poke (GeglBuffer *buffer,
gint x,
gint y,
gdouble *color)
{
gegl_buffer_set (buffer, GEGL_RECTANGLE (x, y, 1, 1), 0,
babl_format ("RGBA double"), color,
GEGL_AUTO_ROWSTRIDE);
}
static gint
peekmap (const guchar *image,
gint x,
gint y)
{
while (x < 0)
x += effect_width;
x %= effect_width;
while (y < 0)
y += effect_height;
y %= effect_height;
return (gint) image[x + effect_width * y];
}
/*************/
/* Main part */
/*************/
/***************************************************/
/* Compute the derivative in the x and y direction */
/* We use these convolution kernels: */
/* |1 0 -1| | 1 2 1| */
/* DX: |2 0 -2| DY: | 0 0 0| */
/* |1 0 -1| | -1 -2 -1| */
/* (It's a variation of the Sobel kernels, really) */
/***************************************************/
static gint
gradx (const guchar *image,
gint x,
gint y)
{
gint val = 0;
val = val + peekmap (image, x-1, y-1);
val = val - peekmap (image, x+1, y-1);
val = val + 2 * peekmap (image, x-1, y);
val = val - 2 * peekmap (image, x+1, y);
val = val + peekmap (image, x-1, y+1);
val = val - peekmap (image, x+1, y+1);
return val;
}
static gint
grady (const guchar *image,
gint x,
gint y)
{
gint val = 0;
val = val + peekmap (image, x-1, y-1);
val = val + 2 * peekmap (image, x, y-1);
val = val + peekmap (image, x+1, y-1);
val = val - peekmap (image, x-1, y+1);
val = val - 2 * peekmap (image, x, y+1);
val = val - peekmap (image, x+1, y+1);
return val;
}
/************************************/
/* A nice 2nd order cubic spline :) */
/************************************/
static gdouble
cubic (gdouble t)
{
gdouble at = fabs (t);
return (at < 1.0) ? at * at * (2.0 * at - 3.0) + 1.0 : 0.0;
}
static gdouble
omega (gdouble u,
gdouble v,
gint i,
gint j)
{
while (i < 0)
i += numx;
while (j < 0)
j += numy;
i %= numx;
j %= numy;
return cubic (u) * cubic (v) * (G[i][j][0]*u + G[i][j][1]*v);
}
/*************************************************************/
/* The noise function (2D variant of Perlins noise function) */
/*************************************************************/
static gdouble
noise (gdouble x,
gdouble y)
{
gint i, sti = (gint) floor (x / dx);
gint j, stj = (gint) floor (y / dy);
gdouble sum = 0.0;
/* Calculate the gdouble sum */
/* ======================== */
for (i = sti; i <= sti + 1; i++)
for (j = stj; j <= stj + 1; j++)
sum += omega ((x - (gdouble) i * dx) / dx,
(y - (gdouble) j * dy) / dy,
i, j);
return sum;
}
/*************************************************/
/* Generates pseudo-random vectors with length 1 */
/*************************************************/
static void
generatevectors (void)
{
gdouble alpha;
gint i, j;
GRand *gr;
gr = g_rand_new();
for (i = 0; i < numx; i++)
{
for (j = 0; j < numy; j++)
{
alpha = g_rand_double_range (gr, 0, 2) * G_PI;
G[i][j][0] = cos (alpha);
G[i][j][1] = sin (alpha);
}
}
g_rand_free (gr);
}
/* A simple triangle filter */
/* ======================== */
static gdouble
filter (gdouble u)
{
gdouble f = 1.0 - fabs (u) / l;
return (f < 0.0) ? 0.0 : f;
}
/******************************************************/
/* Compute the Line Integral Convolution (LIC) at x,y */
/******************************************************/
static gdouble
lic_noise (gint x,
gint y,
gdouble vx,
gdouble vy)
{
gdouble i = 0.0;
gdouble f1 = 0.0, f2 = 0.0;
gdouble u, step = 2.0 * l / isteps;
gdouble xx = (gdouble) x, yy = (gdouble) y;
gdouble c, s;
/* Get vector at x,y */
/* ================= */
c = vx;
s = vy;
/* Calculate integral numerically */
/* ============================== */
f1 = filter (-l) * noise (xx + l * c , yy + l * s);
for (u = -l + step; u <= l; u += step)
{
f2 = filter (u) * noise ( xx - u * c , yy - u * s);
i += (f1 + f2) * 0.5 * step;
f1 = f2;
}
i = (i - minv) / (maxv - minv);
i = CLAMP (i, 0.0, 1.0);
i = (i / 2.0) + 0.5;
return i;
}
static void
getpixel (GeglBuffer *buffer,
gdouble *p,
gdouble u,
gdouble v)
{
register gint x1, y1, x2, y2;
gint width, height;
gdouble pp[4];
gdouble pixels[16];
width = border_w;
height = border_h;
x1 = (gint)u;
y1 = (gint)v;
if (x1 < 0)
x1 = width - (-x1 % width);
else
x1 = x1 % width;
if (y1 < 0)
y1 = height - (-y1 % height);
else
y1 = y1 % height;
x2 = (x1 + 1) % width;
y2 = (y1 + 1) % height;
peek (buffer, x1, y1, pp);
for (gint i = 0; i < 4; i++)
pixels[i] = pp[i];
peek (buffer, x2, y1, pp);
for (gint i = 0; i < 4; i++)
pixels[i + 4] = pp[i];
peek (buffer, x1, y2, pp);
for (gint i = 0; i < 4; i++)
pixels[i + 8] = pp[i];
peek (buffer, x2, y2, pp);
for (gint i = 0; i < 4; i++)
pixels[i + 12] = pp[i];
gimp_bilinear_rgb (u, v, pixels, source_drw_has_alpha, p);
}
static void
lic_image (GeglBuffer *buffer,
gint x,
gint y,
gdouble vx,
gdouble vy,
gdouble *color)
{
gdouble u, step = 2.0 * l / isteps;
gdouble xx = (gdouble) x, yy = (gdouble) y;
gdouble c, s;
gdouble col[4] = { 0, 0, 0, 0 };
gdouble col1[4], col2[4], col3[4];
/* Get vector at x,y */
/* ================= */
c = vx;
s = vy;
/* Calculate integral numerically */
/* ============================== */
getpixel (buffer, col1, xx + l * c, yy + l * s);
if (source_drw_has_alpha)
{
for (gint i = 0; i < 4; i++)
col1[i] *= filter (-l);
}
else
{
for (gint i = 0; i < 3; i++)
col1[i] *= filter (-l);
}
for (u = -l + step; u <= l; u += step)
{
getpixel (buffer, col2, xx - u * c, yy - u * s);
if (source_drw_has_alpha)
{
for (gint i = 0; i < 4; i++)
{
col2[i] *= filter (u);
col3[i] = col1[i];
}
for (gint i = 0; i < 4; i++)
{
col3[i] += col2[i];
col3[i] *= (0.5 * step);
col[i] += col3[i];
}
}
else
{
for (gint i = 0; i < 3; i++)
{
col2[i] *= filter (u);
col3[i] = col1[i];
}
for (gint i = 0; i < 3; i++)
{
col3[i] += col2[i];
col3[i] *= (0.5 * step);
col[i] += col3[i];
}
}
for (gint i = 0; i < 4; i++)
col1[i] = col2[i];
}
if (source_drw_has_alpha)
{
for (gint i = 0; i < 4; i++)
col[i] *= (1.0 / l);
}
else
{
for (gint i = 0; i < 3; i++)
col[i] *= (1.0 / l);
}
for (gint i = 0; i < 4; i++)
color[i] = CLAMP (col[i], 0.0, 1.0);
}
static guchar *
rgb_to_hsl (GimpDrawable *drawable,
LICEffectChannel effect_channel)
{
GeglBuffer *buffer;
guchar *themap;
gfloat data[3];
gint x, y;
gint height_max;
gint width_max;
gdouble val = 0.0;
gint64 maxc, index = 0;
GRand *gr;
gr = g_rand_new ();
width_max = gimp_drawable_get_width (drawable);
height_max = gimp_drawable_get_height (drawable);
maxc = width_max * height_max;
buffer = gimp_drawable_get_buffer (drawable);
themap = g_new (guchar, maxc);
for (y = 0; y < height_max; y++)
{
for (x = 0; x < width_max; x++)
{
gegl_buffer_sample (buffer, x, y, NULL,
data, babl_format ("HSL float"),
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
switch (effect_channel)
{
case LIC_HUE:
val = data[0] * 255;
break;
case LIC_SATURATION:
val = data[1] * 255;
break;
case LIC_BRIGHTNESS:
val = data[2] * 255;
break;
}
/* add some random to avoid unstructured areas. */
val += g_rand_double_range (gr, -1.0, 1.0);
themap[index++] = (guchar) CLAMP0255 (RINT (val));
}
}
g_object_unref (buffer);
g_rand_free (gr);
return themap;
}
static void
compute_lic (GimpProcedureConfig *config,
GimpDrawable *drawable,
const guchar *scalarfield,
gboolean rotate)
{
GeglBuffer *src_buffer;
GeglBuffer *dest_buffer;
gint xcount, ycount;
gdouble color[4] = { 0.0, 0.0, 0.0, 1.0 };
gdouble vx, vy, tmp;
gint effect_convolve;
effect_convolve = gimp_procedure_config_get_choice_id (config,
"effect-convolve");
src_buffer = gimp_drawable_get_buffer (drawable);
dest_buffer = gimp_drawable_get_shadow_buffer (drawable);
for (ycount = 0; ycount < border_h; ycount++)
{
for (xcount = 0; xcount < border_w; xcount++)
{
/* Get derivative at (x,y) and normalize it */
/* ============================================================== */
vx = gradx (scalarfield, xcount, ycount);
vy = grady (scalarfield, xcount, ycount);
/* Rotate if needed */
if (rotate)
{
tmp = vy;
vy = -vx;
vx = tmp;
}
tmp = sqrt (vx * vx + vy * vy);
if (tmp >= 0.000001)
{
tmp = 1.0 / tmp;
vx *= tmp;
vy *= tmp;
}
/* Convolve with the LIC at (x,y) */
/* ============================== */
if (effect_convolve == 0)
{
peek (src_buffer, xcount, ycount, color);
tmp = lic_noise (xcount, ycount, vx, vy);
if (source_drw_has_alpha)
{
for (gint i = 0; i < 4; i++)
color[i] *= tmp;
}
else
{
for (gint i = 0; i < 3; i++)
color[i] *= tmp;
}
}
else
{
lic_image (src_buffer, xcount, ycount, vx, vy, color);
}
poke (dest_buffer, xcount, ycount, color);
}
gimp_progress_update ((gfloat) ycount / (gfloat) border_h);
}
g_object_unref (src_buffer);
g_object_unref (dest_buffer);
gimp_progress_update (1.0);
}
static void
compute_image (GimpProcedureConfig *config,
GimpDrawable *drawable)
{
GimpDrawable *effect_image;
guchar *scalarfield = NULL;
gdouble filtlen;
gdouble noisemag;
gdouble intsteps;
gdouble minv;
gdouble maxv;
gint effect_channel;
gint effect_operator;
gint effect_convolve;
g_object_get (config,
"filter-length", &filtlen,
"noise-magnitude", &noisemag,
"effect-image", &effect_image,
"integration-steps", &intsteps,
"min-value", &minv,
"max-value", &maxv,
NULL);
effect_channel = gimp_procedure_config_get_choice_id (config,
"effect-channel");
effect_operator = gimp_procedure_config_get_choice_id (config,
"effect-operator");
effect_convolve = gimp_procedure_config_get_choice_id (config,
"effect-convolve");
if (! effect_image)
return;
/* Get some useful info on the input drawable */
/* ========================================== */
if (! gimp_drawable_mask_intersect (drawable,
&border_x, &border_y,
&border_w, &border_h))
return;
gimp_progress_init (_("Van Gogh (LIC)"));
if (effect_convolve == 0)
generatevectors ();
if (filtlen < 0.1)
filtlen = 0.1;
l = filtlen;
dx = dy = noisemag;
minv = minv / 10.0;
maxv = maxv / 10.0;
isteps = intsteps;
source_drw_has_alpha = gimp_drawable_has_alpha (drawable);
effect_width = gimp_drawable_get_width (effect_image);
effect_height = gimp_drawable_get_height (effect_image);
switch (effect_channel)
{
case LIC_HUE:
scalarfield = rgb_to_hsl (effect_image, LIC_HUE);
break;
case LIC_SATURATION:
scalarfield = rgb_to_hsl (effect_image, LIC_SATURATION);
break;
case LIC_BRIGHTNESS:
scalarfield = rgb_to_hsl (effect_image, LIC_BRIGHTNESS);
break;
}
g_clear_object (&effect_image);
compute_lic (config, drawable, scalarfield, effect_operator);
g_free (scalarfield);
/* Update image */
/* ============ */
gimp_drawable_merge_shadow (drawable, TRUE);
gimp_drawable_update (drawable, border_x, border_y, border_w, border_h);
gimp_displays_flush ();
}
/**************************/
/* Below is only UI stuff */
/**************************/
static gboolean
create_main_dialog (GimpProcedure *procedure,
GimpProcedureConfig *config,
GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *chooser;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
dialog = gimp_procedure_dialog_new (procedure,
GIMP_PROCEDURE_CONFIG (config),
_("Van Gogh (LIC)"));
gimp_procedure_dialog_get_spin_scale (GIMP_PROCEDURE_DIALOG (dialog),
"filter-length", 1.0);
gimp_procedure_dialog_get_spin_scale (GIMP_PROCEDURE_DIALOG (dialog),
"noise-magnitude", 1.0);
gimp_procedure_dialog_get_spin_scale (GIMP_PROCEDURE_DIALOG (dialog),
"integration-steps", 1.0);
gimp_procedure_dialog_get_spin_scale (GIMP_PROCEDURE_DIALOG (dialog),
"min-value", 1.0);
gimp_procedure_dialog_get_spin_scale (GIMP_PROCEDURE_DIALOG (dialog),
"max-value", 1.0);
chooser = gimp_procedure_dialog_get_widget (GIMP_PROCEDURE_DIALOG (dialog),
"effect-image", GIMP_TYPE_ITEM_CHOOSER);
gimp_procedure_dialog_fill (GIMP_PROCEDURE_DIALOG (dialog), NULL);
gtk_widget_set_visible (dialog, TRUE);
/* TODO: Currently we can't serialize GimpDrawable parameters, so this sets
* the parameter to the current image as a default value */
gimp_item_chooser_set_item (GIMP_ITEM_CHOOSER (chooser), GIMP_ITEM (drawable));
run = gimp_procedure_dialog_run (GIMP_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);
return run;
}
Reference in a new issue View git blame Copy permalink