cairo_pattern_t *
gimp_cairo_stipple_pattern_create (const GimpRGB *fg,
const GimpRGB *bg,
gint index)
{
cairo_surface_t *surface;
cairo_pattern_t *pattern;
guchar *data;
guchar *d;
guchar fg_r, fg_g, fg_b, fg_a;
guchar bg_r, bg_g, bg_b, bg_a;
gint x, y;
g_return_val_if_fail (fg != NULL, NULL);
g_return_val_if_fail (bg != NULL, NULL);
data = g_malloc (8 * 8 * 4);
gimp_rgba_get_uchar (fg, &fg_r, &fg_g, &fg_b, &fg_a);
gimp_rgba_get_uchar (bg, &bg_r, &bg_g, &bg_b, &bg_a);
d = data;
for (y = 0; y < 8; y++)
{
for (x = 0; x < 8; x++)
{
if ((x + y + index) % 8 >= 4)
GIMP_CAIRO_ARGB32_SET_PIXEL (d, fg_r, fg_g, fg_b, fg_a);
else
GIMP_CAIRO_ARGB32_SET_PIXEL (d, bg_r, bg_g, bg_b, bg_a);
d += 4;
}
}
surface = cairo_image_surface_create_for_data (data,
CAIRO_FORMAT_ARGB32,
8, 8, 8 * 4);
cairo_surface_set_user_data (surface, &surface_data_key,
data, (cairo_destroy_func_t) g_free);
pattern = cairo_pattern_create_for_surface (surface);
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
cairo_surface_destroy (surface);
return pattern;
}
static void
gimp_view_renderer_gradient_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpViewRendererGradient *rendergrad = GIMP_VIEW_RENDERER_GRADIENT (renderer);
GimpGradient *gradient = GIMP_GRADIENT (renderer->viewable);
GimpGradientSegment *seg = NULL;
GimpColorTransform *transform;
guchar *buf;
guchar *dest;
gint dest_stride;
gint x;
gint y;
gdouble dx, cur_x;
GimpRGB color;
buf = g_alloca (4 * renderer->width);
dx = (rendergrad->right - rendergrad->left) / (renderer->width - 1);
cur_x = rendergrad->left;
for (x = 0, dest = buf; x < renderer->width; x++, dest += 4)
{
guchar r, g, b, a;
seg = gimp_gradient_get_color_at (gradient, renderer->context, seg,
cur_x, rendergrad->reverse, &color);
cur_x += dx;
gimp_rgba_get_uchar (&color, &r, &g, &b, &a);
GIMP_CAIRO_ARGB32_SET_PIXEL (dest, r, g, b, a);
}
if (! renderer->surface)
renderer->surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
renderer->width,
renderer->height);
cairo_surface_flush (renderer->surface);
dest = cairo_image_surface_get_data (renderer->surface);
dest_stride = cairo_image_surface_get_stride (renderer->surface);
transform = gimp_view_renderer_get_color_transform (renderer, widget,
babl_format ("cairo-ARGB32"),
babl_format ("cairo-ARGB32"));
if (transform)
gimp_color_transform_process_pixels (transform,
babl_format ("cairo-ARGB32"), buf,
babl_format ("cairo-ARGB32"), buf,
renderer->width);
for (y = 0; y < renderer->height; y++, dest += dest_stride)
{
memcpy (dest, buf, renderer->width * 4);
}
cairo_surface_mark_dirty (renderer->surface);
}
static void
cdisplay_lcms_convert_surface (GimpColorDisplay *display,
cairo_surface_t *surface)
{
CdisplayLcms *lcms = CDISPLAY_LCMS (display);
gint width = cairo_image_surface_get_width (surface);
gint height = cairo_image_surface_get_height (surface);
gint stride = cairo_image_surface_get_stride (surface);
guchar *buf = cairo_image_surface_get_data (surface);
cairo_format_t fmt = cairo_image_surface_get_format (surface);
guchar *rowbuf;
gint x, y;
guchar r, g, b, a;
if (fmt != CAIRO_FORMAT_ARGB32)
return;
if (! lcms->transform)
return;
rowbuf = g_malloc (stride);
for (y = 0; y < height; y++, buf += stride)
{
/* Switch buf from ARGB premul to ARGB non-premul, since lcms ignores the
* alpha channel. The macro takes care of byte order.
*/
for (x = 0; x < width; x++)
{
GIMP_CAIRO_ARGB32_GET_PIXEL (buf + 4*x, r, g, b, a);
rowbuf[4*x+0] = a;
rowbuf[4*x+1] = r;
rowbuf[4*x+2] = g;
rowbuf[4*x+3] = b;
}
cmsDoTransform (lcms->transform, rowbuf, rowbuf, width);
/* And back to ARGB premul */
for (x = 0; x < width; x++)
{
a = rowbuf[4*x+0];
r = rowbuf[4*x+1];
g = rowbuf[4*x+2];
b = rowbuf[4*x+3];
GIMP_CAIRO_ARGB32_SET_PIXEL (buf + 4*x, r, g, b, a);
}
}
g_free (rowbuf);
}
static void
cdisplay_gamma_convert_surface (GimpColorDisplay *display,
cairo_surface_t *surface)
{
CdisplayGamma *gamma = CDISPLAY_GAMMA (display);
gint width = cairo_image_surface_get_width (surface);
gint height = cairo_image_surface_get_height (surface);
gint stride = cairo_image_surface_get_stride (surface);
guchar *buf = cairo_image_surface_get_data (surface);
cairo_format_t fmt = cairo_image_surface_get_format (surface);
gint i, j, skip;
gint r, g, b, a;
if (fmt != CAIRO_FORMAT_ARGB32)
return;
/* You will not be using the entire buffer most of the time.
* Hence, the simplistic code for this is as follows:
*
* for (j = 0; j < height; j++)
* {
* for (i = 0; i < width * bpp; i++)
* buf[i] = lookup[buf[i]];
* buf += bpl;
* }
*/
j = height;
skip = stride - 4 * width;
while (j--)
{
i = width;
while (i--)
{
GIMP_CAIRO_ARGB32_GET_PIXEL (buf, r, g, b, a);
r = gamma->lookup[r];
g = gamma->lookup[g];
b = gamma->lookup[b];
GIMP_CAIRO_ARGB32_SET_PIXEL (buf, r, g, b, a);
buf += 4;
}
buf += skip;
}
}
