void preview_clicked(GtkWidget *widget, gpointer data)
{
if (!dialog_is_init) return;
if (local_vals.prev == 0)
{
local_vals.prev = 1;
gtk_button_set_label(GTK_BUTTON(widget), "Preview On");
preview_redraw();
}
else
{
local_vals.prev = 0;
gtk_button_set_label(GTK_BUTTON(widget), "Preview Off");
// html color: #f2f1f0
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_d), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_ao), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_s), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_p), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_n), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
_active = 'x';
return;
}
}
static gboolean
preview_event_handler (GtkWidget *area,
GdkEvent *event,
GtkWidget *preview)
{
gint pos;
guchar *buf;
guint32 drawable_id;
GimpRGB color;
GdkEventButton *button_event = (GdkEventButton *)event;
buf = GIMP_PREVIEW_AREA (area)->buf;
drawable_id = GIMP_DRAWABLE_PREVIEW (preview)->drawable->drawable_id;
switch (event->type)
{
case GDK_BUTTON_PRESS:
if (button_event->button == 2)
{
pos = event->button.x * gimp_drawable_bpp (drawable_id) +
event->button.y * GIMP_PREVIEW_AREA (area)->rowstride;
gimp_rgb_set_uchar (&color, buf[pos], buf[pos + 1], buf[pos + 2]);
gimp_color_button_set_color (GIMP_COLOR_BUTTON (from_colorbutton),
&color);
}
break;
default:
break;
}
return FALSE;
}
static void
gimp_aspect_preview_draw_buffer (GimpPreview *preview,
const guchar *buffer,
gint rowstride)
{
GimpDrawable *drawable = GIMP_ASPECT_PREVIEW (preview)->drawable;
gint32 image_id;
image_id = gimp_item_get_image (drawable->drawable_id);
if (gimp_selection_is_empty (image_id))
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
0, 0,
preview->width, preview->height,
gimp_drawable_type (drawable->drawable_id),
buffer,
rowstride);
}
else
{
guchar *sel;
guchar *src;
gint selection_id;
gint width, height;
gint bpp;
selection_id = gimp_image_get_selection (image_id);
width = preview->width;
height = preview->height;
src = gimp_drawable_get_thumbnail_data (drawable->drawable_id,
&width, &height, &bpp);
sel = gimp_drawable_get_thumbnail_data (selection_id,
&width, &height, &bpp);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (preview->area),
0, 0, preview->width, preview->height,
gimp_drawable_type (drawable->drawable_id),
src, width * drawable->bpp,
buffer, rowstride,
sel, width);
g_free (sel);
g_free (src);
}
}
static void
updatesmpreviewprev (void)
{
gint x, y;
static ppm_t nsbuffer;
guchar black[3] = {0, 0, 0};
guchar gray[3] = {120, 120, 120};
if (! PPM_IS_INITED (&nsbuffer))
{
ppm_new (&nsbuffer, OMWIDTH, OMHEIGHT);
}
fill (&nsbuffer, black);
for (y = 6; y < OMHEIGHT-4; y += 10)
{
for (x = 6; x < OMWIDTH-4; x += 10)
{
gdouble siz = 5 * getsiz_from_gui (x / (double)OMWIDTH,
y / (double)OMHEIGHT);
ppm_drawline (&nsbuffer, x-siz, y-siz, x+siz, y-siz, gray);
ppm_drawline (&nsbuffer, x+siz, y-siz, x+siz, y+siz, gray);
ppm_drawline (&nsbuffer, x+siz, y+siz, x-siz, y+siz, gray);
ppm_drawline (&nsbuffer, x-siz, y+siz, x-siz, y-siz, gray);
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (smpreviewprev),
0, 0, OMWIDTH, OMHEIGHT,
GIMP_RGB_IMAGE,
nsbuffer.col,
OMWIDTH * 3);
}
static GtkWidget *CreateOnePreviewFrame(GtkWidget *vbox, GtkWidget **preview, const gchar *szName)
{
GtkWidget *frame = NULL;
GtkWidget *labelFrame = NULL;
GtkWidget *abox = NULL;
if (vbox == NULL) return NULL;
labelFrame = gtk_frame_new(szName);
gtk_box_pack_start(GTK_BOX(vbox), labelFrame, 0, 0, 0);
gtk_widget_show(labelFrame);
abox = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
gtk_container_set_border_width(GTK_CONTAINER (abox), 4);
gtk_container_add(GTK_CONTAINER(labelFrame), abox);
gtk_widget_show(abox);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(abox), frame);
gtk_widget_show(frame);
*preview = gimp_preview_area_new();
gimp_preview_area_set_max_size(GIMP_PREVIEW_AREA(*preview), PREVIEW_SIZE, PREVIEW_SIZE);
gtk_drawing_area_size(GTK_DRAWING_AREA(*preview), PREVIEW_SIZE, PREVIEW_SIZE);
gtk_container_add(GTK_CONTAINER(frame), *preview);
gtk_widget_show(*preview);
return labelFrame;
}
static void
nova_center_update (GtkWidget *widget,
NovaCenter *center,
gint x,
gint y)
{
gint tx, ty;
GimpPreviewArea *area = GIMP_PREVIEW_AREA (center->preview->area);
GtkAllocation allocation;
gtk_widget_get_allocation (GTK_WIDGET (area), &allocation);
x -= (allocation.width - area->width) / 2;
y -= (allocation.height - area->height) / 2;
gimp_preview_untransform (center->preview, x, y, &tx, &ty);
g_signal_handlers_block_by_func (center->coords,
nova_center_coords_update,
center);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (center->coords), 0, tx);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (center->coords), 1, ty);
g_signal_handlers_unblock_by_func (center->coords,
nova_center_coords_update,
center);
nova_center_coords_update (GIMP_SIZE_ENTRY (center->coords), center);
gtk_widget_queue_draw (center->preview->area);
}
static void
update_vector_prev (void)
{
static gint ok = 0;
gint i, x, y;
gdouble dir, xo, yo;
gdouble val;
static gdouble last_val = 0.0;
guchar gray[3] = {120, 120, 120};
guchar red[3] = {255, 0, 0};
guchar white[3] = {255, 255, 255};
if (vector_preview_brightness_adjust)
val = 1.0 - gtk_adjustment_get_value (GTK_ADJUSTMENT (vector_preview_brightness_adjust)) / 100.0;
else
val = 0.5;
if (!ok || (val != last_val))
{
infile_copy_to_ppm (&update_vector_preview_backup);
ppm_apply_brightness (&update_vector_preview_backup, val, 1,1,1);
if ((update_vector_preview_backup.width != OMWIDTH) ||
(update_vector_preview_backup.height != OMHEIGHT))
resize_fast (&update_vector_preview_backup, OMWIDTH, OMHEIGHT);
ok = 1;
}
ppm_copy (&update_vector_preview_backup, &update_vector_preview_buffer);
for (i = 0; i < num_vectors; i++)
{
gdouble s;
x = vector[i].x * OMWIDTH;
y = vector[i].y * OMHEIGHT;
dir = gimp_deg_to_rad (vector[i].dir);
s = gimp_deg_to_rad (vector[i].str);
xo = sin (dir) * (6.0+100*s);
yo = cos (dir) * (6.0+100*s);
if (i == selectedvector)
{
ppm_drawline (&update_vector_preview_buffer,
x - xo, y - yo, x + xo, y + yo, red);
}
else
{
ppm_drawline (&update_vector_preview_buffer,
x - xo, y - yo, x + xo, y + yo, gray);
}
ppm_put_rgb (&update_vector_preview_buffer, x - xo, y - yo, white);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (vector_preview),
0, 0, OMWIDTH, OMHEIGHT,
GIMP_RGB_IMAGE,
(guchar *)update_vector_preview_buffer.col,
OMWIDTH * 3);
}
/* Private functions */
static void draw_preview_area_update(GtkWidget *preview, GimpDrawable *drawable) {
if(is_3D_preview_active())
{
/** Adding all references to preview for second release. */
if ((local_vals.image_ID != 0) && (drawable != NULL))
{
update_preview = 0;
if (drawable->bpp == 3) {
GimpPixelRgn amap_rgn;
gint rowbytes = PREVIEW_SIZE * 3;
gint nbytes = drawable->width * drawable->height * 3;
guchar *tmp = g_new(guchar, nbytes);
guchar dst[PREVIEW_RGB_SIZE];
gimp_pixel_rgn_init(&amap_rgn, drawable, 0, 0, drawable->width, drawable->height, 0, 0);
gimp_pixel_rgn_get_rect(&amap_rgn, tmp, 0, 0, drawable->width, drawable->height);
scale_pixels(dst, PREVIEW_SIZE, PREVIEW_SIZE, tmp, drawable->width, drawable->height, drawable->bpp);
gimp_preview_area_draw(GIMP_PREVIEW_AREA(preview), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE,
GIMP_RGB_IMAGE, dst, rowbytes);
gtk_widget_queue_draw (preview);
g_free (tmp);
_active = 'w';
} else if (drawable->bpp == 4) {
GimpPixelRgn amap_rgn;
gint rowbytes = PREVIEW_SIZE * 4;
gint nbytes = drawable->width * drawable->height * 4;
guchar *tmp = g_new(guchar, nbytes);
guchar dst[PREVIEW_RGBA_SIZE];
gimp_pixel_rgn_init(&amap_rgn, drawable, 0, 0, drawable->width, drawable->height, 0, 0);
gimp_pixel_rgn_get_rect(&amap_rgn, tmp, 0, 0, drawable->width, drawable->height);
scale_pixels(dst, PREVIEW_SIZE, PREVIEW_SIZE, tmp, drawable->width, drawable->height, drawable->bpp);
gimp_preview_area_draw(GIMP_PREVIEW_AREA(preview), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE,
GIMP_RGBA_IMAGE, dst, rowbytes);
gtk_widget_queue_draw (preview);
g_free (tmp);
_active = 'w';
}
}
}
}
void renderPreview(PlugInVals *vals) {
gint y,k,j;
guchar *imageRow;
guchar *resultRow;
guchar *maskRow;
guchar *stopRow;
guchar *resultRGBA;
#ifdef DEBUG
g_warning("renderPreview");
#endif
resultRGBA = g_new (guchar, 4 * interface_vals.previewWidth *
interface_vals.previewHeight);
for (y = 0; y < interface_vals.previewHeight; y++)
{
imageRow =
&(interface_vals.previewImage[ y * interface_vals.previewWidth * 4]);
maskRow =
&(interface_vals.previewMask[y * interface_vals.previewWidth ]);
stopRow =
&(interface_vals.previewStopPath[y * interface_vals.previewWidth ]);
resultRow =
&(resultRGBA[ y * interface_vals.previewWidth * 4]);
for (k = 0, j=0; k < interface_vals.previewWidth; ++k,j+=4) {
if (maskRow[k] > vals->threshold) {
resultRow[j] = 0;
resultRow[j+1] = 0;
resultRow[j+2] = 0;
if (stopRow[k] > 0) {
resultRow[j+3] = 255;
} else {
resultRow[j+3] = 0;
}
} else {
resultRow[j] = imageRow[j];
resultRow[j+1] = imageRow[j+1];
resultRow[j+2] = imageRow[j+2];
resultRow[j+3] = imageRow[j+3];;
}
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (interface_vals.preview_widget),
0, 0,
interface_vals.previewWidth,
interface_vals.previewHeight,
GIMP_RGBA_IMAGE,
resultRGBA,
interface_vals.previewWidth * 4);
g_free(resultRGBA);
}
static void
wmf_preview_callback (GtkWidget *widget,
GtkAllocation *allocation,
guchar *pixels)
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (widget),
0, 0, allocation->width, allocation->height,
GIMP_RGBA_IMAGE,
pixels, allocation->width * 4);
}
static void
gimp_aspect_preview_draw (GimpPreview *preview)
{
g_return_if_fail (GIMP_IS_ASPECT_PREVIEW (preview));
gimp_preview_area_fill (GIMP_PREVIEW_AREA (preview->area),
0, 0,
preview->width,
preview->height,
0, 0, 0);
}
static void
color_to_alpha_preview (GimpPreview *preview,
GimpDrawable *drawable)
{
GimpPixelRgn src_rgn;
gint x, y;
gint width, height;
gint bpp;
gint i;
guchar *src, *dest;
bpp = drawable->bpp;
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
dest = g_new (guchar, width * height * 4);
src = g_new (guchar, width * height * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
x, y, width, height,
FALSE, FALSE);
gimp_pixel_rgn_get_rect (&src_rgn, src, x, y, width, height);
for (i = 0; i < width * height; i++)
to_alpha_func (src + i * bpp, dest + i * 4, bpp, NULL);
g_free (src);
/* Our code assumes that the drawable has an alpha channel (and adds
* one later if the effect is actually performed). For that reason
* we have to take care when drawing the preview.
*/
if (bpp == 4)
{
gimp_preview_draw_buffer (preview, dest, width * 4);
}
else
{
/* This is not correct because we ignore the selection, but it
* is the best we can easily do.
*/
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
0, 0, width, height,
GIMP_RGBA_IMAGE, dest, width * 4);
}
g_free (dest);
}
static gboolean
area_realize (GimpPreviewArea *area)
{
GdkPixbuf *pixbuf;
pixbuf = load_image ("wilber-wizard.png");
gimp_preview_area_draw (GIMP_PREVIEW_AREA (area), 0, 0,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
GIMP_RGBA_IMAGE,
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf));
g_object_unref (pixbuf);
return FALSE;
}
static void
gimp_scrolled_preview_v_scroll (GtkAdjustment *vadj,
GimpPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
preview->yoff = gtk_adjustment_get_value (vadj);
gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (preview->area),
preview->xoff, preview->yoff);
if (! (priv->in_drag || priv->frozen))
{
gimp_preview_draw (preview);
gimp_preview_invalidate (preview);
}
}
static void
render_gray_image(Preview_t *preview_base, GimpPixelRgn *srcrgn)
{
guchar *src_row, *dest_buffer, *src, *dest;
gint row, col;
gint bpp, dwidth, dheight, pwidth, pheight;
gint *src_col;
GtkWidget *preview = preview_base->preview;
dwidth = srcrgn->w;
dheight = srcrgn->h;
pwidth = preview_base->widget_width;
pheight = preview_base->widget_height;
bpp = srcrgn->bpp;
src_row = g_new(guchar, dwidth * bpp);
dest_buffer = g_new(guchar, pwidth * pheight);
src_col = g_new(gint, pwidth);
for (col = 0; col < pwidth; col++)
src_col[col] = (col * dwidth / pwidth) * bpp;
dest = dest_buffer;
for (row = 0; row < pheight; row++) {
gimp_pixel_rgn_get_row(srcrgn, src_row, 0, row * dheight / pheight,
dwidth);
src = src_row;
for (col = 0; col < pwidth; col++) {
src = &src_row[src_col[col]];
*dest++ = *src;
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, pwidth, pheight,
GIMP_GRAY_IMAGE,
dest_buffer,
pwidth);
g_free(src_col);
g_free(src_row);
g_free(dest_buffer);
}
/*
* Handle the expose event on the preview
*/
static gboolean
nova_center_preview_expose (GtkWidget *widget,
GdkEvent *event,
NovaCenter *center)
{
if (show_cursor)
{
cairo_t *cr;
gint x, y, offx, offy;
gint width, height;
GimpPreviewArea *area = GIMP_PREVIEW_AREA (center->preview->area);
GtkAllocation allocation;
cr = gdk_cairo_create (gtk_widget_get_window (center->preview->area));
gimp_preview_transform (center->preview,
pvals.xcenter, pvals.ycenter,
&x, &y);
gtk_widget_get_allocation (GTK_WIDGET (area), &allocation);
offx = (allocation.width - area->width) / 2;
offy = (allocation.height - area->height) / 2;
gimp_preview_get_size (center->preview, &width, &height);
cairo_move_to (cr, offx + x + 0.5, 0);
cairo_line_to (cr, offx + x + 0.5, allocation.height);
cairo_move_to (cr, 0, offy + y + 0.5);
cairo_line_to (cr, allocation.width, offy + y + 0.5);
cairo_set_line_width (cr, 3.0);
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.6);
cairo_stroke_preserve (cr);
cairo_set_line_width (cr, 1.0);
cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.8);
cairo_stroke (cr);
cairo_destroy (cr);
}
return FALSE;
}
static void
update_orient_map_preview_prev (void)
{
int x, y;
guchar black[3] = {0, 0, 0};
guchar gray[3] = {120, 120, 120};
guchar white[3] = {255, 255, 255};
if (!PPM_IS_INITED (&update_om_preview_nbuffer))
ppm_new (&update_om_preview_nbuffer,OMWIDTH,OMHEIGHT);
fill (&update_om_preview_nbuffer, black);
for (y = 6; y < OMHEIGHT-4; y += 10)
for (x = 6; x < OMWIDTH-4; x += 10)
{
double dir =
gimp_deg_to_rad (get_direction (x / (double)OMWIDTH,
y / (double)OMHEIGHT,0));
double xo = sin (dir) * 4.0;
double yo = cos (dir) * 4.0;
ppm_drawline (&update_om_preview_nbuffer,
x - xo, y - yo, x + xo, y + yo,
gray);
ppm_put_rgb (&update_om_preview_nbuffer,
x - xo, y - yo,
white);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (orient_map_preview_prev),
0, 0, OMWIDTH, OMHEIGHT,
GIMP_RGB_IMAGE,
(guchar *)update_om_preview_nbuffer.col,
OMWIDTH * 3);
gtk_widget_queue_draw (orient_map_preview_prev);
gtk_widget_set_sensitive (prev_button, (num_vectors > 1));
gtk_widget_set_sensitive (next_button, (num_vectors > 1));
gtk_widget_set_sensitive (add_button, (num_vectors < MAXORIENTVECT));
gtk_widget_set_sensitive (kill_button, (num_vectors > 1));
}
void
sinus_do_preview (GtkWidget *widget)
{
static GtkWidget *theWidget = NULL;
gint rowsize;
guchar *buf;
params p;
if (!do_preview)
return;
if (theWidget == NULL)
{
theWidget = widget;
}
rowsize = thePreview->width * thePreview->bpp;
buf = g_new (guchar, thePreview->width*thePreview->height*thePreview->bpp);
p.height = thePreview->height;
p.width = thePreview->width;
prepare_coef (&p);
if (thePreview->bpp == 3) /* [dindinx]: it looks to me that this is always true... */
compute_block_x (buf, rowsize, 0, 0, thePreview->width, thePreview->height,
3, assign_block_3, &p);
else if (thePreview->bpp == 1)
{
compute_block_x (buf, rowsize, 0, 0, thePreview->width,
thePreview->height, 1, assign_block_1, &p);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (theWidget),
0, 0, thePreview->width, thePreview->height,
GIMP_RGB_IMAGE,
buf,
rowsize);
g_free (buf);
}
void
rcm_render_circle (GtkWidget *preview,
int sum,
int margin)
{
gint i, j;
gdouble h, s, v;
guchar *a;
if (preview == NULL) return;
a = g_new (guchar, 3*sum*sum);
for (j = 0; j < sum; j++)
{
for (i = 0; i < sum; i++)
{
s = sqrt ((SQR (i - sum / 2.0) + SQR (j - sum / 2.0)) / (float) SQR (sum / 2.0 - margin));
if (s > 1)
{
a[(j*sum+i)*3+0] = 255;
a[(j*sum+i)*3+1] = 255;
a[(j*sum+i)*3+2] = 255;
}
else
{
h = arctg (sum / 2.0 - j, i - sum / 2.0) / (2 * G_PI);
v = 1 - sqrt (s) / 4;
gimp_hsv_to_rgb4 (&a[(j*sum+i)*3], h, s, v);
}
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, sum, sum,
GIMP_RGB_IMAGE,
a,
sum * 3);
g_free (a);
}
static void
dialog_update_previews (GtkWidget *widget,
gpointer data)
{
gint i, j;
guchar buf[PREVIEW_SIZE * PREVIEW_SIZE * 3];
for (j = 0; j < 9; j++)
{
optimize (&info[(j + 5) % 9]);
for (i = 0; i < PREVIEW_SIZE; i++)
{
qbist (&info[(j + 5) % 9], buf + i * PREVIEW_SIZE * 3,
0, i, PREVIEW_SIZE, PREVIEW_SIZE, PREVIEW_SIZE, 3, 1);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview[j]),
0, 0, PREVIEW_SIZE, PREVIEW_SIZE,
GIMP_RGB_IMAGE,
buf,
PREVIEW_SIZE *3);
}
}
static void paper_update_preview (void)
{
gint i, j;
guchar *buf, *paper_preview_buffer;
gdouble sc;
ppm_t p = {0, 0, NULL};
ppm_load (pcvals.selected_paper, &p);
sc = p.width > p.height ? p.width : p.height;
sc = 100.0 / sc;
resize (&p, p.width*sc,p.height*sc);
paper_preview_buffer = g_new0 (guchar, 100*100);
for (i = 0, buf = paper_preview_buffer; i < 100; i++, buf += 100)
{
gint k = i * p.width * 3;
if (i < p.height)
{
for (j = 0; j < p.width; j++)
buf[j] = p.col[k + j * 3];
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (paper_invert)))
for (j = 0; j < p.width; j++)
buf[j] = 255 - buf[j];
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (paper_preview),
0, 0, 100, 100,
GIMP_GRAY_IMAGE,
paper_preview_buffer,
100);
ppm_kill (&p);
g_free (paper_preview_buffer);
gtk_widget_queue_draw (paper_preview);
}
/* render before/after preview */
void
rcm_render_preview (GtkWidget *preview)
{
ReducedImage *reduced;
gint version;
gint RW, RH, bytes, i, j;
guchar *a;
guchar *rgb_array;
gdouble *hsv_array;
gfloat degree;
g_return_if_fail (preview != NULL);
version = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (preview), "mode"));
reduced = Current_c.reduced;
RW = reduced->width;
RH = reduced->height;
bytes = Current_c.drawable->bpp;
hsv_array = reduced->hsv;
rgb_array = reduced->rgb;
a = g_new (guchar, 4 * RW * RH);
if (version == CURRENT)
{
gdouble H, S, V;
guchar rgb[3];
for (i = 0; i < RH; i++)
{
for (j = 0; j < RW; j++)
{
gboolean unchanged = FALSE;
gboolean skip = FALSE;
H = hsv_array[i*RW*bytes + j*bytes + 0];
S = hsv_array[i*RW*bytes + j*bytes + 1];
V = hsv_array[i*RW*bytes + j*bytes + 2];
if (rcm_is_gray(S) && (reduced->mask[i*RW+j] != 0))
{
switch (Current_c.Gray_to_from)
{
case GRAY_FROM:
if (rcm_angle_inside_slice (Current_c.Gray->hue,
Current_c.From->angle) <= 1)
{
H = Current_c.Gray->hue/TP;
S = Current_c.Gray->satur;
}
else
skip = TRUE;
break;
case GRAY_TO:
unchanged = FALSE;
skip = TRUE;
gimp_hsv_to_rgb4 (rgb,
Current_c.Gray->hue/TP,
Current_c.Gray->satur,
V);
break;
default:
break;
}
}
if (!skip)
{
unchanged = FALSE;
H = rcm_linear (rcm_left_end (Current_c.From->angle),
rcm_right_end (Current_c.From->angle),
rcm_left_end (Current_c.To->angle),
rcm_right_end (Current_c.To->angle),
H * TP);
H = angle_mod_2PI(H) / TP;
gimp_hsv_to_rgb4 (rgb, H,S,V);
}
if (unchanged)
degree = 0;
else
degree = reduced->mask[i*RW+j] / 255.0;
a[(i*RW+j)*4+0] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 0] + degree * rgb[0];
a[(i*RW+j)*4+1] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 1] + degree * rgb[1];
a[(i*RW+j)*4+2] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 2] + degree * rgb[2];
/* apply transparency */
if (bytes == 4)
a[(i*RW+j)*4+3] = rgb_array[i*RW*bytes+j*bytes+3];
else
a[(i*RW+j)*4+3] = 255;
}
}
}
else /* ORIGINAL */
{
for (i = 0; i < RH; i++)
{
for (j = 0; j < RW; j++)
{
a[(i*RW+j)*4+0] = rgb_array[i*RW*bytes + j*bytes + 0];
a[(i*RW+j)*4+1] = rgb_array[i*RW*bytes + j*bytes + 1];
a[(i*RW+j)*4+2] = rgb_array[i*RW*bytes + j*bytes + 2];
if (bytes == 4)
a[(i*RW+j)*4+3] = rgb_array[i*RW*bytes+j*bytes+3];
else
a[(i*RW+j)*4+3] = 255;
}
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, RW, RH,
GIMP_RGBA_IMAGE,
a,
RW * 4);
g_free (a);
}
void preview_redraw(void)
{
if (!dialog_is_init) return;
if (is_3D_preview_active()) return;
if (local_vals.prev == 1)
{
// gimp_progress_init("Creating InsaneBump...");
_active = 't'; // for start
if (pDrawables.drawable_d != NULL) {
gimp_drawable_detach(pDrawables.drawable_d);
pDrawables.drawable_d = NULL;
}
if (pDrawables.drawable_ao != NULL) {
gimp_drawable_detach(pDrawables.drawable_ao);
pDrawables.drawable_ao = NULL;
}
if (pDrawables.drawable_s != NULL) {
gimp_drawable_detach(pDrawables.drawable_s);
pDrawables.drawable_s = NULL;
}
if (pDrawables.drawable_n != NULL) {
gimp_drawable_detach(pDrawables.drawable_n);
pDrawables.drawable_n = NULL;
}
if (pDrawables.drawable_p != NULL) {
gimp_drawable_detach(pDrawables.drawable_p);
pDrawables.drawable_p = NULL;
}
preview_specular_only(local_vals.image_ID);
if (pDrawables.drawable_d != NULL) {
_active = 'd' ;
draw_preview_area_update(pDrawables.preview_d, pDrawables.drawable_d);
} else {
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_d), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
_active = 'd' ;
}
if (pDrawables.drawable_ao != NULL) {
_active = 'a' ;
draw_preview_area_update(pDrawables.preview_ao, pDrawables.drawable_ao);
} else {
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_ao), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
_active = 'a' ;
}
if (pDrawables.drawable_s != NULL) {
_active = 's' ;
draw_preview_area_update(pDrawables.preview_s, pDrawables.drawable_s);
} else {
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_s), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
_active = 's' ;
}
if (pDrawables.drawable_p != NULL) {
_active = 'p' ;
draw_preview_area_update(pDrawables.preview_p, pDrawables.drawable_p);
} else {
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_p), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
_active = 'p' ;
}
if (pDrawables.drawable_n != NULL) {
_active = 'n' ;
draw_preview_area_update(pDrawables.preview_n, pDrawables.drawable_n);
} else {
gimp_preview_area_fill(GIMP_PREVIEW_AREA(pDrawables.preview_n), 0, 0, PREVIEW_SIZE, PREVIEW_SIZE, 0xF2, 0xF1, 0xF0);
}
removeAllLayersExceptMain();
preview_progress_reset = 0 ;
}
}
static gboolean
gimp_scrolled_preview_nav_button_press (GtkWidget *widget,
GdkEventButton *event,
GimpScrolledPreview *preview)
{
GimpPreview *gimp_preview = GIMP_PREVIEW (preview);
GtkAdjustment *adj;
if (preview->nav_popup)
return TRUE;
if (event->type == GDK_BUTTON_PRESS && event->button == 1)
{
GtkStyle *style = gtk_widget_get_style (widget);
GtkWidget *outer;
GtkWidget *inner;
GtkWidget *area;
GdkCursor *cursor;
gint x, y;
gdouble h, v;
preview->nav_popup = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (preview->nav_popup),
gtk_widget_get_screen (widget));
outer = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (outer), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (preview->nav_popup), outer);
gtk_widget_show (outer);
inner = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (inner), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (outer), inner);
gtk_widget_show (inner);
area = g_object_new (GIMP_TYPE_PREVIEW_AREA,
"check-size", GIMP_CHECK_SIZE_SMALL_CHECKS,
"check-type", GIMP_PREVIEW_AREA (gimp_preview->area)->check_type,
NULL);
gtk_container_add (GTK_CONTAINER (inner), area);
g_signal_connect (area, "event",
G_CALLBACK (gimp_scrolled_preview_nav_popup_event),
preview);
g_signal_connect_after (area, "expose-event",
G_CALLBACK (gimp_scrolled_preview_nav_popup_expose),
preview);
GIMP_PREVIEW_GET_CLASS (preview)->draw_thumb (gimp_preview,
GIMP_PREVIEW_AREA (area),
POPUP_SIZE, POPUP_SIZE);
gtk_widget_realize (area);
gtk_widget_show (area);
gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y);
adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
h = ((gtk_adjustment_get_value (adj) /
gtk_adjustment_get_upper (adj)) +
(gtk_adjustment_get_page_size (adj) /
gtk_adjustment_get_upper (adj)) / 2.0);
adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
v = ((gtk_adjustment_get_value (adj) /
gtk_adjustment_get_upper (adj)) +
(gtk_adjustment_get_page_size (adj) /
gtk_adjustment_get_upper (adj)) / 2.0);
x += event->x - h * (gdouble) GIMP_PREVIEW_AREA (area)->width;
y += event->y - v * (gdouble) GIMP_PREVIEW_AREA (area)->height;
gtk_window_move (GTK_WINDOW (preview->nav_popup),
x - 2 * style->xthickness,
y - 2 * style->ythickness);
gtk_widget_show (preview->nav_popup);
gtk_grab_add (area);
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
GDK_FLEUR);
gdk_pointer_grab (gtk_widget_get_window (area), TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
gtk_widget_get_window (area), cursor,
event->time);
gdk_cursor_unref (cursor);
}
return TRUE;
}
static void
updatesmvectorprev (void)
{
static int ok = 0;
gint i, x, y;
gdouble val;
static gdouble last_val = 0.0;
guchar gray[3] = {120, 120, 120};
guchar red[3] = {255, 0, 0};
guchar white[3] = {255, 255, 255};
if (smvectprevbrightadjust)
val = 1.0 - gtk_adjustment_get_value (GTK_ADJUSTMENT (smvectprevbrightadjust)) / 100.0;
else
val = 0.5;
if (!ok || (val != last_val))
{
#if 0
if (!PPM_IS_INITED (&infile))
updatepreview (NULL, (void *)2); /* Force grabarea () */
ppm_copy (&infile, &update_vector_preview_backup);
#else
infile_copy_to_ppm (&update_vector_preview_backup);
#endif
ppm_apply_brightness (&update_vector_preview_backup, val, 1,1,1);
if (update_vector_preview_backup.width != OMWIDTH ||
update_vector_preview_backup.height != OMHEIGHT)
resize_fast (&update_vector_preview_backup, OMWIDTH, OMHEIGHT);
ok = 1;
}
ppm_copy (&update_vector_preview_backup, &update_vector_preview_sbuffer);
for (i = 0; i < numsmvect; i++)
{
x = smvector[i].x * OMWIDTH;
y = smvector[i].y * OMHEIGHT;
if (i == selectedsmvector)
{
ppm_drawline (&update_vector_preview_sbuffer, x-5, y, x+5, y, red);
ppm_drawline (&update_vector_preview_sbuffer, x, y-5, x, y+5, red);
}
else
{
ppm_drawline (&update_vector_preview_sbuffer, x-5, y, x+5, y, gray);
ppm_drawline (&update_vector_preview_sbuffer, x, y-5, x, y+5, gray);
}
ppm_put_rgb (&update_vector_preview_sbuffer, x, y, white);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (smvectorprev),
0, 0, OMWIDTH, OMHEIGHT,
GIMP_RGB_IMAGE,
update_vector_preview_sbuffer.col,
OMWIDTH * 3);
gtk_widget_set_sensitive (prev_button, (numsmvect > 1));
gtk_widget_set_sensitive (next_button, (numsmvect > 1));
gtk_widget_set_sensitive (add_button, (numsmvect < MAXORIENTVECT));
gtk_widget_set_sensitive (kill_button, (numsmvect > 1));
}
static void
render_rgb_image(Preview_t *preview_base, GimpPixelRgn *srcrgn)
{
guchar *src_row, *dest_buffer, *src, *dest;
gint row, col;
gint dwidth, dheight, pwidth, pheight;
gint *src_col;
gint bpp, alpha, has_alpha, b;
guchar check;
gboolean gray = get_map_info()->show_gray;
GtkWidget *preview = preview_base->preview;
dwidth = srcrgn->w;
dheight = srcrgn->h;
pwidth = preview_base->widget_width;
pheight = preview_base->widget_height;
bpp = srcrgn->bpp;
alpha = bpp;
has_alpha = gimp_drawable_has_alpha(srcrgn->drawable->drawable_id);
if (has_alpha)
alpha--;
src_row = g_new(guchar, dwidth * bpp);
dest_buffer = g_new(guchar, pwidth * pheight * bpp);
src_col = g_new(gint, pwidth);
for (col = 0; col < pwidth; col++)
src_col[col] = (col * dwidth / pwidth) * bpp;
dest = dest_buffer;
for (row = 0; row < pheight; row++) {
gimp_pixel_rgn_get_row(srcrgn, src_row, 0, row * dheight / pheight,
dwidth);
for (col = 0; col < pwidth; col++) {
src = &src_row[src_col[col]];
if(!has_alpha || src[alpha] == OPAQUE) {
/* no alpha channel or opaque -- simple way */
for (b = 0; b < alpha; b++)
dest[b] = src[b];
} else {
/* more or less transparent */
if( ( col % (CHECKWIDTH*2) < CHECKWIDTH ) ^
( row % (CHECKWIDTH*2) < CHECKWIDTH ) )
check = LIGHTCHECK;
else
check = DARKCHECK;
if (src[alpha] == 0) {
/* full transparent -- check */
for (b = 0; b < alpha; b++)
dest[b] = check;
} else {
/* middlemost transparent -- mix check and src */
for (b = 0; b < alpha; b++)
dest[b] = (src[b] * src[alpha] +
check * (OPAQUE - src[alpha])) / OPAQUE;
}
}
if (gray) {
guchar avg;
avg = (299 * dest[0] + 587 * dest[1] + 114 * dest[2]) / 1000;
for (b = 0; b < alpha; b++)
dest[b] = avg;
}
dest += alpha;
}
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, pwidth, pheight,
GIMP_RGB_IMAGE,
dest_buffer,
pwidth * 3);
g_free(src_col);
g_free(src_row);
g_free(dest_buffer);
}
static void
render_indexed_image(Preview_t *preview_base, GimpPixelRgn *srcrgn)
{
guchar *src_row, *dest_buffer, *src, *dest;
gint row, col;
gint dwidth, dheight, pwidth, pheight;
gint *src_col;
gint bpp, alpha, has_alpha;
guchar *cmap, *colour;
gint ncols;
gboolean gray = get_map_info()->show_gray;
GtkWidget *preview = preview_base->preview;
dwidth = srcrgn->w;
dheight = srcrgn->h;
pwidth = preview_base->widget_width;
pheight = preview_base->widget_height;
bpp = srcrgn->bpp;
alpha = bpp;
has_alpha = gimp_drawable_has_alpha(srcrgn->drawable->drawable_id);
if (has_alpha)
alpha--;
cmap = gimp_image_get_colormap (gimp_item_get_image (srcrgn->drawable->drawable_id),
&ncols);
src_row = g_new(guchar, dwidth * bpp);
dest_buffer = g_new(guchar, pwidth * pheight * 3);
src_col = g_new(gint, pwidth);
for (col = 0; col < pwidth; col++)
src_col[col] = (col * dwidth / pwidth) * bpp;
dest = dest_buffer;
for (row = 0; row < pheight; row++) {
gimp_pixel_rgn_get_row(srcrgn, src_row, 0, row * dheight / pheight,
dwidth);
for (col = 0; col < pwidth; col++) {
src = &src_row[src_col[col]];
colour = cmap + 3 * (int)(*src);
if (gray) {
guchar avg = (299 * colour[0] + 587 * colour[1] +
114 * colour[2]) / 1000;
*dest++ = avg;
*dest++ = avg;
*dest++ = avg;
} else {
*dest++ = colour[0];
*dest++ = colour[1];
*dest++ = colour[2];
}
}
}
gimp_preview_area_draw(GIMP_PREVIEW_AREA(preview),
0, 0, pwidth, pheight,
GIMP_RGB_IMAGE,
dest_buffer,
pwidth * 3);
g_free(src_col);
g_free(src_row);
g_free(dest_buffer);
}
static void
update_brush_preview (const gchar *fn)
{
gint i, j;
guchar *preview_image;
if (fn)
brush_from_file = 1;
preview_image = g_new0 (guchar, 100*100);
if (!fn && brush_from_file)
{
/* preview_image is already initialized to our liking. */
}
else
{
double sc;
ppm_t p = {0, 0, NULL};
guchar gammatable[256];
int newheight;
if (brush_from_file)
brush_reload (fn, &p);
else if (PPM_IS_INITED (&brushppm))
ppm_copy (&brushppm, &p);
set_colorbrushes (fn);
sc = gtk_adjustment_get_value (brush_gamma_adjust);
if (sc != 1.0)
for (i = 0; i < 256; i++)
gammatable[i] = pow (i / 255.0, sc) * 255;
else
for (i = 0; i < 256; i++)
gammatable[i] = i;
newheight = p.height *
pow (10, gtk_adjustment_get_value (brush_aspect_adjust));
sc = p.width > newheight ? p.width : newheight;
sc = 100.0 / sc;
resize_fast (&p, p.width*sc,newheight*sc);
padbrush (&p, 100, 100);
for (i = 0; i < 100; i++)
{
int k = i * p.width * 3;
if (i < p.height)
for (j = 0; j < p.width; j++)
preview_image[i*100+j] = gammatable[p.col[k + j * 3]];
}
ppm_kill (&p);
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (brush_preview),
0, 0, 100, 100,
GIMP_GRAY_IMAGE,
preview_image,
100);
g_free (preview_image);
}
/* fill our preview image with the color-histogram */
static void
fillPreview (GtkWidget *preview)
{
guchar *image, *column, *pixel;
gint x, y, rowstride;
gdouble histcount, val;
rowstride = PREWIDTH * 3;
image = g_new0 (guchar, PREWIDTH * rowstride);
for (x = 0, column = image; x < PREWIDTH; x++, column += 3)
{
/*
* For every channel, calculate a logarithmic value, scale it,
* and build a one-pixel bar.
* ... in the respective channel, preserving the other ones. --hb
*/
histcount = hist_red[x] > 1.0 ? hist_red[x] : 1.0;
val = log (histcount) * (PREHEIGHT / 12);
if (val > PREHEIGHT)
val = PREHEIGHT;
y = PREHEIGHT - 1;
pixel = column + (y * rowstride);
for (; y > (PREHEIGHT - val); y--)
{
pixel[0] = 255;
pixel -= rowstride;
}
histcount = hist_green[x] > 1.0 ? hist_green[x] : 1.0;
val = log (histcount) * (PREHEIGHT / 12);
if (val > PREHEIGHT)
val = PREHEIGHT;
y = PREHEIGHT - 1;
pixel = column + (y * rowstride);
for (; y > (PREHEIGHT - val); y--)
{
pixel[1] = 255;
pixel -= rowstride;
}
histcount = hist_blue[x] > 1.0 ? hist_blue[x] : 1.0;
val = log (histcount) * (PREHEIGHT / 12);
if (val > PREHEIGHT)
val = PREHEIGHT;
y = PREHEIGHT - 1;
pixel = column + (y * rowstride);
for (; y > (PREHEIGHT - val); y--)
{
pixel[2] = 255;
pixel -= rowstride;
}
}
/* move our data into the preview image */
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview),
0, 0, PREWIDTH, PREHEIGHT,
GIMP_RGB_IMAGE,
image,
3 * PREWIDTH);
g_free (image);
}
