cairo_surface_t *
ink_cairo_surface_create_for_argb32_pixbuf(GdkPixbuf *pb)
{
guchar *data = gdk_pixbuf_get_pixels(pb);
int w = gdk_pixbuf_get_width(pb);
int h = gdk_pixbuf_get_height(pb);
int stride = gdk_pixbuf_get_rowstride(pb);
cairo_surface_t *pbs = cairo_image_surface_create_for_data(
data, CAIRO_FORMAT_ARGB32, w, h, stride);
return pbs;
}
static gboolean
pixdata_equal (GdkPixbuf *p1, GdkPixbuf *p2)
{
if (gdk_pixbuf_get_colorspace (p1) != gdk_pixbuf_get_colorspace (p2))
return FALSE;
if (gdk_pixbuf_get_n_channels (p1) != gdk_pixbuf_get_n_channels (p2))
return FALSE;
if (gdk_pixbuf_get_bits_per_sample (p1) != gdk_pixbuf_get_bits_per_sample (p2))
return FALSE;
if (gdk_pixbuf_get_width (p1) != gdk_pixbuf_get_width (p2))
return FALSE;
if (gdk_pixbuf_get_height (p1) != gdk_pixbuf_get_height (p2))
return FALSE;
if (gdk_pixbuf_get_rowstride (p1) != gdk_pixbuf_get_rowstride (p2))
return FALSE;
if (memcmp (gdk_pixbuf_get_pixels (p1), gdk_pixbuf_get_pixels (p2),
gdk_pixbuf_get_byte_length (p1)) != 0)
return FALSE;
return TRUE;
}
/** Create a pixbuf from a GdkPixbuf.
* The constructor takes ownership of the passed GdkPixbuf reference,
* so it should not be unrefed. */
Pixbuf::Pixbuf(GdkPixbuf *pb)
: _pixbuf(pb)
, _surface(0)
, _mod_time(0)
, _pixel_format(PF_GDK)
, _cairo_store(false)
{
_forceAlpha();
_surface = cairo_image_surface_create_for_data(
gdk_pixbuf_get_pixels(_pixbuf), CAIRO_FORMAT_ARGB32,
gdk_pixbuf_get_width(_pixbuf), gdk_pixbuf_get_height(_pixbuf), gdk_pixbuf_get_rowstride(_pixbuf));
}
/**
* eel_gdk_pixbuf_fill_rectangle_with_color:
* @pixbuf: Target pixbuf to fill into.
* @area: Rectangle to fill.
* @color: The color to use.
*
* Fill the rectangle with the the given color.
*/
void
eel_gdk_pixbuf_fill_rectangle_with_color (GdkPixbuf *pixbuf,
EelIRect area,
guint32 color)
{
EelIRect target;
guchar red;
guchar green;
guchar blue;
guchar alpha;
guchar *pixels;
gboolean has_alpha;
guint pixel_offset;
guint rowstride;
guchar *row_offset;
int x;
int y;
g_return_if_fail (eel_gdk_pixbuf_is_valid (pixbuf));
target = eel_gdk_pixbuf_intersect (pixbuf, 0, 0, area);
if (eel_irect_is_empty (&target)) {
return;
}
pixels = gdk_pixbuf_get_pixels (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
pixel_offset = has_alpha ? 4 : 3;
red = EEL_RGBA_COLOR_GET_R (color);
green = EEL_RGBA_COLOR_GET_G (color);
blue = EEL_RGBA_COLOR_GET_B (color);
alpha = EEL_RGBA_COLOR_GET_A (color);
row_offset = pixels + target.y0 * rowstride;
for (y = target.y0; y < target.y1; y++) {
guchar *offset = row_offset + (target.x0 * pixel_offset);
for (x = target.x0; x < target.x1; x++) {
*(offset++) = red;
*(offset++) = green;
*(offset++) = blue;
if (has_alpha) {
*(offset++) = alpha;
}
}
row_offset += rowstride;
}
}
static cairo_surface_t *
display_create_shm_surface_from_file(struct display *display,
const char *filename,
struct rectangle *rect)
{
cairo_surface_t *surface;
GdkPixbuf *pixbuf;
GError *error = NULL;
int stride, i;
unsigned char *pixels, *p, *end, *dest_data;
int dest_stride;
uint32_t *d;
pixbuf = gdk_pixbuf_new_from_file_at_scale(filename,
rect->width, rect->height,
FALSE, &error);
if (error != NULL)
return NULL;
if (!gdk_pixbuf_get_has_alpha(pixbuf) ||
gdk_pixbuf_get_n_channels(pixbuf) != 4) {
gdk_pixbuf_unref(pixbuf);
return NULL;
}
stride = gdk_pixbuf_get_rowstride(pixbuf);
pixels = gdk_pixbuf_get_pixels(pixbuf);
surface = display_create_shm_surface(display, rect);
dest_data = cairo_image_surface_get_data (surface);
dest_stride = cairo_image_surface_get_stride (surface);
for (i = 0; i < rect->height; i++) {
d = (uint32_t *) (dest_data + i * dest_stride);
p = pixels + i * stride;
end = p + rect->width * 4;
while (p < end) {
unsigned int t;
unsigned char a, r, g, b;
a = p[3];
MULT(r, p[0], a, t);
MULT(g, p[1], a, t);
MULT(b, p[2], a, t);
p += 4;
*d++ = (a << 24) | (r << 16) | (g << 8) | b;
}
}
gdk_pixbuf_unref(pixbuf);
return surface;
}
GdkPixbuf *
eel_create_spotlight_pixbuf (GdkPixbuf* src)
{
GdkPixbuf *dest;
int i, j;
int width, height, has_alpha, src_row_stride, dst_row_stride;
guchar *target_pixels, *original_pixels;
guchar *pixsrc, *pixdest;
g_return_val_if_fail (gdk_pixbuf_get_colorspace (src) == GDK_COLORSPACE_RGB, NULL);
g_return_val_if_fail ((!gdk_pixbuf_get_has_alpha (src)
&& gdk_pixbuf_get_n_channels (src) == 3)
|| (gdk_pixbuf_get_has_alpha (src)
&& gdk_pixbuf_get_n_channels (src) == 4), NULL);
g_return_val_if_fail (gdk_pixbuf_get_bits_per_sample (src) == 8, NULL);
dest = create_new_pixbuf (src);
has_alpha = gdk_pixbuf_get_has_alpha (src);
width = gdk_pixbuf_get_width (src);
height = gdk_pixbuf_get_height (src);
dst_row_stride = gdk_pixbuf_get_rowstride (dest);
src_row_stride = gdk_pixbuf_get_rowstride (src);
target_pixels = gdk_pixbuf_get_pixels (dest);
original_pixels = gdk_pixbuf_get_pixels (src);
for (i = 0; i < height; i++) {
pixdest = target_pixels + i * dst_row_stride;
pixsrc = original_pixels + i * src_row_stride;
for (j = 0; j < width; j++) {
*pixdest++ = lighten_component (*pixsrc++);
*pixdest++ = lighten_component (*pixsrc++);
*pixdest++ = lighten_component (*pixsrc++);
if (has_alpha) {
*pixdest++ = *pixsrc++;
}
}
}
return dest;
}
/* Started from from http://www.gtkforums.com/about5204.html
* Author: tadeboro */
GdkPixbuf *
_gdk_pixbuf_new_from_cairo_surface (cairo_surface_t *surface)
{
int width;
int height;
int s_stride;
unsigned char *s_pixels;
GdkPixbuf *pixbuf;
int p_stride;
guchar *p_pixels;
int p_n_channels;
if (surface == NULL)
return NULL;
if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS)
return NULL;
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
s_stride = cairo_image_surface_get_stride (surface);
s_pixels = _cairo_image_surface_flush_and_get_data (surface);
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, _cairo_image_surface_get_has_alpha (surface), 8, width, height);
p_stride = gdk_pixbuf_get_rowstride (pixbuf);
p_pixels = gdk_pixbuf_get_pixels (pixbuf);
p_n_channels = gdk_pixbuf_get_n_channels (pixbuf);
while (height--) {
guchar *s_iter = s_pixels;
guchar *p_iter = p_pixels;
int i;
for (i = 0; i < width; i++) {
gdouble alpha_factor = (gdouble) 0xff / s_iter[CAIRO_ALPHA];
p_iter[0] = (guchar) (alpha_factor * s_iter[CAIRO_RED] + .5);
p_iter[1] = (guchar) (alpha_factor * s_iter[CAIRO_GREEN] + .5);
p_iter[2] = (guchar) (alpha_factor * s_iter[CAIRO_BLUE] + .5);
if (p_n_channels == 4)
p_iter[3] = s_iter[CAIRO_ALPHA];
s_iter += 4;
p_iter += p_n_channels;
}
s_pixels += s_stride;
p_pixels += p_stride;
}
return pixbuf;
}
static void
opt_show_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
OptShow *show = OPT_SHOW(object);
OptShowPrivate *priv;
priv = show->priv;
switch (prop_id)
{
case PROP_TITLE_BORDER_SIZE:
priv->title_border_size = g_value_get_int (value);
break;
case PROP_TITLE_BULLET_PAD:
priv->title_bullet_pad = g_value_get_int (value);
break;
case PROP_BULLET_BORDER_SIZE:
priv->bullet_border_size = g_value_get_int (value);
break;
case PROP_BULLET_PAD:
priv->bullet_pad = g_value_get_int (value);
break;
case PROP_TITLE_FONT:
if (priv->title_font) g_free (priv->title_font);
priv->title_font = g_value_dup_string (value);
break;
case PROP_BULLET_FONT:
if (priv->bullet_font) g_free (priv->bullet_font);
priv->bullet_font = g_value_dup_string (value);
break;
case PROP_BACKGROUND:
priv->background = g_value_get_object (value);
clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (priv->bg),
gdk_pixbuf_get_pixels (priv->background),
gdk_pixbuf_get_has_alpha (priv->background),
gdk_pixbuf_get_width (priv->background),
gdk_pixbuf_get_height (priv->background),
gdk_pixbuf_get_rowstride (priv->background),
gdk_pixbuf_get_n_channels (priv->background),
0,
NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
GdkPixbuf* BitmapImage::getGdkPixbuf()
{
int width = cairo_image_surface_get_width(frameAtIndex(currentFrame()));
int height = cairo_image_surface_get_height(frameAtIndex(currentFrame()));
unsigned char* surfaceData = cairo_image_surface_get_data(frameAtIndex(currentFrame()));
int surfaceRowStride = cairo_image_surface_get_stride(frameAtIndex(currentFrame()));
GdkPixbuf* dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
if (!dest)
return 0;
guchar* pixbufData = gdk_pixbuf_get_pixels(dest);
int pixbufRowStride = gdk_pixbuf_get_rowstride(dest);
/* From: http://cairographics.org/manual/cairo-image-surface.html#cairo-format-t
* "CAIRO_FORMAT_ARGB32: each pixel is a 32-bit quantity, with alpha in
* the upper 8 bits, then red, then green, then blue. The 32-bit
* quantities are stored native-endian. Pre-multiplied alpha is used.
* (That is, 50% transparent red is 0x80800000, not 0x80ff0000.)"
*
* See http://developer.gimp.org/api/2.0/gdk-pixbuf/gdk-pixbuf-gdk-pixbuf.html#GdkPixbuf
* for information on the structure of GdkPixbufs stored with GDK_COLORSPACE_RGB.
*
* RGB color channels in CAIRO_FORMAT_ARGB32 are stored based on the
* endianness of the machine and are also multiplied by the alpha channel.
* To properly transfer the data from the Cairo surface we must divide each
* of the RGB channels by the alpha channel and then reorder all channels
* if this machine is little-endian.
*/
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
unsigned char* source = getCairoSurfacePixel(surfaceData, x, y, surfaceRowStride);
guchar* dest = getGdkPixbufPixel(pixbufData, x, y, pixbufRowStride);
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
guchar alpha = source[3];
dest[0] = alpha ? ((source[2] * 255) / alpha) : 0;
dest[1] = alpha ? ((source[1] * 255) / alpha) : 0;
dest[2] = alpha ? ((source[0] * 255) / alpha) : 0;
dest[3] = alpha;
#else
guchar alpha = source[0];
dest[0] = alpha ? ((source[1] * 255) / alpha) : 0;
dest[1] = alpha ? ((source[2] * 255) / alpha) : 0;
dest[2] = alpha ? ((source[3] * 255) / alpha) : 0;
dest[3] = alpha;
#endif
}
}
return dest;
}
static void flip_pixbuf (GdkPixbuf *pixbuf,
jboolean flip_x,
jboolean flip_y,
jint width,
jint height)
{
gint src_rs;
guchar *src_pix;
src_rs = gdk_pixbuf_get_rowstride (pixbuf);
src_pix = gdk_pixbuf_get_pixels (pixbuf);
if (flip_x)
{
gint i, channels;
guchar buf[4];
channels = gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3;
for (i = 0; i < height; i++)
{
guchar *left = src_pix + i * src_rs;
guchar *right = left + channels * (width - 1);
while (left < right)
{
g_memmove (buf, left, channels);
g_memmove (left, right, channels);
g_memmove (right, buf, channels);
left += channels;
right -= channels;
}
}
}
if (flip_y)
{
guchar *top = src_pix;
guchar *bottom = top + (height - 1) * src_rs;
gpointer buf = g_malloc (src_rs);
while (top < bottom)
{
g_memmove (buf, top, src_rs);
g_memmove (top, bottom, src_rs);
g_memmove (bottom, buf, src_rs);
top += src_rs;
bottom -= src_rs;
}
g_free (buf);
}
}
int main(int argc, char** argv)
{
GtkWidget *window;
int x, y;
gtk_init(&argc, &argv);
/* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_opacity(window, 0.7);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), "pressed");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_show(window);
gtk_main();
*/
GdkPixbuf* photo = gdk_pixbuf_new_from_file_at_size("bluesky.jpg", 300, 200, NULL);
//GdkPixbuf* image = gdk_pixbuf_new_from_data(photo,;
//photo = gdk_pixbuf_flip(photo, FALSE);
//gdk_pixbuf_fill(photo, 0xff00ff64);
//gdk_pixbuf_rotate_simple(photo, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
//gdk_pixbuf_save(photo, "thumbnail.png", "png", NULL, NULL);
guchar *pixels, *p;
int rowstride, n_channels, bits, width, height ;
GdkColorspace cs;
n_channels = gdk_pixbuf_get_n_channels(photo);
rowstride = gdk_pixbuf_get_rowstride(photo);
pixels = gdk_pixbuf_get_pixels(photo);
bits = gdk_pixbuf_get_bits_per_sample(photo);
cs = gdk_pixbuf_get_colorspace(photo);
width = gdk_pixbuf_get_width(photo);
height = gdk_pixbuf_get_height(photo);
printf("n_channels %d\n", n_channels);
printf("rowstride %d\n", rowstride);
printf("bits %d\n", bits);
printf("cs %d\n", cs);
printf("width %d\n", width);
printf("height %d\n", height);
//photo = gdk_pixbuf_new_from_data(pixels, cs, TRUE, bits, width, height, rowstride, NULL, NULL);
//gdk_pixbuf_add_alpha(photo, FALSE, 0, 0, 0);
for(x = 0; x < width; x++)
{
for(y = 0; y < height; y++)
{
put_pixel(photo, x, y, 100);
}
}
gdk_pixbuf_save(photo, "thumbnail.jpg", "jpeg", NULL, NULL);
return 0;
}
/**
* is_pixel_alpha:
**/
static gboolean
is_pixel_alpha (GdkPixbuf *pixbuf, guint x, guint y)
{
gint rowstride, n_channels;
guchar *pixels, *p;
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
p = pixels + y * rowstride + x * n_channels;
return p[3] == 0;
}
Pixbuf::Pixbuf()
{
_width = 500;
_height = 500;
_ref = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, _width, _height);
gdk_pixbuf_fill(_ref, 0xffffffff );
_scale = 1;
n_channels = gdk_pixbuf_get_n_channels(_ref);
rowstride = gdk_pixbuf_get_rowstride(_ref);
pixels = gdk_pixbuf_get_pixels(_ref);
};
/* ----------------------------------------------------
* p_create_desaturated_buf_from_pixbuf
* ----------------------------------------------------
*/
static void
p_create_desaturated_buf_from_pixbuf(GapPView *pv_ptr)
{
pv_ptr->pv_desaturated_area_data = g_new ( guchar
, pv_ptr->pv_height * pv_ptr->pv_width * pv_ptr->pv_bpp );
p_desaturate(pv_ptr
, gdk_pixbuf_get_pixels(pv_ptr->pixbuf)
, gdk_pixbuf_get_rowstride(pv_ptr->pixbuf)
);
} /* end p_create_desaturated_buf_from_pixbuf */
void
test_inspect (void)
{
const gchar *expected;
pixbuf1 = load_pixbuf("dark-circle.png");
pixbuf2 = load_pixbuf("small-circle-no-alpha.png");
expected = cut_take_printf("#<GdkPixbuf:%p "
"colorspace="
"<#<GdkColorspace: rgb(GDK_COLORSPACE_RGB:0)>>, "
"n-channels=<4>, "
"has-alpha=<TRUE>, "
"bits-per-sample=<8>, "
"width=<100>, "
"height=<100>, "
"rowstride=<400>, "
"pixels=<((gpointer) %p)>"
">",
pixbuf1,
gdk_pixbuf_get_pixels(pixbuf1));
cut_assert_equal_string_with_free(expected,
gcut_object_inspect(G_OBJECT(pixbuf1)));
expected = cut_take_printf("#<GdkPixbuf:%p "
"colorspace="
"<#<GdkColorspace: rgb(GDK_COLORSPACE_RGB:0)>>, "
"n-channels=<3>, "
"has-alpha=<FALSE>, "
"bits-per-sample=<8>, "
"width=<50>, "
"height=<50>, "
"rowstride=<152>, "
"pixels=<((gpointer) %p)>"
">",
pixbuf2,
gdk_pixbuf_get_pixels(pixbuf2));
cut_assert_equal_string_with_free(expected,
gcut_object_inspect(G_OBJECT(pixbuf2)));
}
/**
* games_card_textures_cache_get_card_texture_by_id:
* @cache:
* @card_id:
*
* Returns: a cached #CoglHandle for @card_id.
*/
CoglHandle
games_card_textures_cache_get_card_texture_by_id (GamesCardTexturesCache *cache,
guint card_id)
{
GamesCardTexturesCachePrivate *priv = cache->priv;
CoglHandle handle;
g_return_val_if_fail (card_id < GAMES_CARDS_TOTAL , NULL);
LOG_CALL (cache);
handle = priv->cards[card_id];
if (IS_FAILED_HANDLE (handle)) {
LOG_CACHE_HIT (cache);
return COGL_INVALID_HANDLE;
}
if (handle == COGL_INVALID_HANDLE) {
GdkPixbuf *pixbuf;
LOG_CACHE_MISS (cache);
pixbuf = games_card_theme_get_card_pixbuf (priv->theme, card_id);
if (!pixbuf) {
priv->cards[card_id] = FAILED_HANDLE;
return COGL_INVALID_HANDLE;
}
handle = cogl_texture_new_from_data (gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
64, FALSE,
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
gdk_pixbuf_get_rowstride (pixbuf),
gdk_pixbuf_get_pixels (pixbuf));
g_object_unref (pixbuf);
if (handle == COGL_INVALID_HANDLE) {
priv->cards[card_id] = FAILED_HANDLE;
return COGL_INVALID_HANDLE;
}
priv->cards[card_id] = handle;
} else {
LOG_CACHE_HIT (cache);
}
return handle;
}
static Image* LoadImage (ArchiveFile& file, const char *extension)
{
RGBAImage* image = (RGBAImage *) 0;
/* load the buffer from pk3 or filesystem */
ScopedArchiveBuffer buffer(file);
GdkPixbufLoader *loader = gdk_pixbuf_loader_new_with_type(extension, (GError**) 0);
if (loader == (GdkPixbufLoader*)0) {
g_warning("could not get a loader for: '%s'\n", extension);
return image;
}
GError *error = (GError *) 0;
if (gdk_pixbuf_loader_write(loader, (const guchar *) buffer.buffer, static_cast<gsize> (buffer.length),
&error)) {
int pos = 0;
GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
const int width = gdk_pixbuf_get_width(pixbuf);
const int height = gdk_pixbuf_get_height(pixbuf);
const gboolean hasAlpha = gdk_pixbuf_get_has_alpha(pixbuf);
const int stepWidth = gdk_pixbuf_get_n_channels(pixbuf);
const guchar *pixels = gdk_pixbuf_get_pixels(pixbuf);
image = new RGBAImage(width, height, false);
byte *rgba = image->getRGBAPixels();
const int rowextra = gdk_pixbuf_get_rowstride(pixbuf) - width * stepWidth;
for (int y = 0; y < height; ++y, pixels += rowextra) {
for (int x = 0; x < width; ++x) {
rgba[pos++] = *(pixels++);
rgba[pos++] = *(pixels++);
rgba[pos++] = *(pixels++);
if (hasAlpha && *pixels != 255)
image->setHasAlpha(true);
rgba[pos++] = hasAlpha ? *(pixels++) : 255;
}
}
g_object_unref(pixbuf);
} else {
g_warning("image could not get loaded: '%s' %s\n",
file.getName().c_str(), (error != (GError *) 0) ? error->message : "");
if (error)
g_error_free(error);
}
gdk_pixbuf_loader_close(loader, (GError**) 0);
return image;
}
void HudIconTextureSource::ColorForIcon(GdkPixbuf* pixbuf)
{
if (GDK_IS_PIXBUF(pixbuf))
{
unsigned int width = gdk_pixbuf_get_width(pixbuf);
unsigned int height = gdk_pixbuf_get_height(pixbuf);
unsigned int row_bytes = gdk_pixbuf_get_rowstride(pixbuf);
long int rtotal = 0, gtotal = 0, btotal = 0;
float total = 0.0f;
guchar* img = gdk_pixbuf_get_pixels(pixbuf);
for (unsigned int i = 0; i < width; i++)
{
for (unsigned int j = 0; j < height; j++)
{
guchar* pixels = img + (j * row_bytes + i * 4);
guchar r = *(pixels + 0);
guchar g = *(pixels + 1);
guchar b = *(pixels + 2);
guchar a = *(pixels + 3);
float saturation = (MAX(r, MAX(g, b)) - MIN(r, MIN(g, b))) / 255.0f;
float relevance = .1 + .9 * (a / 255.0f) * saturation;
rtotal += (guchar)(r * relevance);
gtotal += (guchar)(g * relevance);
btotal += (guchar)(b * relevance);
total += relevance * 255;
}
}
nux::color::RedGreenBlue rgb(rtotal / total,
gtotal / total,
btotal / total);
nux::color::HueSaturationValue hsv(rgb);
if (hsv.saturation > 0.15f)
hsv.saturation = 0.65f;
hsv.value = 0.90f;
bg_color = nux::Color(nux::color::RedGreenBlue(hsv));
}
else
{
LOG_ERROR(logger) << "Pixbuf (" << pixbuf << ") passed is non valid";
bg_color = nux::Color(255,255,255,255);
}
}
void CriaQuadTree(node **raiz, GdkPixbuf *imagem) {
if ( cor_uniforme(imagem) ) {
guchar *pixels = gdk_pixbuf_get_pixels (imagem);
guint32 pixel;
pixel = (
pixels[0] << 24 |
pixels[1] << 16 |
pixels[2] << 8
);
(*raiz)->cor = pixel;
(*raiz)->width = gdk_pixbuf_get_width (imagem);
(*raiz)->height = gdk_pixbuf_get_height (imagem);
}
else {
node *ES = new_node();
node *EI = new_node();
node *DS = new_node();
node *DI = new_node();
(*raiz)->EsqInferior = EI;
(*raiz)->EsqSuperior = ES;
(*raiz)->DirInferior = DI;
(*raiz)->DirSuperior = DS;
(*raiz)->width = gdk_pixbuf_get_width (imagem);
(*raiz)->height = gdk_pixbuf_get_height (imagem);
int width_total = gdk_pixbuf_get_width (imagem);
int height_total = gdk_pixbuf_get_height (imagem);
int width_ES = width_total/2;
int height_ES = height_total/2;
GdkPixbuf *subpixbuf = gdk_pixbuf_new_subpixbuf (imagem, 0, 0,
width_ES,
height_ES);
CriaQuadTree(&ES, subpixbuf);
subpixbuf = gdk_pixbuf_new_subpixbuf (imagem, 0, height_ES,
width_ES,
height_total - height_ES);
CriaQuadTree(&EI, subpixbuf);
subpixbuf = gdk_pixbuf_new_subpixbuf (imagem, width_ES, 0,
width_total - width_ES,
height_ES);
CriaQuadTree(&DS, subpixbuf);
subpixbuf = gdk_pixbuf_new_subpixbuf (imagem, width_ES, height_ES,
width_total - width_ES,
height_total - height_ES);
CriaQuadTree(&DI, subpixbuf);
}
}
/* colorshift a pixbuf */
static void
do_colorshift (GdkPixbuf *dest, GdkPixbuf *src, int shift)
{
gint i, j;
gint width, height, has_alpha, srcrowstride, destrowstride;
guchar *target_pixels;
guchar *original_pixels;
guchar *pixsrc;
guchar *pixdest;
int val;
guchar r,g,b;
has_alpha = gdk_pixbuf_get_has_alpha (src);
width = gdk_pixbuf_get_width (src);
height = gdk_pixbuf_get_height (src);
srcrowstride = gdk_pixbuf_get_rowstride (src);
destrowstride = gdk_pixbuf_get_rowstride (dest);
target_pixels = gdk_pixbuf_get_pixels (dest);
original_pixels = gdk_pixbuf_get_pixels (src);
for (i = 0; i < height; i++) {
pixdest = target_pixels + i*destrowstride;
pixsrc = original_pixels + i*srcrowstride;
for (j = 0; j < width; j++) {
r = *(pixsrc++);
g = *(pixsrc++);
b = *(pixsrc++);
val = r + shift;
*(pixdest++) = CLAMP(val, 0, 255);
val = g + shift;
*(pixdest++) = CLAMP(val, 0, 255);
val = b + shift;
*(pixdest++) = CLAMP(val, 0, 255);
if (has_alpha)
*(pixdest++) = *(pixsrc++);
}
}
}
static CoglTexture *
pixbuf_to_cogl_texture (GdkPixbuf *pixbuf)
{
ClutterBackend *backend = clutter_get_default_backend ();
CoglContext *ctx = clutter_backend_get_cogl_context (backend);
return COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_rowstride (pixbuf),
gdk_pixbuf_get_pixels (pixbuf),
NULL));
}
/**
* shell_clutter_texture_set_from_pixbuf:
* texture: #ClutterTexture to be modified
* pixbuf: #GdkPixbuf to set as an image for #ClutterTexture
*
* Convenience function for setting an image for #ClutterTexture based on #GdkPixbuf.
* Copied from an example posted by hp in this thread http://mail.gnome.org/archives/gtk-devel-list/2008-September/msg00218.html
*
* Return value: %TRUE on success, %FALSE on failure
*/
gboolean
shell_clutter_texture_set_from_pixbuf (ClutterTexture *texture,
GdkPixbuf *pixbuf)
{
return clutter_texture_set_from_rgb_data (texture,
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf),
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? 4 : 3,
0, NULL);
}
static Image* LoadImageGDK (ArchiveFile& file)
{
// Allocate a new GdkPixBuf and create an alpha-channel with alpha=1.0
GdkPixbuf* rawPixbuf = gdk_pixbuf_new_from_file(file.getName().c_str(), NULL);
// Only create an alpha channel if the other rawPixbuf could be loaded
GdkPixbuf* img = (rawPixbuf != NULL) ? gdk_pixbuf_add_alpha(rawPixbuf, TRUE, 255, 0, 255) : NULL;
if (img != NULL) {
// Allocate a new image
RGBAImage* image = new RGBAImage(gdk_pixbuf_get_width(img), gdk_pixbuf_get_height(img), false);
// Initialise the source buffer pointers
guchar* gdkStart = gdk_pixbuf_get_pixels(img);
int rowstride = gdk_pixbuf_get_rowstride(img);
int numChannels = gdk_pixbuf_get_n_channels(img);
// Set the target buffer pointer to the first RGBAPixel
RGBAPixel* targetPixel = image->pixels;
// Now do an unelegant cycle over all the pixels and move them into the target
for (unsigned int y = 0; y < image->height; y++) {
for (unsigned int x = 0; x < image->width; x++) {
guchar* gdkPixel = gdkStart + y * rowstride + x * numChannels;
// Copy the values from the GdkPixel
targetPixel->red = gdkPixel[0];
targetPixel->green = gdkPixel[1];
targetPixel->blue = gdkPixel[2];
targetPixel->alpha = gdkPixel[3];
if (targetPixel->alpha != 255)
image->setHasAlpha(true);
// Increase the pointer
targetPixel++;
}
}
// Free the GdkPixbufs from the memory
g_object_unref(G_OBJECT(img));
g_object_unref(G_OBJECT(rawPixbuf));
return image;
} else {
g_warning("image could not get loaded: '%s'\n", file.getName().c_str());
}
// No image could be loaded, return NULL
return NULL;
}
void image_draw_vline(GdkPixbuf *img, int x, int y, int height, guint32 color)
{
guint32 *pixels = (guint32*) gdk_pixbuf_get_pixels(img);
int rowstride = gdk_pixbuf_get_rowstride(img);
int i;
g_assert(gdk_pixbuf_get_n_channels(img) == 4);
rowstride >>= 2;
pixels += x + y * rowstride;
for (i=height; i; i--) {
*pixels = color;
pixels += rowstride;
}
}
static inline uint32_t get_pixel(struct imgcache_element *element,
int X,
int Y)
{
GdkPixbuf *buf;
unsigned char *p;
buf = element->ptr;
p = gdk_pixbuf_get_pixels(buf);
p += Y * gdk_pixbuf_get_rowstride(buf);
p += X * 4;
return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
}
static void
gcm_cell_renderer_set_color (GcmCellRendererColor *renderer)
{
CdColorRGB8 rgb;
GdkPixbuf *pixbuf = NULL;
gint height = 26; /* TODO: needs to be a property */
gint width = 400; /* TODO: needs to be a property */
gint x, y;
guchar *pixels;
guint pos;
cmsHPROFILE profile_srgb = NULL;
cmsHPROFILE profile_lab = NULL;
cmsHTRANSFORM xform = NULL;
/* nothing set yet */
if (renderer->color == NULL)
goto out;
/* convert the color to sRGB */
profile_lab = cmsCreateLab2Profile (NULL);
profile_srgb = cmsCreate_sRGBProfile ();
xform = cmsCreateTransform (profile_lab, TYPE_Lab_DBL,
profile_srgb, TYPE_RGB_8,
INTENT_ABSOLUTE_COLORIMETRIC, 0);
cmsDoTransform (xform, renderer->color, &rgb, 1);
/* create a pixbuf of the right size */
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
for (y=0; y<height; y++) {
for (x=0; x<width; x++) {
pos = (y*width+x) * 3;
pixels[pos+0] = rgb.R;
pixels[pos+1] = rgb.G;
pixels[pos+2] = rgb.B;
}
}
out:
g_object_set (renderer, "pixbuf", pixbuf, NULL);
if (profile_srgb != NULL)
cmsCloseProfile (profile_srgb);
if (profile_lab != NULL)
cmsCloseProfile (profile_lab);
if (xform != NULL)
cmsDeleteTransform (xform);
if (pixbuf != NULL)
g_object_unref (pixbuf);
}
/*!
* \brief Draw an image to Dia's _Image
* \todo use maskColors to have some alpha support
*/
void
DiaOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
int width, int height, GfxImageColorMap *colorMap,
GBool interpolate, int *maskColors, GBool inlineImg)
{
DiaObject *obj;
GdkPixbuf *pixbuf;
Point pos;
ObjectChange *change;
double *ctm = state->getCTM();
pos.x = ctm[4] * scale;
// there is some undocumented magic done with the ctm for drawImage
// deduced from SplashOutputDev::drawImage()
// cmt[2] and ctm[3] being negative - use that for y postion
// ctm[0] and ctm[3] have width and height in device coordinates
pos.y = (ctm[5] + ctm[3]) * scale;
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, maskColors ? TRUE : FALSE, 8, width, height);
{
// 3 channels, 8 bit
ImageStream imgStr(str, width, colorMap->getNumPixelComps(), colorMap->getBits());
Guchar *line;
int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
int y;
imgStr.reset(); // otherwise getLine() is crashing right away
line = imgStr.getLine ();
for (y = 0; y < height && line; ++y) {
guchar *dest = pixels + y * rowstride;
colorMap->getRGBLine (line, dest, width);
// ToDo: respect maskColors
line = imgStr.getLine ();
}
}
obj = create_standard_image (pos.x, pos.y,
ctm[0] * scale,
ctm[3] * scale, NULL);
if ((change = dia_object_set_pixbuf (obj, pixbuf)) != NULL)
change->free (change); /* reference transfered */
else
g_object_unref (pixbuf);
addObject (obj);
}
static cairo_t *_mt_cairo_begin_pixbuf(MT_TOOLKIT *mt, MT_WINDOW *win, MT_RECTANGLE *area, int x, int y, int width, int height)
{
cairo_t *cr;
int xoff=0, yoff=0;
_cairo_buf = _mt_image_new(width, height);
_cairo_win = win;
mt_rectangle_set(_cairo_rect, x, y, width, height);
_cairo_surface = cairo_image_surface_create_for_data(gdk_pixbuf_get_pixels(_cairo_buf), CAIRO_FORMAT_RGB24, width, height, gdk_pixbuf_get_rowstride(_cairo_buf));
cr = cairo_create(_cairo_surface);
cairo_translate(cr, -xoff, -yoff);
return cr;
}
/**
* @brief Copy part of display
*
* @param display gui_diaplay instance
* @param rect rectangle to copy
* @param img
*
* @return
*/
wg_status
gui_display_copy(Gui_display *display, Wg_rect *rect, Wg_image *img)
{
wg_uchar *buffer = NULL;
Wg_image image;
Wg_image rect_image;
wg_uint width = 0;
wg_uint height = 0;
cam_status status = CAM_FAILURE;
gdk_threads_enter();
width = gdk_pixbuf_get_width(display->pixbuf);
height = gdk_pixbuf_get_height(display->pixbuf);
buffer = gdk_pixbuf_get_pixels(display->pixbuf);
status = img_rgb_from_buffer(buffer, width, height, &image);
if (CAM_FAILURE == status){
return WG_FAILURE;
}
gdk_threads_leave();
status = img_fill(rect->width, rect->height,
RGB24_COMPONENT_NUM, IMG_RGB, &rect_image);
if (CAM_FAILURE == status){
img_cleanup(&image);
return WG_FAILURE;
}
status = img_get_subimage(&image, rect->x, rect->y, &rect_image);
if (CAM_FAILURE == status){
img_cleanup(&image);
img_cleanup(&rect_image);
return WG_FAILURE;
}
status = img_rgb_2_hsv_gtk(&rect_image, img);
if (CAM_FAILURE == status){
img_cleanup(&image);
img_cleanup(&rect_image);
return WG_FAILURE;
}
img_cleanup(&image);
img_cleanup(&rect_image);
return WG_SUCCESS;
}
static void get_alpha_mask(float_shape_t *shape)
{
GdkColormap *colormap;
GdkColor black;
GdkColor white;
GdkGC *gc;
int rowstride, nchannels, x, y;
guchar *pixels, *p;
bool bright_green, has_alpha;
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
shape->mask_bitmap =
(GdkDrawable*)gdk_pixmap_new(NULL, shape->width, shape->height, 1);
gc = gdk_gc_new(shape->mask_bitmap);
gdk_gc_set_foreground(gc, &black);
gdk_gc_set_background(gc, &white);
gdk_draw_rectangle(shape->mask_bitmap, gc, TRUE, 0, 0,
shape->width, shape->height);
nchannels = gdk_pixbuf_get_n_channels(shape->pixbuf);
g_assert(gdk_pixbuf_get_colorspace(shape->pixbuf) == GDK_COLORSPACE_RGB);
g_assert(gdk_pixbuf_get_bits_per_sample(shape->pixbuf) == 8);
has_alpha = gdk_pixbuf_get_has_alpha(shape->pixbuf);
rowstride = gdk_pixbuf_get_rowstride(shape->pixbuf);
pixels = gdk_pixbuf_get_pixels(shape->pixbuf);
gdk_gc_set_foreground(gc, &white);
gdk_gc_set_background(gc, &black);
for (y = 0; y < shape->height; y++) {
for (x = 0; x < shape->width; x++) {
p = pixels + y*rowstride + x*nchannels;
bright_green = 0 == p[0] && 255 == p[1] && 0 == p[2];
if (has_alpha) {
if (255 == p[3]) // p[3] is alpha channel
gdk_draw_point(shape->mask_bitmap, gc, x, y);
}
else if (!bright_green) { // Bright green is alpha for RGB images
gdk_draw_point(shape->mask_bitmap, gc, x, y);
}
}
}
}
