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

plug-ins/common/mapcolor.c ported to GimpPreviewArea. 

* plug-ins/common/mapcolor.c
* plug-ins/common/sample_colorize.c: ported to GimpPreviewArea.

* plug-ins/common/newsprint.c: ported to GimpPreviewArea, even though
  it should use some pngs instead.
This commit is contained in:
David Odin 2004-08-01 17:16:42 +00:00
parent 471a565b88
commit 65776cd25a
4 changed files with 678 additions and 735 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ChangeLog
View File

@ -1,3 +1,11 @@
2004-08-01 DindinX <david@dindinx.org>
* plug-ins/common/mapcolor.c
* plug-ins/common/sample_colorize.c: ported to GimpPreviewArea.
* plug-ins/common/newsprint.c: ported to GimpPreviewArea, even though
it should use some pngs instead.
2004-08-01 Michael Schumacher <schumaml@cvs.gnome.org>
* configure.in: modified the checks. hopefully it works on all

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

@ -40,11 +40,6 @@ static char ident[] = "@(#) GIMP mapcolor plug-in v1.03 22-May-00";
#include <string.h>
#include <time.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
#endif
#undef GTK_DISABLE_DEPRECATED
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
@ -98,10 +93,10 @@ static guchar redmap[256], greenmap[256], bluemap[256];
*/
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
GimpPlugInInfo PLUG_IN_INFO =
{
@ -115,23 +110,23 @@ static IMG_PREVIEW *img_preview_alloc (guint width, guint height);
static void img_preview_free (IMG_PREVIEW *ip);
static void img_preview_copy (IMG_PREVIEW *src, IMG_PREVIEW **dst);
static IMG_PREVIEW *img_preview_create_from_drawable (guint maxsize,
gint32 drawable_ID);
gint32 drawable_ID);
static void update_img_preview (void);
static gboolean dialog (gint32 drawable_ID);
static void get_mapping (GimpRGB *src_col1,
GimpRGB *src_col2,
GimpRGB *dst_col1,
GimpRGB *dst_col2,
gint32 map_mode,
guchar *redmap,
guchar *greenmap,
guchar *bluemap);
GimpRGB *src_col2,
GimpRGB *dst_col1,
GimpRGB *dst_col2,
gint32 map_mode,
guchar *redmap,
guchar *greenmap,
guchar *bluemap);
static void add_color_button (gint csel_index,
gint left,
gint top,
GtkWidget *table);
gint left,
gint top,
GtkWidget *table);
static void color_mapping (GimpDrawable *drawable);
@ -153,7 +148,7 @@ static PLInterface plinterface;
/* Allocate image preview structure and preview memory */
static IMG_PREVIEW *
img_preview_alloc (guint width,
guint height)
guint height)
{
IMG_PREVIEW *ip;
@ -179,7 +174,7 @@ img_preview_free (IMG_PREVIEW *ip)
/* Copy image preview. Create/modify destination preview */
static void
img_preview_copy (IMG_PREVIEW *src,
IMG_PREVIEW **dst)
IMG_PREVIEW **dst)
{
gint numbytes;
@ -218,83 +213,83 @@ img_preview_copy (IMG_PREVIEW *src,
static IMG_PREVIEW *
img_preview_create_from_drawable (guint maxsize,
gint32 drawable_ID)
gint32 drawable_ID)
{
GimpDrawable *drw;
GimpPixelRgn pixel_rgn;
guint drw_width, drw_height;
guint prv_width, prv_height;
gint src_x, src_y, x, y;
guchar *prv_data, *img_data, *cu_row;
gdouble xfactor, yfactor;
gint tile_height, row_start, row_end;
gint bpp;
IMG_PREVIEW *ip;
GimpDrawable *drw;
GimpPixelRgn pixel_rgn;
guint drw_width, drw_height;
guint prv_width, prv_height;
gint src_x, src_y, x, y;
guchar *prv_data, *img_data, *cu_row;
gdouble xfactor, yfactor;
gint tile_height, row_start, row_end;
gint bpp;
IMG_PREVIEW *ip;
drw_width = gimp_drawable_width (drawable_ID);
drw_height = gimp_drawable_height (drawable_ID);
tile_height = (gint)gimp_tile_height();
bpp = gimp_drawable_bpp(drawable_ID);
drw_width = gimp_drawable_width (drawable_ID);
drw_height = gimp_drawable_height (drawable_ID);
tile_height = (gint)gimp_tile_height();
bpp = gimp_drawable_bpp(drawable_ID);
img_data = g_malloc (drw_width * tile_height * bpp);
if (img_data == NULL)
return NULL;
img_data = g_malloc (drw_width * tile_height * bpp);
if (img_data == NULL)
return NULL;
/* Calculate preview size */
if ((drw_width <= maxsize) && (drw_height <= maxsize))
{
prv_width = drw_width;
prv_height = drw_height;
}
else
{
xfactor = ((double)maxsize) / ((double)drw_width);
yfactor = ((double)maxsize) / ((double)drw_height);
if (xfactor < yfactor)
{
prv_width = maxsize;
prv_height = (guint)(drw_height * xfactor);
}
else
{
prv_width = (guint)(drw_width * yfactor);
prv_height = maxsize;
}
}
ip = img_preview_alloc (prv_width, prv_height);
if (ip == NULL)
return NULL;
/* Calculate preview size */
if ((drw_width <= maxsize) && (drw_height <= maxsize))
{
prv_width = drw_width;
prv_height = drw_height;
}
else
{
xfactor = ((double)maxsize) / ((double)drw_width);
yfactor = ((double)maxsize) / ((double)drw_height);
if (xfactor < yfactor)
{
prv_width = maxsize;
prv_height = (guint)(drw_height * xfactor);
}
else
{
prv_width = (guint)(drw_width * yfactor);
prv_height = maxsize;
}
}
ip = img_preview_alloc (prv_width, prv_height);
if (ip == NULL)
return NULL;
drw = gimp_drawable_get (drawable_ID);
prv_data = ip->img;
gimp_pixel_rgn_init (&pixel_rgn, drw, 0, 0, drw_width, drw_height,
FALSE, FALSE);
row_start = row_end = -1;
drw = gimp_drawable_get (drawable_ID);
prv_data = ip->img;
gimp_pixel_rgn_init (&pixel_rgn, drw, 0, 0, drw_width, drw_height,
FALSE, FALSE);
row_start = row_end = -1;
/* Get the pixels for the preview from the drawable */
for (y = 0; y < prv_height; y++)
{
src_y = (drw_height * y) / prv_height;
if (src_y > row_end) /* Need new row ? */
{
row_start = (src_y / tile_height) * tile_height;
row_end = row_start+tile_height-1;
if (row_end > drw_height-1) row_end = drw_height-1;
gimp_pixel_rgn_get_rect (&pixel_rgn, img_data, 0, row_start, drw_width,
row_end-row_start+1);
}
cu_row = img_data + (src_y-row_start)*drw_width*bpp;
for (x = 0; x < prv_width; x++)
{
src_x = (drw_width * x) / prv_width;
memcpy (prv_data, cu_row+bpp*src_x, 3);
prv_data += 3;
}
}
/* Get the pixels for the preview from the drawable */
for (y = 0; y < prv_height; y++)
{
src_y = (drw_height * y) / prv_height;
if (src_y > row_end) /* Need new row ? */
{
row_start = (src_y / tile_height) * tile_height;
row_end = row_start+tile_height-1;
if (row_end > drw_height-1) row_end = drw_height-1;
gimp_pixel_rgn_get_rect (&pixel_rgn, img_data, 0, row_start, drw_width,
row_end-row_start+1);
}
cu_row = img_data + (src_y-row_start)*drw_width*bpp;
for (x = 0; x < prv_width; x++)
{
src_x = (drw_width * x) / prv_width;
memcpy (prv_data, cu_row+bpp*src_x, 3);
prv_data += 3;
}
}
gimp_drawable_detach (drw);
g_free (img_data);
return ip;
gimp_drawable_detach (drw);
g_free (img_data);
return ip;
}
MAIN ()
@ -343,9 +338,9 @@ query (void)
gimp_install_procedure ("plug_in_color_map",
"Map color range specified by two colors"
"to color range specified by two other color.",
"to color range specified by two other color.",
"Map color range specified by two colors"
"to color range specified by two other color."
"to color range specified by two other color."
"Intermediate colors are interpolated.",
"Peter Kirchgessner",
"Peter Kirchgessner",
@ -391,87 +386,87 @@ run (const gchar *name,
while (status == GIMP_PDB_SUCCESS)
{
if (nparams < 3)
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
/* Make sure the drawable is RGB color */
drawable = gimp_drawable_get (param[2].data.d_drawable);
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Cannot operate on gray or indexed color images."));
status = GIMP_PDB_EXECUTION_ERROR;
break;
}
{
g_message (_("Cannot operate on gray or indexed color images."));
status = GIMP_PDB_EXECUTION_ERROR;
break;
}
if (strcmp (name, "plug_in_color_adjust") == 0)
{
if (nparams != 3) /* Make sure all the arguments are there */
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
{
if (nparams != 3) /* Make sure all the arguments are there */
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
gimp_palette_get_foreground (plvals.colors);
gimp_palette_get_background (plvals.colors + 1);
gimp_palette_get_foreground (plvals.colors);
gimp_palette_get_background (plvals.colors + 1);
gimp_rgb_set (plvals.colors + 2, 0.0, 0.0, 0.0);
gimp_rgb_set (plvals.colors + 3, 1.0, 1.0, 1.0);
gimp_rgb_set (plvals.colors + 2, 0.0, 0.0, 0.0);
gimp_rgb_set (plvals.colors + 3, 1.0, 1.0, 1.0);
plvals.map_mode = 0;
plvals.map_mode = 0;
gimp_progress_init (_("Adjusting Foreground/Background..."));
color_mapping (drawable);
break;
}
color_mapping (drawable);
break;
}
if (strcmp (name, "plug_in_color_map") == 0)
{
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (nparams != 8) /* Make sure all the arguments are there */
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
{
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (nparams != 8) /* Make sure all the arguments are there */
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
for (j = 0; j < 4; j++)
{
plvals.colors[j] = param[3+j].data.d_color;
}
plvals.map_mode = param[7].data.d_int32;
}
else if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_get_data (name, &plvals);
for (j = 0; j < 4; j++)
{
plvals.colors[j] = param[3+j].data.d_color;
}
plvals.map_mode = param[7].data.d_int32;
}
else if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_get_data (name, &plvals);
gimp_palette_get_foreground (plvals.colors);
gimp_palette_get_background (plvals.colors + 1);
gimp_palette_get_foreground (plvals.colors);
gimp_palette_get_background (plvals.colors + 1);
if (!dialog (param[2].data.d_drawable))
break;
}
else if (run_mode == GIMP_RUN_WITH_LAST_VALS)
{
gimp_get_data (name, &plvals);
}
else
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
if (!dialog (param[2].data.d_drawable))
break;
}
else if (run_mode == GIMP_RUN_WITH_LAST_VALS)
{
gimp_get_data (name, &plvals);
}
else
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
gimp_progress_init (_("Mapping colors..."));
color_mapping (drawable);
color_mapping (drawable);
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (name, &plvals, sizeof (plvals));
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (name, &plvals, sizeof (plvals));
break;
}
break;
}
status = GIMP_PDB_EXECUTION_ERROR;
}
@ -497,10 +492,10 @@ update_img_preview (void)
if ((dst_ip == NULL) || (src_ip == NULL)) return;
get_mapping (plvals.colors,
plvals.colors + 1,
plvals.colors + 2,
plvals.colors + 3,
plvals.map_mode,
plvals.colors + 1,
plvals.colors + 2,
plvals.colors + 3,
plvals.map_mode,
redmap, greenmap, bluemap);
j = dst_ip->width*dst_ip->height;
@ -514,12 +509,11 @@ update_img_preview (void)
*(dst++) = bluemap[*(src++)];
}
for (j = 0; j < dst_ip->height; j++)
gtk_preview_draw_row (GTK_PREVIEW (preview),
dst_ip->img + dst_ip->width*3*j,
0, j, dst_ip->width);
gtk_widget_queue_draw (preview);
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, dst_ip->width, dst_ip->height,
GIMP_RGB_IMAGE,
dst_ip->img,
dst_ip->width*3);
}
static gboolean
@ -539,12 +533,12 @@ dialog (gint32 drawable_ID)
dlg = gimp_dialog_new (_("Map Color Range"), "mapcolor",
NULL, 0,
gimp_standard_help_func, "plug-in-color-map",
gimp_standard_help_func, "plug-in-color-map",
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
NULL);
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@ -571,9 +565,9 @@ dialog (gint32 drawable_ID)
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
preview = gimp_preview_area_new ();
plinterface.preview = preview;
gtk_preview_size (GTK_PREVIEW (preview), ip->width, ip->height);
gtk_widget_set_size_request (preview, ip->width, ip->height);
gtk_container_add (GTK_CONTAINER (frame), preview);
gtk_widget_show (preview);
}
@ -596,10 +590,10 @@ dialog (gint32 drawable_ID)
add_color_button (j * 2 + 1, 2, 0, table);
}
update_img_preview ();
gtk_widget_show (dlg);
update_img_preview ();
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK);
if (run)
@ -622,13 +616,13 @@ add_color_button (gint csel_index,
GtkWidget *button;
button = gimp_color_button_new (gettext (csel_title[csel_index]),
PRV_WIDTH, PRV_HEIGHT,
&plvals.colors[csel_index],
GIMP_COLOR_AREA_FLAT);
PRV_WIDTH, PRV_HEIGHT,
&plvals.colors[csel_index],
GIMP_COLOR_AREA_FLAT);
gimp_table_attach_aligned (GTK_TABLE (table), left + 1, top,
(left == 0) ? _("From:") : _("To:"),
0.0, 0.5,
button, 1, TRUE);
(left == 0) ? _("From:") : _("To:"),
0.0, 0.5,
button, 1, TRUE);
g_signal_connect (button, "color_changed",
G_CALLBACK (gimp_color_button_get_color),
@ -671,27 +665,27 @@ get_mapping (GimpRGB *src_col1,
case 0:
default:
for (rgb = 0; rgb < 3; rgb++)
{
a = src1[rgb]; as = dst1[rgb];
b = src2[rgb]; bs = dst2[rgb];
{
a = src1[rgb]; as = dst1[rgb];
b = src2[rgb]; bs = dst2[rgb];
if (b == a)
b = a + 1;
for (i = 0; i < 256; i++)
b = a + 1;
for (i = 0; i < 256; i++)
{
gint j = ((i - a) * (bs - as)) / (b - a) + as;
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)
guchar *dest,
gint bpp,
gpointer data)
{
dest[0] = redmap[src[0]];
dest[1] = greenmap[src[1]];
@ -716,10 +710,10 @@ color_mapping (GimpDrawable *drawable)
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
get_mapping (plvals.colors,
plvals.colors + 1,
plvals.colors + 2,
plvals.colors + 3,
plvals.map_mode,
plvals.colors + 1,
plvals.colors + 2,
plvals.colors + 3,
plvals.map_mode,
redmap, greenmap, bluemap);
gimp_rgn_iterate2 (drawable, l_run_mode, mapcolor_func, NULL);

788
plug-ins/common/newsprint.c
View File

File diff suppressed because it is too large Load Diff

241
plug-ins/common/sample_colorize.c
View File

@ -26,11 +26,6 @@
#include <stdlib.h>
#include <string.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
#endif
#undef GTK_DISABLE_DEPRECATED
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
@ -112,13 +107,13 @@ typedef struct
typedef struct
{
GtkWidget *dialog;
GtkWidget *sample_preview;
GtkWidget *dst_preview;
GtkWidget *sample_colortab_preview;
GtkWidget *sample_drawarea;
GtkWidget *in_lvl_gray_preview;
GtkWidget *in_lvl_drawarea;
GtkWidget *dialog;
GtkWidget *sample_preview;
GtkWidget *dst_preview;
GtkWidget *sample_colortab_preview;
GtkWidget *sample_drawarea;
GtkWidget *in_lvl_gray_preview;
GtkWidget *in_lvl_drawarea;
GtkAdjustment *adj_lvl_in_min;
GtkAdjustment *adj_lvl_in_max;
GtkAdjustment *adj_lvl_in_gamma;
@ -128,11 +123,11 @@ typedef struct
gint active_slider;
gint slider_pos[5]; /* positions for the five sliders */
gint32 enable_preview_update;
gint32 sample_show_selection;
gint32 dst_show_selection;
gint32 sample_show_color;
gint32 dst_show_color;
gint32 enable_preview_update;
gint32 sample_show_selection;
gint32 dst_show_selection;
gint32 sample_show_color;
gint32 dst_show_color;
} t_samp_interface;
@ -157,24 +152,24 @@ typedef struct
typedef struct
{
GimpDrawable *drawable;
void *sel_gdrw;
void *sel_gdrw;
GimpPixelRgn pr;
gint x1;
gint y1;
gint x2;
gint y2;
gint index_alpha; /* 0 == no alpha, 1 == GREYA, 3 == RGBA */
gint bpp;
gint x1;
gint y1;
gint x2;
gint y2;
gint index_alpha; /* 0 == no alpha, 1 == GREYA, 3 == RGBA */
gint bpp;
GimpTile *tile;
gint tile_row;
gint tile_col;
gint tile_width;
gint tile_height;
gint tile_dirty;
gint shadow;
gint32 seldeltax;
gint32 seldeltay;
gint32 tile_swapcount;
gint tile_row;
gint tile_col;
gint tile_width;
gint tile_height;
gint tile_dirty;
gint shadow;
gint32 seldeltax;
gint32 seldeltay;
gint32 tile_swapcount;
} t_GDRW;
/*
@ -666,7 +661,7 @@ static void
p_refresh_dst_preview (GtkWidget *preview,
guchar *src_buffer)
{
guchar l_rowbuf[4 * PREVIEW_SIZE_X];
guchar l_allrowsbuf[3 * PREVIEW_SIZE_X * PREVIEW_SIZE_Y];
guchar *l_ptr;
guchar *l_src_ptr;
guchar l_lum;
@ -678,9 +673,10 @@ p_refresh_dst_preview (GtkWidget *preview,
l_preview_bpp = PREVIEW_BPP;
l_src_bpp = PREVIEW_BPP +1; /* 3 colors + 1 maskbyte */
l_src_ptr = src_buffer;
l_ptr = l_allrowsbuf;
for(l_y = 0; l_y < PREVIEW_SIZE_Y; l_y++)
{
l_ptr = &l_rowbuf[0];
for(l_x = 0; l_x < PREVIEW_SIZE_X; l_x++)
{
if((l_maskbyte = l_src_ptr[3]) == 0)
@ -716,39 +712,22 @@ p_refresh_dst_preview (GtkWidget *preview,
}
}
l_ptr += l_preview_bpp;
l_src_ptr += l_src_bpp;
}
gtk_preview_draw_row (GTK_PREVIEW (preview),
&l_rowbuf[0], 0, l_y, PREVIEW_SIZE_X);
}
gtk_widget_queue_draw (preview);
l_src_ptr += l_src_bpp;
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, PREVIEW_SIZE_X, PREVIEW_SIZE_Y,
GIMP_RGB_IMAGE,
l_allrowsbuf,
PREVIEW_SIZE_X * 3);
} /* end p_refresh_dst_preview */
static void
p_clear_preview (GtkWidget *preview)
{
gint l_x, l_y;
guchar l_rowbuf[4 * PREVIEW_SIZE_X];
guchar *l_ptr;
l_ptr = &l_rowbuf[0];
for (l_x = 0; l_x < PREVIEW_SIZE_X; l_x++)
{
l_ptr[0] = 170;
l_ptr[1] = 170;
l_ptr[2] = 170;
l_ptr += PREVIEW_BPP;
}
for (l_y = 0; l_y < PREVIEW_SIZE_Y; l_y++)
{
gtk_preview_draw_row (GTK_PREVIEW(preview),
&l_rowbuf[0], 0, l_y, PREVIEW_SIZE_X);
}
gtk_widget_queue_draw (preview);
gimp_preview_area_fill (GIMP_PREVIEW_AREA (preview),
0, 0, PREVIEW_SIZE_X, PREVIEW_SIZE_Y,
170, 170, 170);
} /* end p_clear_preview */
static void
@ -758,7 +737,7 @@ p_update_pv (GtkWidget *preview,
guchar *dst_buffer,
gint is_color)
{
guchar l_rowbuf[4 * PREVIEW_SIZE_X];
guchar l_allrowsbuf[4 * PREVIEW_SIZE_X * PREVIEW_SIZE_Y];
guchar l_pixel[4];
guchar *l_ptr;
gint l_x, l_y;
@ -770,7 +749,6 @@ p_update_pv (GtkWidget *preview,
guchar l_dummy[4];
guchar l_maskbytes[4];
gint l_dstep;
guchar l_check;
guchar l_alpha;
@ -827,10 +805,9 @@ p_update_pv (GtkWidget *preview,
/* render preview */
l_ptr = l_allrowsbuf;
for (l_y = 0; l_y < PREVIEW_SIZE_Y; l_y++)
{
l_ptr = &l_rowbuf[0];
for(l_x = 0; l_x < PREVIEW_SIZE_X; l_x++)
{
if (gdrw->drawable)
@ -852,80 +829,38 @@ p_update_pv (GtkWidget *preview,
}
l_alpha = l_pixel[gdrw->index_alpha];
if ((gdrw->index_alpha == 0) /* has no alpha channel */
|| (l_alpha == 255)) /* or is full opaque */
if (is_color && (gdrw->bpp > 2))
{
if (is_color && (gdrw->bpp > 2))
{
l_buf_ptr[0] = l_ptr[0] = l_pixel[0];
l_buf_ptr[1] = l_ptr[1] = l_pixel[1];
l_buf_ptr[2] = l_ptr[2] = l_pixel[2];
}
else
{
if(gdrw->bpp > 2) *l_ptr = LUMINOSITY_1(l_pixel);
else *l_ptr = l_pixel[0];
*l_buf_ptr = *l_ptr;
l_buf_ptr[1] = l_ptr[1] = *l_ptr;
l_buf_ptr[2] = l_ptr[2] = *l_ptr;
}
l_buf_ptr[3] = l_maskbytes[0];
l_buf_ptr[0] = l_ptr[0] = l_pixel[0];
l_buf_ptr[1] = l_ptr[1] = l_pixel[1];
l_buf_ptr[2] = l_ptr[2] = l_pixel[2];
}
else
{
if( ( l_y % (GIMP_CHECK_SIZE*2) < GIMP_CHECK_SIZE ) ^
( l_x % (GIMP_CHECK_SIZE*2) < GIMP_CHECK_SIZE ) )
{
l_check = GIMP_CHECK_LIGHT * 255;
}
else
{
l_check = GIMP_CHECK_DARK * 255;
}
if(gdrw->bpp > 2) *l_ptr = LUMINOSITY_1(l_pixel);
else *l_ptr = l_pixel[0];
if (l_alpha == 0)
{
/* full transparent */
*l_buf_ptr = *l_ptr = l_check;
l_buf_ptr[1] = l_ptr[1] = l_check;
l_buf_ptr[2] = l_ptr[2] = l_check;
}
else
{
/* more or less transparent */
if (is_color && (gdrw->bpp > 2))
{
*l_buf_ptr = *l_ptr = MIX_CHANNEL(l_pixel[0], l_check, l_alpha);
l_buf_ptr[1] = l_ptr[1] = MIX_CHANNEL(l_pixel[1], l_check, l_alpha);
l_buf_ptr[2] = l_ptr[2] = MIX_CHANNEL(l_pixel[2], l_check, l_alpha);
}
else
{
if(gdrw->bpp > 2) *l_ptr = MIX_CHANNEL(LUMINOSITY_1(l_pixel), l_check, l_alpha);
else *l_ptr = MIX_CHANNEL(l_pixel[0], l_check, l_alpha);
*l_buf_ptr = *l_ptr;
l_buf_ptr[1] = l_ptr[1] = *l_ptr;
l_buf_ptr[2] = l_ptr[2] = *l_ptr;
}
}
l_buf_ptr[3] = MIN(l_maskbytes[0], l_alpha);
*l_buf_ptr = *l_ptr;
l_buf_ptr[1] = l_ptr[1] = *l_ptr;
l_buf_ptr[2] = l_ptr[2] = *l_ptr;
}
if (gdrw->index_alpha == 0) /* has no alpha channel */
l_buf_ptr[3] = l_ptr[3] = 255;
else
l_buf_ptr[3] = l_ptr[3] = MIN(l_maskbytes[0], l_alpha);
l_buf_ptr += l_dstep; /* advance (or stay at dummy byte) */
l_ptr += PREVIEW_BPP;
l_ptr += 4;
}
if (dst_buffer == NULL)
{
gtk_preview_draw_row (GTK_PREVIEW(preview),
&l_rowbuf[0], 0, l_y, PREVIEW_SIZE_X);
}
}
if (dst_buffer == NULL)
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, PREVIEW_SIZE_X, PREVIEW_SIZE_Y,
GIMP_RGBA_IMAGE,
l_allrowsbuf,
PREVIEW_SIZE_X * 4);
gtk_widget_queue_draw (preview);
}
} /* end p_update_pv */
@ -1008,7 +943,8 @@ p_levels_erase_slider (GdkWindow *window,
static void
p_smp_get_colors (GtkWidget *dialog)
{
gint i;
gint i;
guchar buffer[3 * DA_WIDTH * GRADIENT_HEIGHT];
p_update_preview (&g_values.sample_id);
@ -1022,12 +958,15 @@ p_smp_get_colors (GtkWidget *dialog)
}
for (i = 0; i < GRADIENT_HEIGHT; i++)
{
gtk_preview_draw_row (GTK_PREVIEW (g_di.sample_colortab_preview),
g_sample_color_tab, 0, i, DA_WIDTH);
memcpy (buffer+i*3*DA_WIDTH, g_sample_color_tab, 3*DA_WIDTH);
}
p_update_preview (&g_values.dst_id);
gtk_widget_queue_draw (g_di.sample_colortab_preview);
gimp_preview_area_draw (GIMP_PREVIEW_AREA (g_di.sample_colortab_preview),
0, 0, DA_WIDTH, GRADIENT_HEIGHT,
GIMP_RGB_IMAGE,
buffer,
DA_WIDTH * 3);
}
@ -1073,16 +1012,16 @@ p_levels_update (gint update)
}
if (update & INPUT_LEVELS)
{
guchar buffer[DA_WIDTH * GRADIENT_HEIGHT];
for (i = 0; i < GRADIENT_HEIGHT; i++)
{
gtk_preview_draw_row (GTK_PREVIEW (g_di.in_lvl_gray_preview),
&g_lvl_trans_tab[0], 0, i, DA_WIDTH);
}
if (update & DRAW)
{
gtk_widget_queue_draw (g_di.in_lvl_gray_preview);
memcpy (buffer+DA_WIDTH*i, g_lvl_trans_tab, DA_WIDTH);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (g_di.in_lvl_gray_preview),
0, 0, DA_WIDTH, GRADIENT_HEIGHT,
GIMP_GRAY_IMAGE,
buffer,
DA_WIDTH);
}
if (update & INPUT_SLIDERS)
@ -1503,9 +1442,9 @@ p_smp_dialog (void)
frame, 0, 2, l_ty, l_ty + 1, 0, 0, 0, 0);
gtk_widget_show (frame);
g_di.dst_preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (g_di.dst_preview),
PREVIEW_SIZE_X, PREVIEW_SIZE_Y);
g_di.dst_preview = gimp_preview_area_new ();
gtk_widget_set_size_request (g_di.dst_preview,
PREVIEW_SIZE_X, PREVIEW_SIZE_Y);
gtk_container_add (GTK_CONTAINER (frame), g_di.dst_preview);
gtk_widget_show (g_di.dst_preview);
@ -1517,9 +1456,9 @@ p_smp_dialog (void)
frame, 3, 5, l_ty, l_ty + 1, 0, 0, 0, 0);
gtk_widget_show (frame);
g_di.sample_preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (g_di.sample_preview),
PREVIEW_SIZE_X, PREVIEW_SIZE_Y);
g_di.sample_preview = gimp_preview_area_new ();
gtk_widget_set_size_request (g_di.sample_preview,
PREVIEW_SIZE_X, PREVIEW_SIZE_Y);
gtk_container_add (GTK_CONTAINER (frame), g_di.sample_preview);
gtk_widget_show (g_di.sample_preview);
@ -1533,9 +1472,9 @@ p_smp_dialog (void)
gtk_table_attach (GTK_TABLE (table),
frame, 0, 2, l_ty, l_ty + 1, 0, 0, 0, 0);
g_di.in_lvl_gray_preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
gtk_preview_size (GTK_PREVIEW (g_di.in_lvl_gray_preview),
DA_WIDTH, GRADIENT_HEIGHT);
g_di.in_lvl_gray_preview = gimp_preview_area_new ();
gtk_widget_set_size_request (g_di.in_lvl_gray_preview,
DA_WIDTH, GRADIENT_HEIGHT);
gtk_widget_set_events (g_di.in_lvl_gray_preview, LEVELS_DA_MASK);
gtk_box_pack_start (GTK_BOX (vbox2), g_di.in_lvl_gray_preview, FALSE, TRUE, 0);
gtk_widget_show (g_di.in_lvl_gray_preview);
@ -1567,9 +1506,9 @@ p_smp_dialog (void)
gtk_table_attach (GTK_TABLE (table),
frame, 3, 5, l_ty, l_ty + 1, 0, 0, 0, 0);
g_di.sample_colortab_preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (g_di.sample_colortab_preview),
DA_WIDTH, GRADIENT_HEIGHT);
g_di.sample_colortab_preview = gimp_preview_area_new ();
gtk_widget_set_size_request (g_di.sample_colortab_preview,
DA_WIDTH, GRADIENT_HEIGHT);
gtk_box_pack_start (GTK_BOX (vbox2), g_di.sample_colortab_preview, FALSE, TRUE, 0);
gtk_widget_show (g_di.sample_colortab_preview);