dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Extracted a few reusable routines from several plug-ins and introduced them. The imagemap plug-in now uses the stock Gimp grid icon.

This commit is contained in:
Maurits Rijk 2003-09-13 18:07:44 +00:00
parent b80ed8a525
commit 318e76b790
66 changed files with 744 additions and 909 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
ChangeLog
View File

@ -1,3 +1,66 @@
2003-09-13 Maurits Rijk <lpeek.mrijk@consunet.nl>
* plug-ins/imagemap/grid.xpm: removed
* plug-ins/imagemap/Makefile.am: removed grid.xpm from distribution
* plug-ins/imagemap/imap_stock.[ch]
* plug-ins/imagemap/imap_toolbar.c: use gimp stock icon for grid
2003-09-13 Maurits Rijk <lpeek.mrijk@consunet.nl>
* libgimp/gimpmiscui.[ch]
* libgimp/gimpmisc.[ch]: a few more reusable routines extracted from
several plug-ins.
* plug-ins/common/align_layers.c:
* plug-ins/common/apply_lens.c
* plug-ins/common/blinds.c
* plug-ins/common/blur.c
* plug-ins/common/bumpmap.c
* plug-ins/common/checkerboard.c
* plug-ins/common/cubism.c
* plug-ins/common/despeckle.c
* plug-ins/common/destripe.c
* plug-ins/common/edge.c
* plug-ins/common/emboss.c
* plug-ins/common/engrave.c
* plug-ins/common/gauss_iir.c
* plug-ins/common/gauss_rle.c
* plug-ins/common/glasstile.c
* plug-ins/common/grid.c
* plug-ins/common/illusion.c
* plug-ins/common/jpeg.c
* plug-ins/common/lic.c
* plug-ins/common/mapcolor.c
* plug-ins/common/nlfilt.c
* plug-ins/common/noisify.c
* plug-ins/common/nova.c
* plug-ins/common/oilify.c
* plug-ins/common/pixelize.c
* plug-ins/common/plasma.c
* plug-ins/common/polar.c
* plug-ins/common/randomize.c
* plug-ins/common/ripple.c
* plug-ins/common/scatter_hsv.c
* plug-ins/common/sel_gauss.c
* plug-ins/common/sharpen.c
* plug-ins/common/smooth_palette.c
* plug-ins/common/snoise.c
* plug-ins/common/sobel.c
* plug-ins/common/sparkle.c
* plug-ins/common/struc.c
* plug-ins/common/threshold_alpha.c
* plug-ins/common/tileit.c
* plug-ins/common/unsharp.c
* plug-ins/common/vpropagate.c
* plug-ins/common/waves.c
* plug-ins/common/whirlpinch.c
* plug-ins/common/wind.c
* plug-ins/common/xpm.c: use new stuff from libgimp/gimpmiscui.[ch]
plus some minor cleanup like removing unused header files (for
example signal.h)
2003-09-13 Sven Neumann <sven@gimp.org>
* app/core/core-enums.[ch]

159
libgimp/gimpmisc.c
View File

@ -49,6 +49,12 @@ struct _GimpPixelFetcher
gboolean shadow;
};
struct _GimpRgnIterator
{
GimpDrawable *drawable;
gint x1, y1, x2, y2;
GimpRunMode run_mode;
};
GimpPixelFetcher *
gimp_pixel_fetcher_new (GimpDrawable *drawable)
@ -258,6 +264,39 @@ gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf)
g_free (pf);
}
static void
gimp_get_color_guchar (GimpDrawable *drawable,
GimpRGB *color,
gboolean transparent,
guchar *bg)
{
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]);
bg[3] = 255;
break;
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]);
bg[3] = transparent ? 0 : 255;
break;
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = 255;
break;
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = transparent ? 0 : 255;
break;
default:
break;
}
}
void
gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
@ -266,34 +305,108 @@ gimp_get_bg_guchar (GimpDrawable *drawable,
GimpRGB background;
gimp_palette_get_background (&background);
gimp_get_color_guchar (drawable, &background, transparent, bg);
}
switch (gimp_drawable_type (drawable->drawable_id))
void
gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg)
{
GimpRGB foreground;
gimp_palette_get_foreground (&foreground);
gimp_get_color_guchar (drawable, &foreground, transparent, fg);
}
GimpRgnIterator*
gimp_rgn_iterator_new (GimpDrawable *drawable, GimpRunMode run_mode)
{
GimpRgnIterator *iter = g_new (GimpRgnIterator, 1);
iter->drawable = drawable;
iter->run_mode = run_mode;
gimp_drawable_mask_bounds (drawable->drawable_id, &iter->x1, &iter->y1,
&iter->x2, &iter->y2);
return iter;
}
void
gimp_rgn_iterator_free (GimpRgnIterator *iter)
{
g_free (iter);
}
static void
gimp_rgn_iterator_iter_single (GimpRgnIterator *iter, GimpPixelRgn *srcPR,
GimpRgnFuncSrc func, gpointer data)
{
gpointer pr;
gint total_area, area_so_far;
total_area = (iter->x2 - iter->x1) * (iter->y2 - iter->y1);
area_so_far = 0;
for (pr = gimp_pixel_rgns_register (1, srcPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
bg[3] = 255;
break;
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
bg[3] = transparent ? 0 : 255;
break;
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (&background);
bg[1] = 255;
break;
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (&background);
bg[1] = transparent ? 0 : 255;
break;
default:
break;
guchar *src = srcPR->data;
gint y;
for (y = srcPR->y; y < srcPR->y + srcPR->h; y++)
{
guchar *s = src;
gint x;
for (x = srcPR->x; x < srcPR->x + srcPR->w; x++)
{
func (x, y, s, srcPR->bpp, data);
s += srcPR->bpp;
}
src += srcPR->rowstride;
}
if (iter->run_mode != GIMP_RUN_NONINTERACTIVE)
{
area_so_far += srcPR->w * srcPR->h;
gimp_progress_update ((gdouble) area_so_far /
(gdouble) total_area);
}
}
}
void
gimp_rgn_iterator_src (GimpRgnIterator *iter, GimpRgnFuncSrc func,
gpointer data)
{
GimpPixelRgn srcPR;
gimp_pixel_rgn_init (&srcPR, iter->drawable, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1, FALSE, FALSE);
gimp_rgn_iterator_iter_single (iter, &srcPR, func, data);
}
void
gimp_rgn_iterator_dest (GimpRgnIterator *iter,
GimpRgnFuncDest func,
gpointer data)
{
GimpPixelRgn destPR;
gimp_pixel_rgn_init (&destPR, iter->drawable, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1, TRUE, TRUE);
gimp_rgn_iterator_iter_single (iter, &destPR, func, data);
/* update the processed region */
gimp_drawable_flush (iter->drawable);
gimp_drawable_merge_shadow (iter->drawable->drawable_id, TRUE);
gimp_drawable_update (iter->drawable->drawable_id, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1);
}
static void
gimp_rgn_render_row (guchar *src,
guchar *dest,

21
libgimp/gimpmisc.h
View File

@ -39,7 +39,7 @@ enum
};
typedef struct _GimpPixelFetcher GimpPixelFetcher;
typedef struct _GimpRgnIterator GimpRgnIterator;
GimpPixelFetcher * gimp_pixel_fetcher_new (GimpDrawable *drawable);
void gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf);
@ -64,6 +64,9 @@ void gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf);
void gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *bg);
void gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg);
typedef void (* GimpRgnFunc1) (const guchar *src,
@ -73,6 +76,22 @@ typedef void (* GimpRgnFunc2) (const guchar *src,
guchar *dest,
gint bpp,
gpointer data);
typedef void (* GimpRgnFuncSrc) (gint x,
gint y,
guchar *src,
gint bpp,
gpointer data);
typedef GimpRgnFuncSrc GimpRgnFuncDest;
GimpRgnIterator *gimp_rgn_iterator_new (GimpDrawable *drawable,
GimpRunMode run_mode);
void gimp_rgn_iterator_free (GimpRgnIterator *iter);
void gimp_rgn_iterator_src (GimpRgnIterator *iter,
GimpRgnFuncSrc func,
gpointer data);
void gimp_rgn_iterator_dest (GimpRgnIterator *iter,
GimpRgnFuncDest func,
gpointer data);
void gimp_rgn_iterate1 (GimpDrawable *drawable,
GimpRunMode run_mode,

31
libgimp/gimpmiscui.c
View File

@ -546,3 +546,34 @@ gimp_plug_in_get_path (const gchar *path_name,
return path;
}
GtkWidget*
gimp_parameter_settings_new (GtkWidget *parent,
guint rows,
guint columns)
{
GtkWidget *frame, *table;
frame = gtk_frame_new ( _("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start ( GTK_BOX (parent), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
if (rows && columns)
{
table = gtk_table_new (rows, columns, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
}
else
{
table = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
}
gtk_widget_show (table);
return table;
}

4
libgimp/gimpmiscui.h
View File

@ -98,6 +98,10 @@ gchar * gimp_plug_in_get_path (const gchar *path_name,
const gchar *dir_name);
GtkWidget *gimp_parameter_settings_new (GtkWidget *parent,
guint rows,
guint columns);
G_END_DECLS
#endif /* __GIMP_MISCUI_H__ */

159
libgimp/gimppixelfetcher.c
View File

@ -49,6 +49,12 @@ struct _GimpPixelFetcher
gboolean shadow;
};
struct _GimpRgnIterator
{
GimpDrawable *drawable;
gint x1, y1, x2, y2;
GimpRunMode run_mode;
};
GimpPixelFetcher *
gimp_pixel_fetcher_new (GimpDrawable *drawable)
@ -258,6 +264,39 @@ gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf)
g_free (pf);
}
static void
gimp_get_color_guchar (GimpDrawable *drawable,
GimpRGB *color,
gboolean transparent,
guchar *bg)
{
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]);
bg[3] = 255;
break;
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]);
bg[3] = transparent ? 0 : 255;
break;
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = 255;
break;
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = transparent ? 0 : 255;
break;
default:
break;
}
}
void
gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
@ -266,34 +305,108 @@ gimp_get_bg_guchar (GimpDrawable *drawable,
GimpRGB background;
gimp_palette_get_background (&background);
gimp_get_color_guchar (drawable, &background, transparent, bg);
}
switch (gimp_drawable_type (drawable->drawable_id))
void
gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg)
{
GimpRGB foreground;
gimp_palette_get_foreground (&foreground);
gimp_get_color_guchar (drawable, &foreground, transparent, fg);
}
GimpRgnIterator*
gimp_rgn_iterator_new (GimpDrawable *drawable, GimpRunMode run_mode)
{
GimpRgnIterator *iter = g_new (GimpRgnIterator, 1);
iter->drawable = drawable;
iter->run_mode = run_mode;
gimp_drawable_mask_bounds (drawable->drawable_id, &iter->x1, &iter->y1,
&iter->x2, &iter->y2);
return iter;
}
void
gimp_rgn_iterator_free (GimpRgnIterator *iter)
{
g_free (iter);
}
static void
gimp_rgn_iterator_iter_single (GimpRgnIterator *iter, GimpPixelRgn *srcPR,
GimpRgnFuncSrc func, gpointer data)
{
gpointer pr;
gint total_area, area_so_far;
total_area = (iter->x2 - iter->x1) * (iter->y2 - iter->y1);
area_so_far = 0;
for (pr = gimp_pixel_rgns_register (1, srcPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
bg[3] = 255;
break;
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
bg[3] = transparent ? 0 : 255;
break;
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (&background);
bg[1] = 255;
break;
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (&background);
bg[1] = transparent ? 0 : 255;
break;
default:
break;
guchar *src = srcPR->data;
gint y;
for (y = srcPR->y; y < srcPR->y + srcPR->h; y++)
{
guchar *s = src;
gint x;
for (x = srcPR->x; x < srcPR->x + srcPR->w; x++)
{
func (x, y, s, srcPR->bpp, data);
s += srcPR->bpp;
}
src += srcPR->rowstride;
}
if (iter->run_mode != GIMP_RUN_NONINTERACTIVE)
{
area_so_far += srcPR->w * srcPR->h;
gimp_progress_update ((gdouble) area_so_far /
(gdouble) total_area);
}
}
}
void
gimp_rgn_iterator_src (GimpRgnIterator *iter, GimpRgnFuncSrc func,
gpointer data)
{
GimpPixelRgn srcPR;
gimp_pixel_rgn_init (&srcPR, iter->drawable, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1, FALSE, FALSE);
gimp_rgn_iterator_iter_single (iter, &srcPR, func, data);
}
void
gimp_rgn_iterator_dest (GimpRgnIterator *iter,
GimpRgnFuncDest func,
gpointer data)
{
GimpPixelRgn destPR;
gimp_pixel_rgn_init (&destPR, iter->drawable, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1, TRUE, TRUE);
gimp_rgn_iterator_iter_single (iter, &destPR, func, data);
/* update the processed region */
gimp_drawable_flush (iter->drawable);
gimp_drawable_merge_shadow (iter->drawable->drawable_id, TRUE);
gimp_drawable_update (iter->drawable->drawable_id, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1);
}
static void
gimp_rgn_render_row (guchar *src,
guchar *dest,

21
libgimp/gimppixelfetcher.h
View File

@ -39,7 +39,7 @@ enum
};
typedef struct _GimpPixelFetcher GimpPixelFetcher;
typedef struct _GimpRgnIterator GimpRgnIterator;
GimpPixelFetcher * gimp_pixel_fetcher_new (GimpDrawable *drawable);
void gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf);
@ -64,6 +64,9 @@ void gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf);
void gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *bg);
void gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg);
typedef void (* GimpRgnFunc1) (const guchar *src,
@ -73,6 +76,22 @@ typedef void (* GimpRgnFunc2) (const guchar *src,
guchar *dest,
gint bpp,
gpointer data);
typedef void (* GimpRgnFuncSrc) (gint x,
gint y,
guchar *src,
gint bpp,
gpointer data);
typedef GimpRgnFuncSrc GimpRgnFuncDest;
GimpRgnIterator *gimp_rgn_iterator_new (GimpDrawable *drawable,
GimpRunMode run_mode);
void gimp_rgn_iterator_free (GimpRgnIterator *iter);
void gimp_rgn_iterator_src (GimpRgnIterator *iter,
GimpRgnFuncSrc func,
gpointer data);
void gimp_rgn_iterator_dest (GimpRgnIterator *iter,
GimpRgnFuncDest func,
gpointer data);
void gimp_rgn_iterate1 (GimpDrawable *drawable,
GimpRunMode run_mode,

159
libgimp/gimpregioniterator.c
View File

@ -49,6 +49,12 @@ struct _GimpPixelFetcher
gboolean shadow;
};
struct _GimpRgnIterator
{
GimpDrawable *drawable;
gint x1, y1, x2, y2;
GimpRunMode run_mode;
};
GimpPixelFetcher *
gimp_pixel_fetcher_new (GimpDrawable *drawable)
@ -258,6 +264,39 @@ gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf)
g_free (pf);
}
static void
gimp_get_color_guchar (GimpDrawable *drawable,
GimpRGB *color,
gboolean transparent,
guchar *bg)
{
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]);
bg[3] = 255;
break;
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]);
bg[3] = transparent ? 0 : 255;
break;
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = 255;
break;
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = transparent ? 0 : 255;
break;
default:
break;
}
}
void
gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
@ -266,34 +305,108 @@ gimp_get_bg_guchar (GimpDrawable *drawable,
GimpRGB background;
gimp_palette_get_background (&background);
gimp_get_color_guchar (drawable, &background, transparent, bg);
}
switch (gimp_drawable_type (drawable->drawable_id))
void
gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg)
{
GimpRGB foreground;
gimp_palette_get_foreground (&foreground);
gimp_get_color_guchar (drawable, &foreground, transparent, fg);
}
GimpRgnIterator*
gimp_rgn_iterator_new (GimpDrawable *drawable, GimpRunMode run_mode)
{
GimpRgnIterator *iter = g_new (GimpRgnIterator, 1);
iter->drawable = drawable;
iter->run_mode = run_mode;
gimp_drawable_mask_bounds (drawable->drawable_id, &iter->x1, &iter->y1,
&iter->x2, &iter->y2);
return iter;
}
void
gimp_rgn_iterator_free (GimpRgnIterator *iter)
{
g_free (iter);
}
static void
gimp_rgn_iterator_iter_single (GimpRgnIterator *iter, GimpPixelRgn *srcPR,
GimpRgnFuncSrc func, gpointer data)
{
gpointer pr;
gint total_area, area_so_far;
total_area = (iter->x2 - iter->x1) * (iter->y2 - iter->y1);
area_so_far = 0;
for (pr = gimp_pixel_rgns_register (1, srcPR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
bg[3] = 255;
break;
case GIMP_RGBA_IMAGE:
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
bg[3] = transparent ? 0 : 255;
break;
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (&background);
bg[1] = 255;
break;
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (&background);
bg[1] = transparent ? 0 : 255;
break;
default:
break;
guchar *src = srcPR->data;
gint y;
for (y = srcPR->y; y < srcPR->y + srcPR->h; y++)
{
guchar *s = src;
gint x;
for (x = srcPR->x; x < srcPR->x + srcPR->w; x++)
{
func (x, y, s, srcPR->bpp, data);
s += srcPR->bpp;
}
src += srcPR->rowstride;
}
if (iter->run_mode != GIMP_RUN_NONINTERACTIVE)
{
area_so_far += srcPR->w * srcPR->h;
gimp_progress_update ((gdouble) area_so_far /
(gdouble) total_area);
}
}
}
void
gimp_rgn_iterator_src (GimpRgnIterator *iter, GimpRgnFuncSrc func,
gpointer data)
{
GimpPixelRgn srcPR;
gimp_pixel_rgn_init (&srcPR, iter->drawable, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1, FALSE, FALSE);
gimp_rgn_iterator_iter_single (iter, &srcPR, func, data);
}
void
gimp_rgn_iterator_dest (GimpRgnIterator *iter,
GimpRgnFuncDest func,
gpointer data)
{
GimpPixelRgn destPR;
gimp_pixel_rgn_init (&destPR, iter->drawable, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1, TRUE, TRUE);
gimp_rgn_iterator_iter_single (iter, &destPR, func, data);
/* update the processed region */
gimp_drawable_flush (iter->drawable);
gimp_drawable_merge_shadow (iter->drawable->drawable_id, TRUE);
gimp_drawable_update (iter->drawable->drawable_id, iter->x1, iter->y1,
iter->x2 - iter->x1, iter->y2 - iter->y1);
}
static void
gimp_rgn_render_row (guchar *src,
guchar *dest,

21
libgimp/gimpregioniterator.h
View File

@ -39,7 +39,7 @@ enum
};
typedef struct _GimpPixelFetcher GimpPixelFetcher;
typedef struct _GimpRgnIterator GimpRgnIterator;
GimpPixelFetcher * gimp_pixel_fetcher_new (GimpDrawable *drawable);
void gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf);
@ -64,6 +64,9 @@ void gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf);
void gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *bg);
void gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg);
typedef void (* GimpRgnFunc1) (const guchar *src,
@ -73,6 +76,22 @@ typedef void (* GimpRgnFunc2) (const guchar *src,
guchar *dest,
gint bpp,
gpointer data);
typedef void (* GimpRgnFuncSrc) (gint x,
gint y,
guchar *src,
gint bpp,
gpointer data);
typedef GimpRgnFuncSrc GimpRgnFuncDest;
GimpRgnIterator *gimp_rgn_iterator_new (GimpDrawable *drawable,
GimpRunMode run_mode);
void gimp_rgn_iterator_free (GimpRgnIterator *iter);
void gimp_rgn_iterator_src (GimpRgnIterator *iter,
GimpRgnFuncSrc func,
gpointer data);
void gimp_rgn_iterator_dest (GimpRgnIterator *iter,
GimpRgnFuncDest func,
gpointer data);
void gimp_rgn_iterate1 (GimpDrawable *drawable,
GimpRunMode run_mode,

14
plug-ins/common/align_layers.c
View File

@ -425,17 +425,7 @@ align_layers_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (7, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 7, 3);
optionmenu =
gimp_option_menu_new2 (FALSE, G_CALLBACK (gimp_menu_item_update),
@ -535,8 +525,6 @@ align_layers_dialog (void)
G_CALLBACK (gimp_int_adjustment_update),
&VALS.grid_size);
gtk_widget_show (table);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

12
plug-ins/common/apply_lens.c
View File

@ -374,7 +374,6 @@ lens_dialog (GimpDrawable *drawable)
GtkWidget *dlg;
GtkWidget *label;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *sep;
GtkWidget *hbox;
@ -400,14 +399,7 @@ lens_dialog (GimpDrawable *drawable)
G_CALLBACK (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
toggle = gtk_radio_button_new_with_mnemonic_from_widget
(NULL, _("_Keep Original Surroundings"));
@ -469,8 +461,6 @@ lens_dialog (GimpDrawable *drawable)
&lvals.refraction);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

12
plug-ins/common/blinds.c
View File

@ -343,17 +343,7 @@ blinds_dialog (void)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE);
}
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (main_vbox, 2, 3);
size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Displacement:"), SCALE_WIDTH, 0,

15
plug-ins/common/blur.c
View File

@ -579,7 +579,6 @@ static gint
blur_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *label;
GtkWidget *seed_hbox;
@ -609,17 +608,7 @@ blur_dialog (void)
*
* First set up the basic containers, label them, etc.
*/
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER(frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 3, 3);
/* Random Seed */
seed_hbox = gimp_random_seed_new (&pivals.blur_seed);
@ -653,8 +642,6 @@ blur_dialog (void)
G_CALLBACK (gimp_double_adjustment_update),
&pivals.blur_rcount);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

9
plug-ins/common/bumpmap.c
View File

@ -1015,14 +1015,7 @@ bumpmap_dialog (void)
G_CALLBACK (dialog_tiled_callback),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (top_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
vbox = gimp_parameter_settings_new (top_vbox, 0, 0);
/* Bump map menu */
table = gtk_table_new (1, 2, FALSE);

159
plug-ins/common/checkerboard.c
View File

@ -48,6 +48,8 @@ static CheckInterface cint =
FALSE
};
static GimpRunMode run_mode;
static void query (void);
static void run (const gchar *name,
gint nparams,
@ -118,7 +120,6 @@ run (const gchar *name,
static GimpParam values[1];
GimpDrawable *drawable;
gint32 image_ID;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
INIT_I18N ();
@ -186,57 +187,52 @@ run (const gchar *name,
gimp_drawable_detach (drawable);
}
typedef struct {
guchar fg[4];
guchar bg[4];
} CheckerboardParam_t;
static void
checkerboard_func (gint x,
gint y,
guchar *dest,
gint bpp,
gpointer data)
{
CheckerboardParam_t *param = (CheckerboardParam_t*) data;
gint val, xp, yp;
gint b;
if (cvals.mode)
{
/* Psychobilly Mode */
val = (inblock (x, cvals.size) != inblock (y, cvals.size));
}
else
{
/* Normal, regular checkerboard mode.
* Determine base factor (even or odd) of block
* this x/y position is in.
*/
xp = x / cvals.size;
yp = y / cvals.size;
/* if both even or odd, color sqr */
val = ( (xp & 1) != (yp & 1) );
}
for (b = 0; b < bpp; b++)
dest[b] = val ? param->fg[b] : param->bg[b];
}
static void
do_checkerboard_pattern (GimpDrawable *drawable)
{
GimpPixelRgn dest_rgn;
guchar *dest_row;
guchar *dest;
gint row, col;
gint progress, max_progress;
gint x1, y1, x2, y2, x, y;
GimpRGB foreground;
GimpRGB background;
guchar fg[4];
guchar bg[4];
gint bp;
gpointer pr;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE);
progress = 0;
max_progress = (x2 - x1) * (y2 - y1);
/* Get the foreground and background colors */
gimp_palette_get_foreground (&foreground);
gimp_palette_get_background (&background);
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGBA_IMAGE:
fg[3] = 255;
bg[3] = 255;
case GIMP_RGB_IMAGE:
gimp_rgb_get_uchar (&foreground, &fg[0], &fg[1], &fg[2]);
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
break;
case GIMP_GRAYA_IMAGE:
fg[1] = 255;
bg[1] = 255;
case GIMP_GRAY_IMAGE:
fg[0] = gimp_rgb_intensity_uchar (&foreground);
bg[0] = gimp_rgb_intensity_uchar (&background);
break;
default:
break;
}
CheckerboardParam_t param;
GimpRgnIterator *iter;
gimp_get_bg_guchar (drawable, FALSE, param.bg);
gimp_get_fg_guchar (drawable, FALSE, param.fg);
if (cvals.size < 1)
{
@ -244,59 +240,9 @@ do_checkerboard_pattern (GimpDrawable *drawable)
cvals.size = 1;
}
for (pr = gimp_pixel_rgns_register (1, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
y = dest_rgn.y;
dest_row = dest_rgn.data;
for ( row = 0; row < dest_rgn.h; row++)
{
dest = dest_row;
x = dest_rgn.x;
for (col = 0; col < dest_rgn.w; col++)
{
gint val, xp, yp;
if (cvals.mode)
{
/* Psychobilly Mode */
val = ((inblock (x, cvals.size) == inblock (y, cvals.size))
? 0 : 1);
}
else
{
/* Normal, regular checkerboard mode.
* Determine base factor (even or odd) of block
* this x/y position is in.
*/
xp = x / cvals.size;
yp = y / cvals.size;
/* if both even or odd, color sqr */
val = ( (xp&1) == (yp&1) ) ? 0 : 1;
}
for (bp = 0; bp < dest_rgn.bpp; bp++)
dest[bp] = val ? fg[bp] : bg[bp];
dest += dest_rgn.bpp;
x++;
}
dest_row += dest_rgn.rowstride;
y++;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
iter = gimp_rgn_iterator_new (drawable, run_mode);
gimp_rgn_iterator_dest (iter, checkerboard_func, &param);
gimp_rgn_iterator_free (iter);
}
static gint
@ -355,7 +301,6 @@ do_checkerboard_dialog (gint32 image_ID,
GimpDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *toggle;
GtkWidget *size_entry;
@ -391,16 +336,7 @@ do_checkerboard_dialog (gint32 image_ID,
height = gimp_drawable_height (drawable->drawable_id);
size = MIN (width, height);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
toggle = gtk_check_button_new_with_mnemonic (_("_Psychobilly"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
@ -458,7 +394,6 @@ check_size_update_callback(GtkWidget * widget, gpointer data)
cvals.size = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0);
}
static void
check_ok_callback (GtkWidget *widget,
gpointer data)

16
plug-ins/common/cubism.c
View File

@ -255,7 +255,6 @@ cubism_dialog (void)
{
GtkWidget *dlg;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *table;
GtkObject *scale_data;
@ -277,18 +276,8 @@ cubism_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 2, 3);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
toggle = gtk_check_button_new_with_mnemonic (_("_Use Background Color"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 3, 0, 1,
@ -321,9 +310,6 @@ cubism_dialog (void)
G_CALLBACK (gimp_double_adjustment_update),
&cvals.tile_saturation);
gtk_widget_show (table);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

11
plug-ins/common/despeckle.c
View File

@ -734,16 +734,7 @@ despeckle_dialog (void)
G_CALLBACK (dialog_recursive_callback),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (main_vbox, 3, 3);
/*
* Box size (radius) control...

11
plug-ins/common/destripe.c
View File

@ -636,16 +636,7 @@ destripe_dialog (void)
* Filter type controls...
*/
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (vbox, 2, 3);
button = gtk_check_button_new_with_mnemonic (_("Create _Histogram"));
gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 3, 0, 1);

12
plug-ins/common/edge.c
View File

@ -697,17 +697,7 @@ edge_dialog (GimpDrawable *drawable)
gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame);
gtk_widget_show (frame);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 2, 3);
/* Label, scale, entry for evals.amount */
scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,

11
plug-ins/common/emboss.c
View File

@ -539,16 +539,7 @@ pluginCoreIA (piArgs *argp)
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 3, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Azimuth:"), 100, 6,

15
plug-ins/common/engrave.c
View File

@ -207,7 +207,6 @@ static gint
engrave_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkObject *adj;
@ -230,17 +229,7 @@ engrave_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 2, 3);
toggle = gtk_check_button_new_with_mnemonic (_("_Limit Line Width"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
@ -260,8 +249,6 @@ engrave_dialog (void)
G_CALLBACK (gimp_int_adjustment_update),
&pvals.height);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();

13
plug-ins/common/gauss_iir.c
View File

@ -341,7 +341,6 @@ gauss_iir_dialog (void)
GtkWidget *spinbutton;
GtkObject *adj;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
@ -364,15 +363,7 @@ gauss_iir_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
toggle = gtk_check_button_new_with_label (_("Blur Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
@ -410,8 +401,6 @@ gauss_iir_dialog (void)
&bvals.radius);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

13
plug-ins/common/gauss_rle.c
View File

@ -335,7 +335,6 @@ gauss_rle_dialog (void)
GtkWidget *spinbutton;
GtkObject *adj;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
@ -358,15 +357,7 @@ gauss_rle_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
toggle = gtk_check_button_new_with_label (_("Blur Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
@ -404,8 +395,6 @@ gauss_rle_dialog (void)
&bvals.radius);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

14
plug-ins/common/glasstile.c
View File

@ -228,7 +228,6 @@ glass_dialog (GimpDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *table;
GtkObject *adj;
@ -261,18 +260,7 @@ glass_dialog (GimpDrawable *drawable)
gtk_widget_show (preview->widget);
glasstile (drawable, TRUE); /* filter routine, initial pass */
/* Parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (main_vbox, 2, 3);
/* Horizontal scale - Width */
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,

10
plug-ins/common/grid.c
View File

@ -696,15 +696,7 @@ dialog (gint32 image_ID,
/* left side of the UI is done */
/* right side */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_container_add (GTK_CONTAINER (frame), main_vbox);
gtk_widget_show (main_vbox);
main_vbox = gimp_parameter_settings_new (main_hbox, 0, 0);
/* The width entries */
width = gimp_size_entry_new (3, /* number_of_fields */

12
plug-ins/common/illusion.c
View File

@ -382,7 +382,6 @@ dialog (GimpDrawable *mangle)
{
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *spinbutton;
GtkObject *adj;
@ -419,16 +418,7 @@ dialog (GimpDrawable *mangle)
filter_preview();
gtk_widget_show (preview->widget);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (main_vbox, 3, 2);
spinbutton = gimp_spin_button_new (&adj, parameters.division,
-32, 64, 1, 10, 0, 1, 0);

13
plug-ins/common/jpeg.c
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

10
plug-ins/common/lic.c
View File

@ -38,7 +38,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <gtk/gtk.h>
@ -768,14 +767,7 @@ create_main_dialog (void)
gtk_container_add (GTK_CONTAINER (hbox), frame);
gtk_widget_show (frame);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
vbox = gimp_parameter_settings_new (main_vbox, 0, 0);
/* Effect image menu */
table = gtk_table_new (1, 2, FALSE);

183
plug-ins/common/mapcolor.c
View File

@ -92,7 +92,7 @@ typedef struct
IMG_PREVIEW *map_preview;
} PLInterface;
static guchar redmap[256], greenmap[256], bluemap[256];
static gboolean run_flag = FALSE;
/* Declare some local functions.
@ -161,36 +161,24 @@ img_preview_alloc (guint width,
IMG_PREVIEW *ip;
ip = g_new (IMG_PREVIEW, 1);
ip->img = g_new (guchar, width*height*3);
if (ip->img == NULL)
{
g_free (ip);
return NULL;
}
ip->img = g_new (guchar, width * height*3);
ip->width = width;
ip->height = height;
return ip;
}
/* Free image preview */
static void
img_preview_free (IMG_PREVIEW *ip)
{
if (ip)
{
if (ip->img)
{
g_free (ip->img);
ip->img = NULL;
}
ip->width = ip->height = 0;
g_free (ip);
}
if (ip)
{
g_free (ip->img);
g_free (ip);
}
}
/* Copy image preview. Create/modify destination preview */
static void
img_preview_copy (IMG_PREVIEW *src,
@ -199,41 +187,38 @@ img_preview_copy (IMG_PREVIEW *src,
{
gint numbytes;
IMG_PREVIEW *dst_p;
if ((src == NULL) || (src->img == NULL) || (dst == NULL)) return;
numbytes = src->width * src->height * 3; /* 1 byte spare */
if (numbytes <= 0) return;
if (*dst == NULL) /* Create new preview ? */
{
*dst = img_preview_alloc (src->width, src->height);
if (*dst == NULL) return;
memcpy ((*dst)->img, src->img, numbytes);
return;
}
/* destination preview already exists */
dst_p = *dst;
/* Did not already allocate enough memory ? */
if ((dst_p->img != NULL) && (dst_p->width*dst_p->height*3 < numbytes))
{
g_free (dst_p->img);
dst_p->width = dst_p->height = 0;
dst_p->img = NULL;
}
if (dst_p->img == NULL)
{
dst_p->img = (guchar *)g_malloc (numbytes);
if (dst_p->img == NULL) return;
}
dst_p->width = src->width;
dst_p->height = src->height;
memcpy (dst_p->img, src->img, numbytes);
if ((src == NULL) || (src->img == NULL) || (dst == NULL)) return;
numbytes = src->width * src->height * 3; /* 1 byte spare */
if (numbytes <= 0) return;
if (*dst == NULL) /* Create new preview ? */
{
*dst = img_preview_alloc (src->width, src->height);
memcpy ((*dst)->img, src->img, numbytes);
return;
}
/* destination preview already exists */
dst_p = *dst;
/* Did not already allocate enough memory ? */
if ((dst_p->img != NULL) && (dst_p->width*dst_p->height*3 < numbytes))
{
g_free (dst_p->img);
dst_p->width = dst_p->height = 0;
dst_p->img = NULL;
}
if (dst_p->img == NULL)
{
dst_p->img = (guchar *)g_malloc (numbytes);
}
dst_p->width = src->width;
dst_p->height = src->height;
memcpy (dst_p->img, src->img, numbytes);
}
static IMG_PREVIEW *
img_preview_create_from_drawable (guint maxsize,
gint32 drawable_ID)
@ -315,7 +300,6 @@ img_preview_create_from_drawable (guint maxsize,
return ip;
}
MAIN ()
static void
@ -636,24 +620,17 @@ add_color_button (gint csel_index,
gint left,
gint top,
GtkWidget *table)
{
GtkWidget *label;
GtkWidget *button;
label = gtk_label_new ((left == 0) ? _("From:") : _("To:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, left, left+1, top, top+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
button = gimp_color_button_new (gettext (csel_title[csel_index]),
PRV_WIDTH, PRV_HEIGHT,
&plvals.colors[csel_index],
GIMP_COLOR_AREA_FLAT);
gtk_table_attach (GTK_TABLE (table), button, left+1, left+2, top, top+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
gimp_table_attach_aligned (GTK_TABLE (table), left + 1, top,
(left == 0) ? _("From:") : _("To:"),
1.0, 0.5,
button, 1, TRUE);
g_signal_connect (button, "color_changed",
G_CALLBACK (gimp_color_button_get_color),
@ -663,11 +640,9 @@ add_color_button (gint csel_index,
NULL);
}
static void
mapcolor_ok_callback (GtkWidget *widget,
gpointer data)
{
plvals.map_mode = 0; /* Currently always linear mapping */
@ -687,13 +662,12 @@ get_mapping (GimpRGB *src_col1,
guchar *redmap,
guchar *greenmap,
guchar *bluemap)
{
guchar src1[3];
guchar src2[3];
guchar dst1[3];
guchar dst2[3];
gint rgb, i, j, a, as, b, bs;
gint rgb, i, a, as, b, bs;
guchar *colormap[3];
/* Currently we always do a linear mapping */
@ -720,29 +694,31 @@ get_mapping (GimpRGB *src_col1,
b = a + 1;
for (i = 0; i < 256; i++)
{
j = CLAMP (((i - a) * (bs - as)) / (b - a) + as, 0, 255);
colormap[rgb][i] = j;
gint j = ((i - a) * (bs - as)) / (b - a) + as;
colormap[rgb][i] = CLAMP0255(j);
}
}
break;
}
}
static void
mapcolor_func (const guchar *src,
guchar *dest,
gint bpp,
gpointer data)
{
dest[0] = redmap[src[0]];
dest[1] = greenmap[src[1]];
dest[2] = bluemap[src[2]];
if (bpp > 3)
dest[3] = src[3];
}
static void
color_mapping (GimpDrawable *drawable)
{
gint processed, total;
gint x, y, xmin, xmax, ymin, ymax;
guint bpp = drawable->bpp;
guchar *src;
guchar *dest;
GimpPixelRgn src_rgn;
GimpPixelRgn dest_rgn;
gpointer pr;
gdouble progress;
guchar redmap[256], greenmap[256], bluemap[256];
if (gimp_rgb_distance (&plvals.colors[0], &plvals.colors[1]) < 0.0001)
return;
@ -751,18 +727,8 @@ color_mapping (GimpDrawable *drawable)
g_message (_("Color Mapping / Adjust FG/BG:\nCannot operate on gray/indexed images"));
return;
}
gimp_drawable_mask_bounds (drawable->drawable_id, &xmin, &ymin, &xmax, &ymax);
if ((ymin == ymax) || (xmin == xmax)) return;
total = (xmax - xmin) * (ymax - ymin);
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
gimp_pixel_rgn_init (&src_rgn, drawable, xmin, ymin,
(xmax - xmin), (ymax - ymin), FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable, xmin, ymin,
(xmax - xmin), (ymax - ymin), TRUE, TRUE);
pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
get_mapping (plvals.colors,
plvals.colors + 1,
@ -771,38 +737,5 @@ color_mapping (GimpDrawable *drawable)
plvals.map_mode,
redmap, greenmap, bluemap);
processed = 0;
progress = 0.0;
for (; pr != NULL; pr = gimp_pixel_rgns_process (pr))
{
for (y = 0; y < src_rgn.h; y++)
{
src = src_rgn.data + y * src_rgn.rowstride;
dest = dest_rgn.data + y * dest_rgn.rowstride;
for (x = 0; x < src_rgn.w; x++)
{
dest[0] = redmap[src[0]];
dest[1] = greenmap[src[1]];
dest[2] = bluemap[src[2]];
if (bpp > 3) dest[3] = src[3];
src += bpp;
dest += bpp;
processed++;
}
}
if ((gdouble) processed / (gdouble) total - progress > 0.1)
{
progress = (gdouble) processed / (gdouble) total;
gimp_progress_update (progress);
}
}
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
xmin, ymin, (xmax - xmin), (ymax - ymin));
gimp_rgn_iterate2 (drawable, l_run_mode, mapcolor_func, NULL);
}

13
plug-ins/common/nlfilt.c
View File

@ -373,16 +373,7 @@ pluginCoreIA (piArgs *argp, GimpDrawable *drawable)
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 2, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("A_lpha:"), 0, 0,
@ -402,8 +393,6 @@ pluginCoreIA (piArgs *argp, GimpDrawable *drawable)
G_CALLBACK (nlfilt_double_adjustment_update),
&argp->radius);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();

16
plug-ins/common/noisify.c
View File

@ -303,7 +303,6 @@ noisify_dialog (GimpDrawable *drawable,
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *table;
gimp_ui_init ("noisify", FALSE);
@ -337,17 +336,9 @@ noisify_dialog (GimpDrawable *drawable,
noisify (drawable, TRUE); /* preview noisify */
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (channels + 1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox,
channels + 1, 3);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
toggle = gtk_check_button_new_with_mnemonic (_("_Independent"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
@ -398,9 +389,6 @@ noisify_dialog (GimpDrawable *drawable,
}
}
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();

15
plug-ins/common/nova.c
View File

@ -319,7 +319,6 @@ static gint
nova_dialog (GimpDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *button;
GtkWidget *center_frame;
@ -343,17 +342,7 @@ nova_dialog (GimpDrawable *drawable)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (5, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 5, 3);
center_frame = nova_center_create (drawable);
gtk_table_attach (GTK_TABLE (table), center_frame, 0, 3, 0, 1,
@ -407,8 +396,6 @@ nova_dialog (GimpDrawable *drawable)
G_CALLBACK (nova),
drawable);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();

15
plug-ins/common/oilify.c
View File

@ -442,7 +442,6 @@ static gint
oilify_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkObject *adj;
@ -465,17 +464,7 @@ oilify_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 2, 3);
toggle = gtk_check_button_new_with_mnemonic (_("_Use Intensity Algorithm"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
@ -495,8 +484,6 @@ oilify_dialog (void)
G_CALLBACK (gimp_double_adjustment_update),
&ovals.mask_size);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();

12
plug-ins/common/pixelize.c
View File

@ -310,7 +310,6 @@ static gint
pixelize_dialog (GimpDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *vbox;
guint32 image_id;
GimpUnit unit;
@ -336,16 +335,7 @@ pixelize_dialog (GimpDrawable *drawable)
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
image_id = gimp_drawable_image (drawable->drawable_id);
unit = gimp_image_get_unit (image_id);

13
plug-ins/common/plasma.c
View File

@ -298,7 +298,6 @@ plasma_dialog (GimpDrawable *drawable,
{
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *table;
GtkWidget *seed;
@ -335,17 +334,7 @@ plasma_dialog (GimpDrawable *drawable,
gtk_widget_show (preview->widget);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (main_vbox, 2, 3);
seed = gimp_random_seed_new (&pvals.seed);
label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,

10
plug-ins/common/polar.c
View File

@ -58,7 +58,6 @@
#include "config.h"
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
@ -720,14 +719,7 @@ polarize_dialog (void)
gtk_widget_show (preview->widget);
/* Controls */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
vbox = gimp_parameter_settings_new (main_vbox, 0, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);

20
plug-ins/common/randomize.c
View File

@ -690,7 +690,6 @@ static gint
randomize_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *label;
GtkWidget *seed_hbox;
@ -714,22 +713,7 @@ randomize_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/*
* Parameter settings
*
* First set up the basic containers, label them, etc.
*/
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show(table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 3, 3);
/* Random Seed */
seed_hbox = gimp_random_seed_new (&pivals.rndm_seed);
@ -763,8 +747,6 @@ randomize_dialog (void)
G_CALLBACK (gimp_double_adjustment_update),
&pivals.rndm_rcount);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

14
plug-ins/common/ripple.c
View File

@ -587,16 +587,7 @@ ripple_dialog (void)
gtk_widget_show (table);
/* Parameter Settings */
frame = gtk_frame_new ( _("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 2, 3);
/* Period */
scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
@ -618,9 +609,6 @@ ripple_dialog (void)
G_CALLBACK (gimp_int_adjustment_update),
&rvals.amplitude);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (main_vbox);
gtk_widget_show (dlg);

15
plug-ins/common/scatter_hsv.c
View File

@ -403,17 +403,7 @@ scatter_hsv_dialog (void)
gtk_widget_show (frame);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (vbox, 4, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Holdness:"), SCALE_WIDTH, ENTRY_WIDTH,
@ -451,9 +441,6 @@ scatter_hsv_dialog (void)
G_CALLBACK (scatter_hsv_iscale_update),
&VALS.value_distance);
gtk_widget_show (table);
gtk_widget_show (frame);
gtk_widget_show (vbox);
gtk_widget_show (dlg);

21
plug-ins/common/sel_gauss.c
View File

@ -227,7 +227,6 @@ static gint
sel_gauss_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *spinbutton;
GtkObject *adj;
@ -252,17 +251,7 @@ sel_gauss_dialog (void)
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame,
TRUE, TRUE, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 2, 3);
spinbutton = gimp_spin_button_new (&adj,
bvals.radius, 0.0, G_MAXINT, 1.0, 5.0,
@ -284,7 +273,6 @@ sel_gauss_dialog (void)
&bvals.maxdelta);
gtk_widget_show (table);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();
@ -411,14 +399,11 @@ sel_gauss (GimpDrawable *drawable,
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
width = x2 - x1;
height = y2 - y1;
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
if ((width < 1) || (height < 1) || (bytes < 1))
return;
numrad = (gint) (radius + 1.0);
mat = g_new (gdouble *, numrad);
for (i = 0; i < numrad; i++)

12
plug-ins/common/sharpen.c
View File

@ -26,7 +26,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
@ -587,16 +586,7 @@ sharpen_dialog (void)
/*
* Sharpness control...
*/
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (vbox, 1, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Sharpness:"), SCALE_WIDTH, 0,

9
plug-ins/common/smooth_palette.c
View File

@ -411,7 +411,7 @@ static gboolean
dialog (GimpDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *spinbutton;
GtkObject *adj;
guint32 image_id;
@ -437,10 +437,7 @@ dialog (GimpDrawable *drawable)
G_CALLBACK (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
image_id = gimp_drawable_image (drawable->drawable_id);
unit = gimp_image_get_unit (image_id);
@ -459,7 +456,7 @@ dialog (GimpDrawable *drawable)
config.height, yres,
1, GIMP_MAX_IMAGE_SIZE,
1, GIMP_MAX_IMAGE_SIZE);
gtk_container_add (GTK_CONTAINER (frame), sizeentry);
gtk_container_add (GTK_CONTAINER (vbox), sizeentry);
gtk_widget_show (sizeentry);
spinbutton = gimp_spin_button_new (&adj, config.ntries,

15
plug-ins/common/snoise.c
View File

@ -61,7 +61,6 @@
#include "config.h"
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
@ -494,7 +493,6 @@ static gint
solid_noise_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *table;
GtkWidget *label;
@ -521,17 +519,7 @@ solid_noise_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* Table */
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 4, 3);
/* Random Seed */
seed_hbox = gimp_random_seed_new (&snvals.seed);
@ -593,7 +581,6 @@ solid_noise_dialog (void)
G_CALLBACK (gimp_double_adjustment_update),
&snvals.ysize);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();

13
plug-ins/common/sobel.c
View File

@ -236,7 +236,6 @@ sobel_dialog (void)
{
GtkWidget *dlg;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
gimp_ui_init ("sobel", FALSE);
@ -258,15 +257,7 @@ sobel_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new ( _("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
toggle = gtk_check_button_new_with_mnemonic (_("Sobel _Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
@ -295,8 +286,6 @@ sobel_dialog (void)
G_CALLBACK (gimp_toggle_button_update),
&bvals.keep_sign);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();

12
plug-ins/common/sparkle.c
View File

@ -333,7 +333,6 @@ sparkle_dialog (void)
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *sep;
@ -360,16 +359,7 @@ sparkle_dialog (void)
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), main_vbox);
gtk_widget_show (main_vbox);
main_vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 1, 3);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);

11
plug-ins/common/struc.c
View File

@ -1279,16 +1279,7 @@ struc_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* Parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
vbox = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 0, 0);
frame = gimp_radio_group_new2 (TRUE, _("Direction"),
G_CALLBACK (gimp_radio_button_update),

12
plug-ins/common/threshold_alpha.c
View File

@ -223,7 +223,6 @@ static gint
threshold_alpha_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkObject *adj;
@ -245,16 +244,7 @@ threshold_alpha_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (1 ,3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 1, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Threshold:"), SCALE_WIDTH, 0,

1
plug-ins/common/tileit.c
View File

@ -40,7 +40,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#ifdef __GNUC__

14
plug-ins/common/unsharp.c
View File

@ -636,7 +636,6 @@ static gint
unsharp_mask_dialog (void)
{
GtkWidget *window;
GtkWidget *frame;
GtkWidget *table;
GtkObject *adj;
@ -659,18 +658,7 @@ unsharp_mask_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), frame,
FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (GTK_DIALOG (window)->vbox, 3, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Radius:"), SCALE_WIDTH, ENTRY_WIDTH,

10
plug-ins/common/vpropagate.c
View File

@ -1081,15 +1081,7 @@ vpropagate_dialog (GimpImageBaseType image_type)
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* Parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (10, 3, FALSE); /* 4 raw, 2 columns(name and value) */
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (hbox, 10, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Lower T_hreshold:"), SCALE_WIDTH, 4,

11
plug-ins/common/waves.c
View File

@ -356,16 +356,7 @@ pluginCoreIA (piArgs *argp,
G_CALLBACK (waves_toggle_button_update),
&argp->reflective);
frame = gtk_frame_new ( _("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 3, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Amplitude:"), 140, 6,

12
plug-ins/common/whirlpinch.c
View File

@ -47,7 +47,6 @@
#include "config.h"
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef HAVE_UNISTD_H
@ -692,16 +691,7 @@ whirl_pinch_dialog (void)
gtk_widget_show (wpint.preview);
/* Controls */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (main_vbox, 3, 3);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Whirl Angle:"), SCALE_WIDTH, 7,

10
plug-ins/common/wind.c
View File

@ -909,15 +909,7 @@ dialog_box (GimpDrawable *drawable)
render_effect (drawable, TRUE);
gtk_widget_show (preview->widget);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_container_add (GTK_CONTAINER (frame), main_vbox);
gtk_widget_show (main_vbox);
main_vbox = gimp_parameter_settings_new (vbox, 0, 0);
/*****************************************************
outer frame and table

14
plug-ins/common/xpm.c
View File

@ -760,7 +760,6 @@ static gint
save_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkObject *scale_data;
@ -780,18 +779,7 @@ save_dialog (void)
G_CALLBACK (gtk_main_quit),
NULL);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
table = gimp_parameter_settings_new (GTK_DIALOG (dlg)->vbox, 1, 3);
scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Alpha Threshold:"), SCALE_WIDTH, 0,

1
plug-ins/imagemap/Makefile.am
View File

@ -15,7 +15,6 @@ EXTRA_DIST = \
circle.xpm \
coord.xpm \
dimension.xpm \
grid.xpm \
java.xpm \
link.xpm \
map_info.xpm \

21
plug-ins/imagemap/grid.xpm
View File

@ -1,21 +0,0 @@
/* XPM */
static char * grid_xpm[] = {
"16 16 2 1",
" c None",
". c black",
" . . . . ",
"............... ",
" . . . . ",
" . . . . ",
" . . . . ",
"............... ",
" . . . . ",
" . . . . ",
" . . . . ",
"............... ",
" . . . . ",
" . . . . ",
" . . . . ",
"............... ",
" . . . . ",
" "};

3
plug-ins/imagemap/imap_stock.c
View File

@ -31,7 +31,6 @@
#include "circle.xpm"
#include "coord.xpm"
#include "dimension.xpm"
#include "grid.xpm"
#include "java.xpm"
#include "link.xpm"
#include "map_info.xpm"
@ -44,7 +43,6 @@
static GtkStockItem imap_stock_items[] = {
{IMAP_STOCK_MAP_INFO, N_("Edit Map Info..."), 0, 0, "imap"},
{IMAP_STOCK_GRID, N_("Grid"), 0, 0, "imap"},
};
static void
@ -70,7 +68,6 @@ init_stock_icons(void)
add_stock_icon(factory, IMAP_STOCK_CIRCLE, (const char**) circle_xpm);
add_stock_icon(factory, IMAP_STOCK_COORD, (const char**) coord_xpm);
add_stock_icon(factory, IMAP_STOCK_DIMENSION, (const char**) dimension_xpm);
add_stock_icon(factory, IMAP_STOCK_GRID, (const char**) grid_xpm);
add_stock_icon(factory, IMAP_STOCK_JAVA, (const char**) java_xpm);
add_stock_icon(factory, IMAP_STOCK_LINK, (const char**) link_xpm);
add_stock_icon(factory, IMAP_STOCK_MAP_INFO, (const char**) map_info_xpm);

1
plug-ins/imagemap/imap_stock.h
View File

@ -28,7 +28,6 @@
#define IMAP_STOCK_CIRCLE "imap_circle"
#define IMAP_STOCK_COORD "imap_coord"
#define IMAP_STOCK_DIMENSION "imap_dimension"
#define IMAP_STOCK_GRID "imap_grid"
#define IMAP_STOCK_JAVA "imap_java"
#define IMAP_STOCK_LINK "imap_link"
#define IMAP_STOCK_MAP_INFO "imap-map-info"

8
plug-ins/imagemap/imap_toolbar.c
View File

@ -3,7 +3,7 @@
*
* Generates clickable image maps.
*
* Copyright (C) 1998-2002 Maurits Rijk lpeek.mrijk@consunet.nl
* Copyright (C) 1998-2003 Maurits Rijk lpeek.mrijk@consunet.nl
*
* 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
@ -31,6 +31,7 @@
#include "imap_toolbar.h"
#include "libgimp/stdplugins-intl.h"
#include "libgimpwidgets/gimpstock.h"
static gboolean _command_lock;
@ -74,7 +75,7 @@ command_list_changed(Command_t *command, gpointer data)
void
toolbar_shapes_selected(ToolBar_t *toolbar, gint count)
{
gint sensitive = (count > 0);
gboolean sensitive = (count > 0);
gtk_widget_set_sensitive(toolbar->cut, sensitive);
gtk_widget_set_sensitive(toolbar->copy, sensitive);
gtk_widget_set_sensitive(toolbar->to_front, sensitive);
@ -158,7 +159,8 @@ make_toolbar(GtkWidget *main_vbox, GtkWidget *window)
&data->cmd_send_to_back);
gtk_widget_set_sensitive(data->to_back, FALSE);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
data->grid = make_toolbar_toggle_icon(toolbar, IMAP_STOCK_GRID, "Grid",
data->grid = make_toolbar_toggle_icon(toolbar, GIMP_STOCK_GRID, "Grid",
_("Grid"), toolbar_command,
&data->cmd_grid);

13
plug-ins/jpeg/jpeg-load.c
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

13
plug-ins/jpeg/jpeg-load.h
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

13
plug-ins/jpeg/jpeg-save.c
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

13
plug-ins/jpeg/jpeg-save.h
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

13
plug-ins/jpeg/jpeg.c
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

13
plug-ins/jpeg/jpeg.h
View File

@ -1643,7 +1643,6 @@ save_dialog (void)
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *abox;
@ -1720,16 +1719,7 @@ save_dialog (void)
make_preview ();
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (9, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
table = gimp_parameter_settings_new (main_vbox, 9, 3);
label = gtk_label_new (_("Quality:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
@ -1939,7 +1929,6 @@ save_dialog (void)
gtk_widget_show (com_frame);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dlg);

18
po/Makefile.in.in
View File

@ -75,7 +75,7 @@ INSTOBJEXT = @INSTOBJEXT@
.po.pox:
$(MAKE) $(GETTEXT_PACKAGE).pot
$(MSGMERGE) $< $(srcdir)/$(GETTEXT_PACKAGE).pot -o $*pox
$(MSGMERGE) $< $(srcdir)/$(GETTEXT_PACKAGE).pot -o $*.pox
.po.mo:
$(MSGFMT) -o $@ $<
@ -179,7 +179,6 @@ dvi info tags TAGS ID:
mostlyclean:
rm -f core core.* *.pox $(GETTEXT_PACKAGE).po *.old.po cat-id-tbl.tmp
rm -fr *.o
rm -f .intltool-merge-cache
clean: mostlyclean
@ -208,7 +207,7 @@ update-po: Makefile
cat=`basename $$cat`; \
lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \
echo "$$lang:"; \
if $$tmpdir/$(INTLTOOL_UPDATE) --gettext-package $(GETTEXT_PACKAGE) --dist -o $$tmpdir/$$lang.new.po $$lang; then \
if $(MSGMERGE) $$lang.po $(GETTEXT_PACKAGE).pot -o $$tmpdir/$$lang.new.po; then \
if cmp $$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \
rm -f $$tmpdir/$$lang.new.po; \
else \
@ -226,6 +225,19 @@ update-po: Makefile
fi; \
done
.po: Makefile
$(MAKE) $(PACKAGE).pot;
PATH=`pwd`/../src:$$PATH; \
echo; printf "$*: "; \
if $(MSGMERGE) $*; then \
rm -f $*.old.po; \
else \
echo "msgmerge for * failed!"; \
mv $*.old.po $*.po; \
fi; \
msgfmt --statistics $*.po; echo;
# POTFILES is created from POTFILES.in by stripping comments, empty lines
# and Intltool tags (enclosed in square brackets), and appending a full
# relative path to them