callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace the threshold-slpha plug-in by a GEGL operation

Browse Source
This commit is contained in:
Michael Natterer
2012-05-04 17:59:36 +02:00
parent cdb79427cb
commit f24445efbc
16 changed files with 374 additions and 328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
app/actions/filters-actions.c
View File

@ -68,6 +68,12 @@ static const GimpStringActionEntry filters_actions[] =
NC_("filters-action", "Convert image to or from polar coordinates"),
"gegl:polar-coordinates",
NULL /* FIXME GIMP_HELP_FILTER_POLAR_COORDINATES */ },
{ "filters-threshold-alpha", GIMP_STOCK_GEGL,
NC_("filters-action", "_Threshold Alpha..."), NULL,
NC_("filters-action", "Make transparency all-or-nothing"),
"gimp:threshold-alpha",
NULL /* FIXME GIMP_HELP_FILTER_POLAR_COORDINATES */ },
};
void
@ -122,6 +128,7 @@ filters_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("filters-gaussian-blur", writable);
SET_SENSITIVE ("filters-pixelize", writable);
SET_SENSITIVE ("filters-polar-coordinates", writable);
SET_SENSITIVE ("filters-threshold-alpha", writable && alpha);
#undef SET_SENSITIVE
}

2
app/gegl/Makefile.am
View File

@ -78,6 +78,8 @@ libappgegl_a_sources = \
gimpoperationshapeburst.h \
gimpoperationshrink.c \
gimpoperationshrink.h \
gimpoperationthresholdalpha.c \
gimpoperationthresholdalpha.h \
\
gimpoperationpointfilter.c \
gimpoperationpointfilter.h \

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

@ -43,6 +43,7 @@
#include "gimpoperationsetalpha.h"
#include "gimpoperationshapeburst.h"
#include "gimpoperationshrink.h"
#include "gimpoperationthresholdalpha.h"
#include "gimpoperationbrightnesscontrast.h"
#include "gimpoperationcolorbalance.h"
@ -125,6 +126,7 @@ gimp_gegl_init (Gimp *gimp)
g_type_class_ref (GIMP_TYPE_OPERATION_SET_ALPHA);
g_type_class_ref (GIMP_TYPE_OPERATION_SHAPEBURST);
g_type_class_ref (GIMP_TYPE_OPERATION_SHRINK);
g_type_class_ref (GIMP_TYPE_OPERATION_THRESHOLD_ALPHA);
g_type_class_ref (GIMP_TYPE_OPERATION_BRIGHTNESS_CONTRAST);
g_type_class_ref (GIMP_TYPE_OPERATION_COLOR_BALANCE);

3
app/gegl/gimpoperationsetalpha.h
View File

@ -23,7 +23,6 @@
#include <gegl-plugin.h>
#include <operation/gegl-operation-point-filter.h>
#define GIMP_TYPE_OPERATION_SET_ALPHA (gimp_operation_set_alpha_get_type ())
@ -41,7 +40,7 @@ struct _GimpOperationSetAlpha
{
GeglOperationPointComposer parent_instance;
gdouble value;
gdouble value;
};
struct _GimpOperationSetAlphaClass

173
app/gegl/gimpoperationthresholdalpha.c Normal file
View File

@ -0,0 +1,173 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationthresholdalpha.c
* Copyright (C) 2012 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Ported from the threshold-alpha plug-in
* Copyright (C) 1997 Shuji Narazaki <narazaki@InetQ.or.jp>
*/
#include "config.h"
#include <gegl.h>
#include "gimp-gegl-types.h"
#include "gimpoperationthresholdalpha.h"
enum
{
PROP_0,
PROP_VALUE
};
static void gimp_operation_threshold_alpha_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_operation_threshold_alpha_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_operation_threshold_alpha_prepare (GeglOperation *operation);
static gboolean gimp_operation_threshold_alpha_process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi,
gint level);
G_DEFINE_TYPE (GimpOperationThresholdAlpha, gimp_operation_threshold_alpha,
GEGL_TYPE_OPERATION_POINT_FILTER)
#define parent_class gimp_operation_threshold_alpha_parent_class
static void
gimp_operation_threshold_alpha_class_init (GimpOperationThresholdAlphaClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationPointFilterClass *point_class = GEGL_OPERATION_POINT_FILTER_CLASS (klass);
object_class->set_property = gimp_operation_threshold_alpha_set_property;
object_class->get_property = gimp_operation_threshold_alpha_get_property;
gegl_operation_class_set_keys (operation_class,
"name", "gimp:threshold-alpha",
"categories", "color",
"description", "Threshold a buffer's alpha channel to a value",
NULL);
operation_class->prepare = gimp_operation_threshold_alpha_prepare;
point_class->process = gimp_operation_threshold_alpha_process;
g_object_class_install_property (object_class, PROP_VALUE,
g_param_spec_double ("value",
"Value",
"The alpha value",
0.0, 1.0, 0.5,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
}
static void
gimp_operation_threshold_alpha_init (GimpOperationThresholdAlpha *self)
{
}
static void
gimp_operation_threshold_alpha_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpOperationThresholdAlpha *self = GIMP_OPERATION_THRESHOLD_ALPHA (object);
switch (property_id)
{
case PROP_VALUE:
g_value_set_double (value, self->value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_operation_threshold_alpha_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpOperationThresholdAlpha *self = GIMP_OPERATION_THRESHOLD_ALPHA (object);
switch (property_id)
{
case PROP_VALUE:
self->value = g_value_get_double (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_operation_threshold_alpha_prepare (GeglOperation *operation)
{
gegl_operation_set_format (operation, "input", babl_format ("RGBA float"));
gegl_operation_set_format (operation, "output", babl_format ("RGBA float"));
}
static gboolean
gimp_operation_threshold_alpha_process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi,
gint level)
{
GimpOperationThresholdAlpha *self = GIMP_OPERATION_THRESHOLD_ALPHA (operation);
gfloat *src = in_buf;
gfloat *dest = out_buf;
while (samples--)
{
dest[RED] = src[RED];
dest[GREEN] = src[GREEN];
dest[BLUE] = src[BLUE];
if (src[ALPHA] > self->value)
dest[ALPHA] = 1.0;
else
dest[ALPHA] = 0.0;
src += 4;
dest += 4;
}
return TRUE;
}

56
app/gegl/gimpoperationthresholdalpha.h Normal file
View File

@ -0,0 +1,56 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpoperationthresholdalpha.h
* Copyright (C) 2012 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_OPERATION_THRESHOLD_ALPHA_H__
#define __GIMP_OPERATION_THRESHOLD_ALPHA_H__
#include <gegl-plugin.h>
#include <operation/gegl-operation-point-filter.h>
#define GIMP_TYPE_OPERATION_THRESHOLD_ALPHA (gimp_operation_threshold_alpha_get_type ())
#define GIMP_OPERATION_THRESHOLD_ALPHA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OPERATION_THRESHOLD_ALPHA, GimpOperationThresholdAlpha))
#define GIMP_OPERATION_THRESHOLD_ALPHA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OPERATION_THRESHOLD_ALPHA, GimpOperationThresholdAlphaClass))
#define GIMP_IS_OPERATION_THRESHOLD_ALPHA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OPERATION_THRESHOLD_ALPHA))
#define GIMP_IS_OPERATION_THRESHOLD_ALPHA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OPERATION_THRESHOLD_ALPHA))
#define GIMP_OPERATION_THRESHOLD_ALPHA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_OPERATION_THRESHOLD_ALPHA, GimpOperationThresholdAlphaClass))
typedef struct _GimpOperationThresholdAlpha GimpOperationThresholdAlpha;
typedef struct _GimpOperationThresholdAlphaClass GimpOperationThresholdAlphaClass;
struct _GimpOperationThresholdAlpha
{
GeglOperationPointFilter parent_instance;
gdouble value;
};
struct _GimpOperationThresholdAlphaClass
{
GeglOperationPointFilterClass parent_class;
};
GType gimp_operation_threshold_alpha_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_OPERATION_THRESHOLD_ALPHA_H__ */

2
app/pdb/internal-procs.c
View File

@ -28,7 +28,7 @@
#include "internal-procs.h"
/* 674 procedures registered total */
/* 675 procedures registered total */
void
internal_procs_init (GimpPDB *pdb)

83
app/pdb/plug-in-compat-cmds.c
View File

@ -225,6 +225,47 @@ plug_in_polar_coords_invoker (GimpProcedure *procedure,
error ? *error : NULL);
}
static GimpValueArray *
plug_in_threshold_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpDrawable *drawable;
gint32 threshold;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp);
threshold = g_value_get_int (gimp_value_array_index (args, 3));
if (success)
{
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, TRUE, error) &&
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error) &&
gimp_drawable_has_alpha (drawable))
{
GeglNode *node =
gegl_node_new_child (NULL,
"operation", "gimp:threshold-alpha",
"value", threshold / 255.0,
NULL);
gimp_drawable_apply_operation (drawable, progress,
C_("undo-type", "Threshold Alpha"),
node);
g_object_unref (node);
}
else
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
plug_in_vinvert_invoker (GimpProcedure *procedure,
Gimp *gimp,
@ -466,6 +507,48 @@ register_plug_in_compat_procs (GimpPDB *pdb)
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plug-in-threshold-alpha
*/
procedure = gimp_procedure_new (plug_in_threshold_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"plug-in-threshold-alpha");
gimp_procedure_set_static_strings (procedure,
"plug-in-threshold-alpha",
"Make transparency all-or-nothing",
"Make transparency all-or-nothing.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("run-mode",
"run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"Input image (unused)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"Input drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("threshold",
"threshold",
"Threshold",
0, 255, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plug-in-vinvert
*/

1
menus/image-menu.xml.in
View File

@ -431,6 +431,7 @@
<menuitem action="layers-alpha-add" />
<menuitem action="layers-alpha-remove" />
<menuitem action="filters-color-to-alpha" />
<menuitem action="filters-threshold-alpha" />
</placeholder>
<separator />
<placeholder name="Selection">

2
plug-ins/common/.gitignore vendored
View File

@ -254,8 +254,6 @@
/sparkle.exe
/sphere-designer
/sphere-designer.exe
/threshold-alpha
/threshold-alpha.exe
/tile
/tile.exe
/tile-glass

18
plug-ins/common/Makefile.am
View File

@ -170,7 +170,6 @@ libexec_PROGRAMS = \
softglow \
sparkle \
sphere-designer \
threshold-alpha \
tile \
tile-glass \
tile-paper \
@ -2366,23 +2365,6 @@ sphere_designer_LDADD = \
$(INTLLIBS) \
$(sphere_designer_RC)
threshold_alpha_SOURCES = \
threshold-alpha.c
threshold_alpha_LDADD = \
$(libgimpui) \
$(libgimpwidgets) \
$(libgimpmodule) \
$(libgimp) \
$(libgimpmath) \
$(libgimpconfig) \
$(libgimpcolor) \
$(libgimpbase) \
$(GTK_LIBS) \
$(RT_LIBS) \
$(INTLLIBS) \
$(threshold_alpha_RC)
tile_SOURCES = \
tile.c

1
plug-ins/common/gimprc.common
View File

@ -124,7 +124,6 @@ smooth_palette_RC = smooth-palette.rc.o
softglow_RC = softglow.rc.o
sparkle_RC = sparkle.rc.o
sphere_designer_RC = sphere-designer.rc.o
threshold_alpha_RC = threshold-alpha.rc.o
tile_RC = tile.rc.o
tile_glass_RC = tile-glass.rc.o
tile_paper_RC = tile-paper.rc.o

1
plug-ins/common/plugin-defs.pl
View File

@ -125,7 +125,6 @@
'softglow' => { ui => 1 },
'sparkle' => { ui => 1 },
'sphere-designer' => { ui => 1 },
'threshold-alpha' => { ui => 1 },
'tile' => { ui => 1 },
'tile-glass' => { ui => 1 },
'tile-paper' => { ui => 1 },

302
plug-ins/common/threshold-alpha.c
View File

@ -1,302 +0,0 @@
/* threshold_alpha.c -- This is a plug-in for GIMP (1.0's API)
* Author: Shuji Narazaki <narazaki@InetQ.or.jp>
* Time-stamp: <2000-01-09 13:25:30 yasuhiro>
* Version: 0.13A (the 'A' is for Adam who hacked in greyscale
* support - don't know if there's a more recent official
* version)
*
* Copyright (C) 1997 Shuji Narazaki <narazaki@InetQ.or.jp>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
#define PLUG_IN_PROC "plug-in-threshold-alpha"
#define PLUG_IN_BINARY "threshold-alpha"
#define PLUG_IN_ROLE "gimp-threshold-alpha"
#define SCALE_WIDTH 120
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static void threshold_alpha (GimpDrawable *drawable,
GimpPreview *preview);
static gboolean threshold_alpha_dialog (GimpDrawable *drawable);
const GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
typedef struct
{
gint threshold;
} ValueType;
static ValueType VALS =
{
127 /* threshold */
};
MAIN ()
static void
query (void)
{
static const GimpParamDef args [] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (not used)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "threshold", "Threshold" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Make transparency all-or-nothing"),
"",
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"1997",
N_("_Threshold Alpha..."),
"RGBA,GRAYA",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC,
"<Image>/Layer/Transparency/Modify");
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
GimpDrawable *drawable;
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Since a channel might be selected, we must check wheter RGB or not. */
if (gimp_layer_get_lock_alpha (drawable->drawable_id))
{
g_message (_("The layer has its alpha channel locked."));
return;
}
if (!gimp_drawable_is_rgb (drawable->drawable_id) &&
!gimp_drawable_is_gray (drawable->drawable_id))
{
g_message (_("RGBA/GRAYA drawable is not selected."));
return;
}
gimp_get_data (PLUG_IN_PROC, &VALS);
if (! threshold_alpha_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 4)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
VALS.threshold = param[3].data.d_int32;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &VALS);
break;
}
if (status == GIMP_PDB_SUCCESS)
{
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
gimp_progress_init (_("Coloring transparency"));
threshold_alpha (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS)
gimp_set_data (PLUG_IN_PROC, &VALS, sizeof (ValueType));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
gimp_drawable_detach (drawable);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
threshold_alpha_func (const guchar *src,
guchar *dest,
gint bpp)
{
for (bpp--; bpp; bpp--)
*dest++ = *src++;
*dest = (VALS.threshold < *src) ? 255 : 0;
}
static void
threshold_alpha (GimpDrawable *drawable,
GimpPreview *preview)
{
if (preview)
{
GimpPixelRgn src_rgn;
guchar *src, *dst;
gint i;
gint x1, y1;
gint width, height;
gint bpp;
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
bpp = drawable->bpp;
src = g_new (guchar, width * height * bpp);
dst = g_new (guchar, width * height * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, width, height,
FALSE, FALSE);
gimp_pixel_rgn_get_rect (&src_rgn, src, x1, y1, width, height);
for (i = 0; i < width * height; i++)
threshold_alpha_func (src + i * bpp, dst + i * bpp, bpp);
gimp_preview_draw_buffer (preview, dst, width * bpp);
g_free (src);
g_free (dst);
}
else
{
gimp_rgn_iterate2 (drawable, 0 /* unused */,
(GimpRgnFunc2)threshold_alpha_func, NULL);
}
}
static gboolean
threshold_alpha_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *table;
GtkObject *adj;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Threshold Alpha"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
preview = gimp_drawable_preview_new (drawable, NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (threshold_alpha),
drawable);
table = gtk_table_new (1 ,3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Threshold:"), SCALE_WIDTH, 0,
VALS.threshold, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&VALS.threshold);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}

1
po-plug-ins/POTFILES.in
View File

@ -132,7 +132,6 @@ plug-ins/common/smooth-palette.c
plug-ins/common/softglow.c
plug-ins/common/sparkle.c
plug-ins/common/sphere-designer.c
plug-ins/common/threshold-alpha.c
plug-ins/common/tile.c
plug-ins/common/tile-glass.c
plug-ins/common/tile-paper.c

48
tools/pdbgen/pdb/plug_in_compat.pdb
View File

@ -224,6 +224,53 @@ CODE
);
}
sub plug_in_threshold_alpha {
$blurb = 'Make transparency all-or-nothing';
$help = <<'HELP';
Make transparency all-or-nothing.
HELP
&std_pdb_misc;
$date = '1997';
@inargs = (
{ name => 'run_mode', type => 'enum GimpRunMode', dead => 1,
desc => 'The run mode' },
{ name => 'image', type => 'image', dead => 1,
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'threshold', type => '0 <= int32 <= 255',
desc => 'Threshold' }
);
%invoke = (
code => <<'CODE'
{
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, TRUE, error) &&
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error) &&
gimp_drawable_has_alpha (drawable))
{
GeglNode *node =
gegl_node_new_child (NULL,
"operation", "gimp:threshold-alpha",
"value", threshold / 255.0,
NULL);
gimp_drawable_apply_operation (drawable, progress,
C_("undo-type", "Threshold Alpha"),
node);
g_object_unref (node);
}
else
success = FALSE;
}
CODE
);
}
sub plug_in_vinvert {
$blurb = 'Invert the brightness of each pixel';
@ -283,6 +330,7 @@ CODE
plug_in_pixelize
plug_in_pixelize2
plug_in_polar_coords
plug_in_threshold_alpha
plug_in_vinvert);
%exports = (app => [@procs], lib => []);