void
nautilus_ui_frame_video (GdkPixbuf **pixbuf)
{
int width, height;
int holes_width, holes_height;
int i;
if (!ensure_filmholes ())
return;
width = gdk_pixbuf_get_width (*pixbuf);
height = gdk_pixbuf_get_height (*pixbuf);
holes_width = gdk_pixbuf_get_width (filmholes_left);
holes_height = gdk_pixbuf_get_height (filmholes_left);
for (i = 0; i < height; i += holes_height) {
gdk_pixbuf_composite (filmholes_left, *pixbuf, 0, i,
MIN (width, holes_width),
MIN (height - i, holes_height),
0, i, 1, 1, GDK_INTERP_NEAREST, 255);
}
for (i = 0; i < height; i += holes_height) {
gdk_pixbuf_composite (filmholes_right, *pixbuf,
width - holes_width, i,
MIN (width, holes_width),
MIN (height - i, holes_height),
width - holes_width, i,
1, 1, GDK_INTERP_NEAREST, 255);
}
}
static GdkPixbuf *
add_slideshow_frame (GdkPixbuf *pixbuf)
{
GdkPixbuf *sheet, *sheet2;
GdkPixbuf *tmp;
gint w, h;
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
sheet = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, w, h);
gdk_pixbuf_fill (sheet, 0x00000000);
sheet2 = gdk_pixbuf_new_subpixbuf (sheet, 1, 1, w - 2, h - 2);
gdk_pixbuf_fill (sheet2, 0xffffffff);
g_object_unref (sheet2);
tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, w + 6, h + 6);
gdk_pixbuf_fill (tmp, 0x00000000);
gdk_pixbuf_composite (sheet, tmp, 6, 6, w, h, 6.0, 6.0, 1.0, 1.0, GDK_INTERP_NEAREST, 255);
gdk_pixbuf_composite (sheet, tmp, 3, 3, w, h, 3.0, 3.0, 1.0, 1.0, GDK_INTERP_NEAREST, 255);
gdk_pixbuf_composite (pixbuf, tmp, 0, 0, w, h, 0.0, 0.0, 1.0, 1.0, GDK_INTERP_NEAREST, 255);
g_object_unref (sheet);
return tmp;
}
gboolean
xfwmPixmapRenderGdkPixbuf (xfwmPixmap * pm, GdkPixbuf *pixbuf)
{
GdkPixbuf *src;
GdkPixmap *destw;
GdkVisual *gvisual;
GdkColormap *cmap;
gint width, height;
gint dest_x, dest_y;
g_return_val_if_fail (pm != NULL, FALSE);
g_return_val_if_fail (pm->pixmap != None, FALSE);
g_return_val_if_fail (pm->mask != None, FALSE);
destw = gdk_xid_table_lookup (pm->pixmap);
if (destw)
{
g_object_ref (G_OBJECT (destw));
}
else
{
destw = gdk_pixmap_foreign_new (pm->pixmap);
}
if (!destw)
{
g_warning ("Cannot get pixmap");
return FALSE;
}
gvisual = gdk_screen_get_system_visual (pm->screen_info->gscr);
cmap = gdk_x11_colormap_foreign_new (gvisual, pm->screen_info->cmap);
if (!cmap)
{
g_warning ("Cannot create colormap");
g_object_unref (destw);
return FALSE;
}
width = MIN (gdk_pixbuf_get_width (pixbuf), pm->width);
height = MIN (gdk_pixbuf_get_height (pixbuf), pm->height);
/* Add 1 for rounding */
dest_x = (pm->width - width + 1) / 2;
dest_y = (pm->height - height + 1) / 2;
src = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (destw), cmap,
dest_x, dest_y, 0, 0, width, height);
gdk_pixbuf_composite (pixbuf, src, 0, 0, width, height,
0, 0, 1.0, 1.0, GDK_INTERP_NEAREST, 0xFF);
gdk_draw_pixbuf (GDK_DRAWABLE (destw), NULL, src, 0, 0, dest_x, dest_y,
width, height, GDK_RGB_DITHER_NONE, 0, 0);
g_object_unref (cmap);
g_object_unref (src);
g_object_unref (destw);
return TRUE;
}
static void
mailwatch_set_icon(XfceMailwatchPlugin *mwp, gboolean newmail)
{
GdkPixbuf *pb = newmail ?
gdk_pixbuf_copy(mwp->pix_newmail) :
gdk_pixbuf_copy(mwp->pix_normal);
GdkPixbuf *overlay = NULL;
gint h, ow, oh;
if ( mwp->log_status && mwp->show_log_status &&
mwp->log_status < XFCE_MAILWATCH_N_LOG_LEVELS ) {
overlay = mwp->pix_log[mwp->log_status];
}
h = gdk_pixbuf_get_height(pb);
if(overlay) {
ow = gdk_pixbuf_get_width(overlay);
oh = gdk_pixbuf_get_height(overlay);
gdk_pixbuf_composite(overlay, pb, 0, h - oh, ow, oh, 0, h - oh,
1.0, 1.0, GDK_INTERP_BILINEAR, 255);
}
xfce_scaled_image_set_from_pixbuf(XFCE_SCALED_IMAGE(mwp->image ), pb);
g_object_unref(G_OBJECT(pb));
}
static void
draw_eye (EyesApplet *eyes_applet,
gint eye_num,
gint pupil_x,
gint pupil_y)
{
GdkPixbuf *pixbuf;
GdkRectangle rect, r1, r2;
pixbuf = gdk_pixbuf_copy (eyes_applet->eye_image);
r1.x = pupil_x - eyes_applet->pupil_width / 2;
r1.y = pupil_y - eyes_applet->pupil_height / 2;
r1.width = eyes_applet->pupil_width;
r1.height = eyes_applet->pupil_height;
r2.x = 0;
r2.y = 0;
r2.width = eyes_applet->eye_width;
r2.height = eyes_applet->eye_height;
gdk_rectangle_intersect (&r1, &r2, &rect);
gdk_pixbuf_composite (eyes_applet->pupil_image, pixbuf,
rect.x,
rect.y,
rect.width,
rect.height,
pupil_x - eyes_applet->pupil_width / 2,
pupil_y - eyes_applet->pupil_height / 2, 1.0, 1.0,
GDK_INTERP_BILINEAR,
255);
gtk_image_set_from_pixbuf (GTK_IMAGE (eyes_applet->eyes[eye_num]),
pixbuf);
g_object_unref (pixbuf);
}
static void
x_pixbuf_tmp_draw_tile(int tile, int ofsx, int ofsy)
{
int i, j, n;
guint32 pixel;
int width, height;
int srcx, srcy;
int dstx = ofsx, dsty = ofsy;
width = Tile->unit_width;
height = Tile->unit_height;
srcx = (tile % tiles_per_row) * width;
srcy = (tile / tiles_per_row) * height;
if (dstx < 0) {
srcx -= dstx;
width += dstx;
dstx = 0;
}
if (dsty < 0) {
srcy -= dsty;
height += dsty;
dsty = 0;
}
if (dstx > 0)
width -= dstx;
if (dsty > 0)
height -= dsty;
if (!tmp_pixbuf) {
tmp_pixbuf = gdk_pixbuf_new(gdk_pixbuf_get_colorspace(tile_pixbuf),
gdk_pixbuf_get_has_alpha(tile_pixbuf),
gdk_pixbuf_get_bits_per_sample(tile_pixbuf),
Tile->unit_width, Tile->unit_height);
memset(gdk_pixbuf_get_pixels(tmp_pixbuf), 0,
Tile->unit_height * gdk_pixbuf_get_rowstride(tmp_pixbuf));
gdk_pixbuf_copy_area(tile_pixbuf, srcx, srcy, width, height,
tmp_pixbuf, dstx, dsty);
{
guchar *pixels;
int rowstride;
int n_channels;
guchar rgba[4];
g_return_if_fail(gdk_pixbuf_get_bits_per_sample(tmp_pixbuf) == 8 &&
gdk_pixbuf_get_colorspace(tmp_pixbuf) == GDK_COLORSPACE_RGB);
pixels = gdk_pixbuf_get_pixels(tmp_pixbuf);
rowstride = gdk_pixbuf_get_rowstride(tmp_pixbuf);
n_channels = gdk_pixbuf_get_n_channels(tmp_pixbuf);
for(j = 0; j < Tile->unit_height; j++)
for(i = 0; i < Tile->unit_width; i++) {
nh_pixbuf_get_pixel(i, j, rgba);
rgba[3] = 255;
nh_pixbuf_put_pixel(i, j, rgba);
}
}
}
else
gdk_pixbuf_composite(tile_pixbuf, tmp_pixbuf, dstx, dsty, width, height,
-srcx, -srcy, 1.0, 1.0, GDK_INTERP_NEAREST, 255.0);
}
static GdkPixbuf* accessx_status_applet_bouncekeys_image(AccessxStatusApplet* sapplet, XkbAccessXNotifyEvent* event)
{
GtkStyle* style;
GdkColor fg, bg;
GdkPixbuf* icon_base = NULL;
GdkPixbuf* tmp_pixbuf;
/* Note to translators: the first letter of the alphabet, not the indefinite article */
gchar* glyphstring = N_("a");
gchar* stock_id = ACCESSX_BASE_ICON;
g_assert(sapplet->applet);
style = gtk_widget_get_style(GTK_WIDGET(sapplet->applet));
#if GTK_CHECK_VERSION (3, 0, 0)
fg = style->text[gtk_widget_get_state_flags (GTK_WIDGET (sapplet->applet))];
#else
fg = style->text[gtk_widget_get_state(GTK_WIDGET(sapplet->applet))];
#endif
bg = style->base[GTK_STATE_NORMAL];
if (event != NULL)
{
switch (event->detail)
{
case XkbAXN_BKReject:
stock_id = SLOWKEYS_REJECT_ICON;
_bk_timeout = g_timeout_add_full(G_PRIORITY_HIGH_IDLE, MAX(event->debounce_delay, 150), timer_reset_bouncekeys_image, sapplet->bouncefoo, NULL);
break;
default:
stock_id = ACCESSX_BASE_ICON;
break;
}
}
tmp_pixbuf = gtk_widget_render_icon(GTK_WIDGET(sapplet->applet), stock_id, icon_size_spec, NULL);
if (tmp_pixbuf)
{
GdkPixbuf* glyph_pixbuf;
icon_base = gdk_pixbuf_copy(tmp_pixbuf);
g_object_unref(tmp_pixbuf);
glyph_pixbuf = accessx_status_applet_get_glyph_pixbuf(sapplet, GTK_WIDGET(sapplet->applet), icon_base, &fg, &bg, glyphstring);
gdk_pixbuf_composite(glyph_pixbuf, icon_base, 2, 2, gdk_pixbuf_get_width(glyph_pixbuf) - 2, gdk_pixbuf_get_height(glyph_pixbuf) - 2, -2., -2., 1.0, 1.0, GDK_INTERP_NEAREST, 96);
gdk_pixbuf_composite(glyph_pixbuf, icon_base, 1, 1, gdk_pixbuf_get_width(glyph_pixbuf) - 1, gdk_pixbuf_get_height(glyph_pixbuf) - 1, 1., 1., 1.0, 1.0, GDK_INTERP_NEAREST, 255);
g_object_unref(glyph_pixbuf);
}
return icon_base;
}
static GdkPixbuf *
xfwmPixmapCompose (GdkPixbuf *pixbuf, const gchar * dir, const gchar * file)
{
GdkPixbuf *alpha;
gchar *filepng;
gchar *filename;
gint width, height;
int i;
static const char* image_types[] = {
"svg",
"png",
"gif",
"jpg",
"bmp",
NULL
};
i = 0;
alpha = NULL;
while ((image_types[i]) && (!alpha))
{
filepng = g_strdup_printf ("%s.%s", file, image_types[i]);
filename = g_build_filename (dir, filepng, NULL);
g_free (filepng);
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
alpha = gdk_pixbuf_new_from_file (filename, NULL);
}
g_free (filename);
++i;
}
if (!alpha)
{
/* We have no suitable image to layer on top of the XPM, stop here... */
return (pixbuf);
}
if (!pixbuf)
{
/* We have no XPM canvas and found a suitable image, use it... */
return (alpha);
}
width = MIN (gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_width (alpha));
height = MIN (gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_height (alpha));
gdk_pixbuf_composite (alpha, pixbuf, 0, 0, width, height,
0, 0, 1.0, 1.0, GDK_INTERP_NEAREST, 0xFF);
g_object_unref (alpha);
return pixbuf;
}
static GdkPixbuf *
add_holes_to_pixbuf_small (GdkPixbuf *pixbuf, int width, int height)
{
GdkPixbuf *holes, *tmp, *target;
char *filename;
int i;
filename = g_build_filename (DATADIR, "xplayer", "filmholes.png", NULL);
holes = gdk_pixbuf_new_from_file (filename, NULL);
g_free (filename);
if (holes == NULL) {
g_object_ref (pixbuf);
return pixbuf;
}
g_assert (gdk_pixbuf_get_has_alpha (pixbuf) == FALSE);
g_assert (gdk_pixbuf_get_has_alpha (holes) != FALSE);
target = g_object_ref (pixbuf);
for (i = 0; i < height; i += gdk_pixbuf_get_height (holes))
{
gdk_pixbuf_composite (holes, target, 0, i,
MIN (width, gdk_pixbuf_get_width (holes)),
MIN (height - i, gdk_pixbuf_get_height (holes)),
0, i, 1, 1, GDK_INTERP_NEAREST, 255);
}
tmp = gdk_pixbuf_flip (holes, FALSE);
g_object_unref (holes);
holes = tmp;
for (i = 0; i < height; i += gdk_pixbuf_get_height (holes))
{
gdk_pixbuf_composite (holes, target,
width - gdk_pixbuf_get_width (holes), i,
MIN (width, gdk_pixbuf_get_width (holes)),
MIN (height - i, gdk_pixbuf_get_height (holes)),
width - gdk_pixbuf_get_width (holes), i,
1, 1, GDK_INTERP_NEAREST, 255);
}
g_object_unref (holes);
return target;
}
static GdkPixbuf* accessx_status_applet_mousekeys_image(AccessxStatusApplet* sapplet, XkbStateNotifyEvent* event)
{
GdkPixbuf* mouse_pixbuf = NULL, *button_pixbuf, *dot_pixbuf, *tmp_pixbuf;
gchar* which_dot = MOUSEKEYS_DOT_LEFT;
tmp_pixbuf = gtk_widget_render_icon(GTK_WIDGET(sapplet->applet), MOUSEKEYS_BASE_ICON, icon_size_spec, NULL);
mouse_pixbuf = gdk_pixbuf_copy(tmp_pixbuf);
g_object_unref(tmp_pixbuf);
/* composite in the buttons */
if (mouse_pixbuf && event && event->ptr_buttons)
{
gint i;
for (i = 0; i < G_N_ELEMENTS(button_icons); ++i)
{
if (event->ptr_buttons & button_icons[i].mask)
{
button_pixbuf = gtk_widget_render_icon(GTK_WIDGET(sapplet->applet), button_icons[i].stock_id, icon_size_spec, NULL);
gdk_pixbuf_composite(button_pixbuf, mouse_pixbuf, 0, 0, gdk_pixbuf_get_width(button_pixbuf), gdk_pixbuf_get_height(button_pixbuf), 0.0, 0.0, 1.0, 1.0, GDK_INTERP_NEAREST, 255);
}
}
}
if (event)
{
switch (sapplet->xkb->ctrls->mk_dflt_btn)
{
case Button2:
which_dot = MOUSEKEYS_DOT_MIDDLE;
break;
case Button3:
which_dot = MOUSEKEYS_DOT_RIGHT;
break;
case Button1:
default:
which_dot = MOUSEKEYS_DOT_LEFT;
break;
}
}
dot_pixbuf = gtk_widget_render_icon(GTK_WIDGET(sapplet->applet), which_dot, icon_size_spec, NULL);
gdk_pixbuf_composite(dot_pixbuf, mouse_pixbuf, 0, 0, gdk_pixbuf_get_width(dot_pixbuf), gdk_pixbuf_get_height(dot_pixbuf), 0.0, 0.0, 1.0, 1.0, GDK_INTERP_NEAREST, 255);
return mouse_pixbuf;
}
/**
* as_screenshot_show_image:
**/
static void
as_screenshot_show_image (GsScreenshotImage *ssimg)
{
GsScreenshotImagePrivate *priv;
_cleanup_object_unref_ GdkPixbuf *pixbuf_bg = NULL;
_cleanup_object_unref_ GdkPixbuf *pixbuf = NULL;
priv = gs_screenshot_image_get_instance_private (ssimg);
/* no need to composite */
if (priv->width == G_MAXUINT || priv->height == G_MAXUINT) {
pixbuf_bg = gdk_pixbuf_new_from_file (priv->filename, NULL);
} else {
/* this is always going to have alpha */
pixbuf = gdk_pixbuf_new_from_file_at_scale (priv->filename,
priv->width * priv->scale,
priv->height * priv->scale,
FALSE, NULL);
if (pixbuf != NULL) {
if (gs_screenshot_image_use_desktop_background (ssimg, pixbuf)) {
pixbuf_bg = gs_screenshot_image_get_desktop_pixbuf (ssimg);
if (pixbuf_bg == NULL) {
pixbuf_bg = g_object_ref (pixbuf);
} else {
gdk_pixbuf_composite (pixbuf, pixbuf_bg,
0, 0,
priv->width, priv->height,
0, 0, 1.0f, 1.0f,
GDK_INTERP_NEAREST, 255);
}
} else {
pixbuf_bg = g_object_ref (pixbuf);
}
}
}
/* show icon */
if (g_strcmp0 (priv->current_image, "image1") == 0) {
if (pixbuf_bg != NULL) {
gs_image_set_from_pixbuf_with_scale (GTK_IMAGE (priv->image2),
pixbuf_bg, priv->scale);
}
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "image2");
priv->current_image = "image2";
} else {
if (pixbuf_bg != NULL) {
gs_image_set_from_pixbuf_with_scale (GTK_IMAGE (priv->image1),
pixbuf_bg, priv->scale);
}
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "image1");
priv->current_image = "image1";
}
gtk_widget_show (GTK_WIDGET (ssimg));
}
static GdkPixbuf * _mime_icon_emblem(GdkPixbuf * pixbuf, int size,
char const * emblem)
{
int esize;
GdkPixbuf * epixbuf;
GtkIconTheme * icontheme;
#if GTK_CHECK_VERSION(2, 14, 0)
const unsigned int flags = GTK_ICON_LOOKUP_USE_BUILTIN
| GTK_ICON_LOOKUP_FORCE_SIZE;
#else
const unsigned int flags = GTK_ICON_LOOKUP_USE_BUILTIN;
#endif
/* work on a copy */
epixbuf = gdk_pixbuf_copy(pixbuf);
g_object_unref(pixbuf);
pixbuf = epixbuf;
/* determine the size of the emblem */
if(size >= 96)
esize = 32;
else if(size >= 48)
esize = 24;
else
esize = 12;
/* obtain the emblem's icon */
icontheme = gtk_icon_theme_get_default();
if((epixbuf = gtk_icon_theme_load_icon(icontheme, emblem, esize, flags,
NULL)) == NULL)
return pixbuf;
/* blit the emblem */
#if 0 /* XXX does not show anything (bottom right) */
gdk_pixbuf_composite(epixbuf, pixbuf, size - esize, size - esize,
esize, esize, 0, 0, 1.0, 1.0, GDK_INTERP_NEAREST,
255);
#else /* blitting at the top left instead */
gdk_pixbuf_composite(epixbuf, pixbuf, 0, 0, esize, esize, 0, 0,
1.0, 1.0, GDK_INTERP_NEAREST, 255);
#endif
g_object_unref(epixbuf);
return pixbuf;
}
static void
create_button_images (AppearanceData *data)
{
GtkWidget *widget = (GtkWidget*)data->wp_view;
GtkStyle *style = gtk_widget_get_style (widget);
GtkIconSet *icon_set;
GdkPixbuf *pixbuf, *pb, *pb2;
gint i, w, h;
icon_set = gtk_style_lookup_icon_set (style, "gtk-media-play");
pb = gtk_icon_set_render_icon (icon_set,
style,
GTK_TEXT_DIR_RTL,
GTK_STATE_NORMAL,
GTK_ICON_SIZE_MENU,
widget,
NULL);
pb2 = gtk_icon_set_render_icon (icon_set,
style,
GTK_TEXT_DIR_LTR,
GTK_STATE_NORMAL,
GTK_ICON_SIZE_MENU,
widget,
NULL);
w = gdk_pixbuf_get_width (pb);
h = gdk_pixbuf_get_height (pb);
for (i = 0; i < 3; i++) {
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 2 * w, h);
gdk_pixbuf_fill (pixbuf, 0);
if (i > 0)
gdk_pixbuf_composite (pb, pixbuf, 0, 0, w, h, 0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
if (i < 2)
gdk_pixbuf_composite (pb2, pixbuf, w, 0, w, h, w, 0, 1, 1, GDK_INTERP_NEAREST, 255);
buttons[i] = pixbuf;
}
g_object_unref (pb);
g_object_unref (pb2);
}
gint
render_camera(gpointer data)
{
GdkPixbuf *pixbuf = NULL;
GdkPixbuf *blobbuf= NULL;
GdkGC *gc = NULL;
GtkWidget *drawing_area = GTK_WIDGET(data);
uint16_t i;
gc = GTK_WIDGET(drawing_area)->style->fg_gc[GTK_WIDGET_STATE(GTK_WIDGET(drawing_area))];
player_update();
if (g_blob_count > 0)
{
// Draw the blobs
blobbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, 1, 1);
for (i=0; i< g_blob_count; ++i)
{
// shift the color by 8-bits to account for the alpha channel
gdk_pixbuf_fill(blobbuf, g_blobs[i].color << 8);
gdk_pixbuf_composite(blobbuf,
g_pixbuf,
g_blobs[i].left,
g_blobs[i].top,
abs(g_blobs[i].right - g_blobs[i].left),
abs(g_blobs[i].top - g_blobs[i].bottom),
1, 1, 1, 1, GDK_INTERP_NEAREST, 128);
}
gdk_pixbuf_unref(blobbuf);
}
// scale everything at the end
if ((g_width==g_window_width)&&(g_height==g_window_height))
{ // we don't need to worry about scaling
gdk_draw_pixbuf(GTK_WIDGET(drawing_area)->window, gc,
g_pixbuf, 0, 0, 0, 0, g_width, g_height,
GDK_RGB_DITHER_NONE, 0, 0);
}
else
{
pixbuf = gdk_pixbuf_scale_simple(g_pixbuf, g_window_width,
g_window_height, GDK_INTERP_BILINEAR);
gdk_draw_pixbuf(GTK_WIDGET(drawing_area)->window, gc,
pixbuf, 0, 0, 0, 0, g_window_width, g_window_height,
GDK_RGB_DITHER_NONE, 0, 0);
gdk_pixbuf_unref(pixbuf);
}
return TRUE;
}
/**
* Update view buffer with new animation frame data.
*
* The functino does not update any display related variable (like offset or
* viewport) since all animation frames have same dimensions and we want
* animation to play with given zoom.
*
* It is called automatically from timeout installed by g_timeout_add()
*
* \todo track if somebody changed image by utilizing sequence number
*
* \param data pointer to ViewImageDisplay structure cast to gpointer
* \return FALSE
*/
gboolean view_idv_update_frame(gpointer data) {
FrameUpdate *update = (FrameUpdate*) data;
ViewImageDisplay* idv_data = NULL;
gint delay = -1;
GdkPixbuf* image = NULL;
if ( update->sequence != update->view->last_sequence ) {
g_free( (gpointer)data );
return FALSE;
}
idv_data = view_idv_get_data_pointer(update->view);
if ( NULL == idv_data ) {
g_free( (gpointer)data );
return FALSE;
}
// composite image to the internal view buffer
image = model_iml_get_image(update->view->model);
if ( NULL == image ) {
ERROR_LOG();
g_free( (gpointer)data );
return FALSE;
}
gdk_pixbuf_fill( idv_data->view_buffer, 0x000000ff);
gdk_pixbuf_composite(image, idv_data->view_buffer,
// destination position
idv_data->viewport.x, idv_data->viewport.y,
// destination dimension
idv_data->viewport.width, idv_data->viewport.height,
// offsets
idv_data->viewport.x - idv_data->offset.x,
idv_data->viewport.y - idv_data->offset.y,
// zoom in both axes
idv_data->zoom_factor, idv_data->zoom_factor,
GDK_INTERP_BILINEAR, 255
);
// invalidate the image view region
gdk_window_invalidate_rect(update->view->window, &(update->view->region), FALSE);
// check and install new frame update timeout
delay = model_iml_get_delay(update->view->model);
if ( -1 != delay ) {
g_timeout_add(delay, view_idv_update_frame, (gpointer)update);
} else {
g_free( (gpointer)data );
}
return FALSE;
}
static void
simple_gdk_pixbuf_composite(GdkPixbuf *source, GdkPixbuf *dest)
{
gint height, width, src_height, src_width;
src_height = gdk_pixbuf_get_height(source);
src_width = gdk_pixbuf_get_width(source);
height = gdk_pixbuf_get_height(dest);
width = gdk_pixbuf_get_width(dest);
gdk_pixbuf_composite(source, dest, 0, 0, width, height, 0.0, 0.0,
(gdouble)width/src_width, (gdouble)height/src_height,
GDK_INTERP_TILES, 0xff);
}
static void active_sensor_update_icon(ActiveSensor *active_sensor,
GdkPixbuf *base_icon,
SensorType sensor_type) {
GdkPixbuf *overlay_icon, *new_icon;
const gchar *overlay_icon_filename = NULL;
SensorValueRange value_range;
g_assert(active_sensor);
/* select overlay icon
* depending on sensor
* value */
value_range = sensor_value_range(active_sensor->sensor_values[0],
active_sensor->sensor_low_value,
active_sensor->sensor_high_value);
if (sensor_type == TEMP_SENSOR) {
overlay_icon_filename = temp_overlay_icons[value_range];
}
/* load base icon */
new_icon = gdk_pixbuf_copy(base_icon);
/* only load overlay if required */
if (overlay_icon_filename) {
overlay_icon = gdk_pixbuf_new_from_file_at_size(overlay_icon_filename,
DEFAULT_ICON_SIZE,
DEFAULT_ICON_SIZE,
NULL);
if (overlay_icon) {
gdk_pixbuf_composite(overlay_icon, new_icon,
0, 0,
DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE,
0, 0,
1.0, 1.0,
GDK_INTERP_BILINEAR,
255);
g_object_unref(overlay_icon);
}
}
gtk_image_set_from_pixbuf(GTK_IMAGE(active_sensor->icon),
new_icon);
g_object_unref(new_icon);
}
static void
file_view_render_pixbuf_with_emblem (GtkTreeViewColumn* tree_column,
GtkCellRenderer* cell,
GtkTreeModel* tree_model,
GtkTreeIter* iter,
gpointer data)
{
GdkPixbuf* file_icon = NULL;
GdkPixbuf* emblem = NULL;
AnjutaVcsStatus status;
gtk_tree_model_get (tree_model, iter,
COLUMN_STATUS, &status,
COLUMN_PIXBUF, &file_icon, -1);
if (file_icon)
{
emblem = get_vcs_emblem (status);
if (emblem)
{
GdkPixbuf *new_icon;
new_icon = gdk_pixbuf_copy (file_icon);
gdk_pixbuf_composite (emblem,
new_icon,
0, 0,
gdk_pixbuf_get_width (file_icon),
gdk_pixbuf_get_height (file_icon),
0, 0,
1, 1,
GDK_INTERP_BILINEAR,
COMPOSITE_ALPHA);
g_object_set (cell, "pixbuf", new_icon, NULL);
g_object_unref (new_icon);
g_object_unref (emblem);
}
else
{
g_object_set (cell, "pixbuf", file_icon, NULL);
}
g_object_unref (file_icon);
}
}
static GdkPixbuf *
transform_pixbuf (GdkPixbuf *orig,
gboolean has_tint, guint32 tint_color,
double alpha, gint width, gint height)
{
GdkPixbuf *scaled;
gint p_width, p_height;
p_width = gdk_pixbuf_get_width (orig);
p_height = gdk_pixbuf_get_height (orig);
if (p_width != width ||
p_height != height ||
alpha < 1.0 ||
has_tint)
{
int alpha_i;
if (alpha >= 1.0)
alpha_i = 0xff;
else if (alpha <= 0.0)
alpha_i = 0;
else
alpha_i = (guint) floor (0xff*alpha);
if (alpha != 0xff)
{
scaled = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
gdk_pixbuf_fill (scaled, 0);
gdk_pixbuf_composite (orig, scaled, 0, 0, width, height,
0, 0, (double)width/p_width, (double)height/p_height,
GDK_INTERP_BILINEAR, alpha_i);
}
else
scaled = gdk_pixbuf_scale_simple (orig, width, height, GDK_INTERP_BILINEAR);
}
else
scaled = g_object_ref (orig);
if (has_tint)
apply_tint (scaled, tint_color);
return scaled;
}
void
nm_network_menu_item_best_strength (NMNetworkMenuItem * item,
guint8 strength,
NMApplet *applet)
{
GdkPixbuf *icon = NULL, *pixbuf, *top;
g_return_if_fail (item != NULL);
g_return_if_fail (NM_IS_NETWORK_MENU_ITEM (item));
strength = CLAMP (strength, 0, 100);
/* Just do nothing if the new strength is less */
if (strength < item->int_strength)
return;
item->int_strength = strength;
if (strength > 80)
icon = nma_icon_check_and_load ("nm-signal-100", &applet->wireless_100_icon, applet);
else if (strength > 55)
icon = nma_icon_check_and_load ("nm-signal-75", &applet->wireless_75_icon, applet);
else if (strength > 30)
icon = nma_icon_check_and_load ("nm-signal-50", &applet->wireless_50_icon, applet);
else if (strength > 5)
icon = nma_icon_check_and_load ("nm-signal-25", &applet->wireless_25_icon, applet);
else
icon = nma_icon_check_and_load ("nm-signal-00", &applet->wireless_00_icon, applet);
pixbuf = gdk_pixbuf_copy (icon);
/* If the AP is "secure", composite the lock icon on top of the signal bars */
if (item->is_encrypted) {
top = nma_icon_check_and_load ("nm-secure-lock", &applet->secure_lock_icon, applet);
gdk_pixbuf_composite (top, pixbuf, 0, 0, gdk_pixbuf_get_width (top),
gdk_pixbuf_get_height (top),
0, 0, 1.0, 1.0,
GDK_INTERP_NEAREST, 255);
}
gtk_image_set_from_pixbuf (GTK_IMAGE (item->strength), pixbuf);
g_object_unref (pixbuf);
}
gboolean
set_gtk_widget_bg_image (GtkWidget *widget, const gchar *filename, guint bgcolor)
{
GdkPixbuf *pbuf, *bg;
GdkPixmap *pixmap;
gint width, height;
if (GTK_WIDGET_NO_WINDOW(widget) || !GTK_WIDGET_REALIZED(widget) || !filename)
goto fail;
pbuf = gdk_pixbuf_new_from_file(filename, NULL);
if (!pbuf)
goto fail;
width = gdk_pixbuf_get_width(pbuf);
height = gdk_pixbuf_get_height(pbuf);
bg = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE,
gdk_pixbuf_get_bits_per_sample(pbuf),
width, height);
gdk_pixbuf_fill(bg, bgcolor);
gdk_pixbuf_composite(pbuf, bg, 0, 0, width, height,
0, 0, 1, 1, GDK_INTERP_BILINEAR,0xFF);
pixmap = gdk_pixmap_new(widget->window, width, height, -1);
gdk_draw_pixbuf(pixmap, NULL, bg, 0, 0, 0, 0,
-1, -1, GDK_RGB_DITHER_NORMAL, 0, 0);
g_object_unref(pbuf);
g_object_unref(bg);
gtk_widget_set_app_paintable(widget,TRUE);
gdk_window_set_back_pixmap(widget->window, pixmap, FALSE);
g_object_unref(pixmap);
//gtk_widget_queue_draw(widget);
return TRUE;
fail:
return FALSE;
}
static GdkPixbuf *add_emblem_to_icon( GdkPixbuf *icon, GdkPixbuf *emblem )
{
if ( icon == NULL ) {
g_warning ( "add_emblem_to_icon: icon is NULL." );
return NULL;
} else if ( emblem == NULL ) {
g_warning ( "add_emblem_to_icon: emblem is NULL." );
return NULL;
}
GdkPixbuf *result = gdk_pixbuf_copy( icon );
if ( result == NULL ) {
g_warning( "add_emblem_to_icon: failed to copy icon.");
return NULL;
}
gdk_pixbuf_composite(emblem, result, 0, 0,
MIN(gdk_pixbuf_get_width(emblem), gdk_pixbuf_get_width(result)),
MIN(gdk_pixbuf_get_height(emblem), gdk_pixbuf_get_height(result)),
0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
return result;
}
/* shouldn't use this -- slow -- change the alpha channel instead. */
void vik_viewport_draw_pixbuf_with_alpha ( VikViewport *vvp, GdkPixbuf *pixbuf, gint alpha,
gint src_x, gint src_y, gint dest_x, gint dest_y, gint w, gint h )
{
gint real_dest_x = MAX(dest_x,0);
gint real_dest_y = MAX(dest_y,0);
if ( alpha == 0 )
return; /* don't waste your time */
if ( w > vvp->alpha_pixbuf_width || h > vvp->alpha_pixbuf_height )
{
if ( vvp->alpha_pixbuf )
g_object_unref ( G_OBJECT ( vvp->alpha_pixbuf ) );
vvp->alpha_pixbuf_width = MAX(w,vvp->alpha_pixbuf_width);
vvp->alpha_pixbuf_height = MAX(h,vvp->alpha_pixbuf_height);
vvp->alpha_pixbuf = gdk_pixbuf_new ( GDK_COLORSPACE_RGB, FALSE, 8, vvp->alpha_pixbuf_width, vvp->alpha_pixbuf_height );
}
w = MIN(w,vvp->width - dest_x);
h = MIN(h,vvp->height - dest_y);
/* check that we are drawing within boundaries. */
src_x += (real_dest_x - dest_x);
src_y += (real_dest_y - dest_y);
w -= (real_dest_x - dest_x);
h -= (real_dest_y - dest_y);
gdk_pixbuf_get_from_drawable ( vvp->alpha_pixbuf, vvp->scr_buffer, NULL,
real_dest_x, real_dest_y, 0, 0, w, h );
/* do a composite */
gdk_pixbuf_composite ( pixbuf, vvp->alpha_pixbuf, 0, 0, w, h, -src_x, -src_y, 1, 1, 0, alpha );
/* draw pixbuf_tmp */
vik_viewport_draw_pixbuf ( vvp, vvp->alpha_pixbuf, 0, 0, real_dest_x, real_dest_y, w, h );
}
static GdkPixbufAnimation*
compose_animation_from_array (animation_param_entry **anim_array, gint array_len, gint pix_size)
{
GdkPixbufSimpleAnim *result = NULL;
gint frames = 1, duration = 0, duration_p, frames_p;
/* calculate frames count as multiplication of all frames and duration as max */
gint i;
GTimeVal start_time = {0, 0};
for (i = 0; i<array_len; i++){
/* initialize iterators for each animation*/
animation_param_entry *p_entry = anim_array[i];
p_entry->iter = gdk_pixbuf_animation_get_iter (p_entry->anim, &start_time);
frames_p = duration_p = 0;
pgpug_pixbuf_animation_get_detail (p_entry->anim, &frames_p, &duration_p);
duration = duration < duration_p ? duration_p : duration;
frames *= frames_p;
}
float fps = duration > 0 ? frames * 1000 / duration : 1;
gint frame_change_time = duration / frames;
DEBG_MSG ("Fps: %f. frame change time :%dmsec", fps,frame_change_time);
result = gdk_pixbuf_simple_anim_new (pix_size, pix_size, fps);
gint elapsed_time = 0, frames_counter = 1;
while (elapsed_time <= duration && frames_counter++ <= frames){
animation_param_entry *p_entry = anim_array[0];
GdkPixbuf *base_pixbuf = gdk_pixbuf_copy (gdk_pixbuf_animation_iter_get_pixbuf (p_entry->iter));
g_time_val_add (&start_time, frame_change_time * 1000);
gdk_pixbuf_animation_iter_advance (p_entry->iter, &start_time);
for (i = 1; i < array_len; i++) {
p_entry = anim_array[i];
GdkPixbuf *src_pixbuf = gdk_pixbuf_animation_iter_get_pixbuf (p_entry->iter);
gint x_offset, y_offset, src_size;
src_size = gdk_pixbuf_get_width (src_pixbuf);
pgpug_pixbuf_calculate_composition_offset (pix_size, src_size, p_entry->pos, &x_offset, &y_offset);
gdk_pixbuf_composite (src_pixbuf,
base_pixbuf,
x_offset, y_offset,
src_size, src_size,
x_offset, y_offset,
1.0f, 1.0f,
GDK_INTERP_BILINEAR, 255);
gboolean res;
res = gdk_pixbuf_animation_iter_advance (p_entry->iter, &start_time);
}
gdk_pixbuf_simple_anim_add_frame (result, base_pixbuf);
elapsed_time += frame_change_time;
}
gdk_pixbuf_simple_anim_set_loop (result, TRUE);
for (i=0;i<array_len;i++){
g_object_unref (anim_array[i]->iter);
}
return GDK_PIXBUF_ANIMATION (result);
}
static GdkPixbuf*
compose_splash(const gchar *version)
{
gint xpos = 224;
gint ypos = 36;
GdkPixbufLoader *loader;
GdkPixbuf *base, *digit;
GError *err = NULL;
guint i;
gchar *p, *filename;
p = gwy_find_self_dir("pixmaps");
filename = g_build_filename(p, "splash.png", NULL);
g_free(p);
base = gdk_pixbuf_new_from_file(filename, &err);
if (!base) {
g_warning("Cannot load base splash image: %s", err->message);
g_clear_error(&err);
sanity_check(filename);
g_free(filename);
return NULL;
}
g_free(filename);
while (*version) {
loader = NULL;
for (i = 0; i < G_N_ELEMENTS(digits); i++) {
if (*version == digits[i].c)
break;
}
if (i == G_N_ELEMENTS(digits)) {
g_warning("Cannot find image for %c", *version);
version++;
continue;
}
loader = gdk_pixbuf_loader_new_with_type("png", &err);
/* We have already successfully loaded base PNG */
g_assert(loader);
if (!gdk_pixbuf_loader_write(loader, digits[i].data, digits[i].len,
&err)) {
g_critical("Cannot load in-line image for %c as PNG", *version);
break;
}
if (!gdk_pixbuf_loader_close(loader, &err)) {
g_critical("Cannot load in-line image for %c as PNG", *version);
break;
}
digit = gdk_pixbuf_loader_get_pixbuf(loader);
g_assert(digit);
gdk_pixbuf_composite(digit, base,
xpos, ypos,
gdk_pixbuf_get_width(digit),
gdk_pixbuf_get_height(digit),
xpos, ypos,
1.0, 1.0,
GDK_INTERP_NEAREST,
255);
xpos += gdk_pixbuf_get_width(digit);
g_object_unref(loader);
version++;
}
return base;
}
static GdkPixbuf *
composite_marks (GtkSourceView *view,
GSList *marks,
gint size)
{
GdkPixbuf *composite;
gint mark_width;
gint mark_height;
/* Draw the mark with higher priority */
marks = g_slist_sort_with_data (marks, sort_marks_by_priority, view);
composite = NULL;
mark_width = 0;
mark_height = 0;
/* composite all the pixbufs for the marks present at the line */
do
{
GtkSourceMark *mark;
GtkSourceMarkAttributes *attrs;
const GdkPixbuf *pixbuf;
mark = marks->data;
attrs = gtk_source_view_get_mark_attributes (view,
gtk_source_mark_get_category (mark),
NULL);
if (attrs == NULL)
{
continue;
}
pixbuf = gtk_source_mark_attributes_render_icon (attrs,
GTK_WIDGET (view),
size);
if (pixbuf != NULL)
{
if (composite == NULL)
{
composite = gdk_pixbuf_copy (pixbuf);
mark_width = gdk_pixbuf_get_width (composite);
mark_height = gdk_pixbuf_get_height (composite);
}
else
{
gint pixbuf_w;
gint pixbuf_h;
pixbuf_w = gdk_pixbuf_get_width (pixbuf);
pixbuf_h = gdk_pixbuf_get_height (pixbuf);
gdk_pixbuf_composite (pixbuf,
composite,
0, 0,
mark_width, mark_height,
0, 0,
(gdouble) pixbuf_w / mark_width,
(gdouble) pixbuf_h / mark_height,
GDK_INTERP_BILINEAR,
COMPOSITE_ALPHA);
}
}
marks = g_slist_next (marks);
}
while (marks);
return composite;
}
static GtkIconSet* accessx_status_applet_altgraph_icon_set(AccessxStatusApplet* sapplet, GtkWidget* widget)
{
GtkIconSet* icon_set = gtk_icon_set_new();
gint i;
GtkStateType states[3] = {GTK_STATE_NORMAL, GTK_STATE_INSENSITIVE, GTK_STATE_SELECTED};
GtkStyle* style = gtk_widget_get_style(widget);
GdkPixbuf* icon_base;
gtk_widget_set_sensitive(widget, TRUE);
for (i = 0; i < 3; ++i)
{
int alpha;
GdkColor* fg;
GdkColor* bg;
GtkIconSource* source = gtk_icon_source_new();
GdkPixbuf* pixbuf;
GdkPixbuf* glyph_pixbuf;
gboolean wildcarded = FALSE;
fg = &style->text[states[i]];
bg = &style->white;
switch (states[i])
{
case GTK_STATE_NORMAL:
alpha = 255;
gtk_widget_set_sensitive(widget, TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_NORMAL, TRUE);
#else
gtk_widget_set_state(widget, GTK_STATE_NORMAL);
#endif
break;
case GTK_STATE_SELECTED:
/* FIXME: should use text/base here, for selected ? */
fg = &style->white;
bg = &style->black;
alpha = 255;
gtk_widget_set_sensitive(widget, TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_SELECTED, TRUE);
#else
gtk_widget_set_state(widget, GTK_STATE_SELECTED);
#endif
break;
case GTK_STATE_INSENSITIVE:
default:
alpha = 63;
gtk_widget_set_sensitive(widget, FALSE);
wildcarded = TRUE;
break;
}
icon_base = gtk_widget_render_icon(widget, ACCESSX_BASE_ICON, icon_size_spec, NULL);
pixbuf = gdk_pixbuf_copy(icon_base);
g_object_unref(icon_base);
/*
* should be N_("ae"));
* need en_ locale for this.
*/
/*
* Translators: substitute an easily-recognized single glyph
* from Level 2, i.e. an AltGraph character from a common keyboard
* in your locale.
*/
glyph_pixbuf = accessx_status_applet_get_glyph_pixbuf(sapplet, widget, pixbuf, fg, bg, ("æ"));
gdk_pixbuf_composite(glyph_pixbuf, pixbuf, 0, 0, gdk_pixbuf_get_width(glyph_pixbuf), gdk_pixbuf_get_height(glyph_pixbuf), 0., 0., 1.0, 1.0, GDK_INTERP_NEAREST, alpha);
g_object_unref(glyph_pixbuf);
gtk_icon_source_set_pixbuf(source, pixbuf);
gtk_icon_source_set_state(source, states[i]);
gtk_icon_source_set_state_wildcarded(source, wildcarded);
gtk_icon_set_add_source(icon_set, source);
gtk_icon_source_free(source);
}
/* we mucked about with the box's state to create the icons; restore it to normal */
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_NORMAL, TRUE);
#else
gtk_widget_set_state(widget, GTK_STATE_NORMAL);
#endif
gtk_widget_set_sensitive(widget, TRUE);
return icon_set;
}
/* Timeout handler to regenerate the frame */
static gint
timeout (gpointer data)
{
double f;
int i;
double xmid, ymid;
double radius;
gdk_pixbuf_copy_area (background, 0, 0, back_width, back_height,
frame, 0, 0);
f = (double) (frame_num % CYCLE_LEN) / CYCLE_LEN;
xmid = back_width / 2.0;
ymid = back_height / 2.0;
radius = MIN (xmid, ymid) / 2.0;
for (i = 0; i < N_IMAGES; i++)
{
double ang;
int xpos, ypos;
int iw, ih;
double r;
GdkRectangle r1, r2, dest;
double k;
ang = 2.0 * G_PI * (double) i / N_IMAGES - f * 2.0 * G_PI;
iw = gdk_pixbuf_get_width (images[i]);
ih = gdk_pixbuf_get_height (images[i]);
r = radius + (radius / 3.0) * sin (f * 2.0 * G_PI);
xpos = floor (xmid + r * cos (ang) - iw / 2.0 + 0.5);
ypos = floor (ymid + r * sin (ang) - ih / 2.0 + 0.5);
k = (i & 1) ? sin (f * 2.0 * G_PI) : cos (f * 2.0 * G_PI);
k = 2.0 * k * k;
k = MAX (0.25, k);
r1.x = xpos;
r1.y = ypos;
r1.width = iw * k;
r1.height = ih * k;
r2.x = 0;
r2.y = 0;
r2.width = back_width;
r2.height = back_height;
if (gdk_rectangle_intersect (&r1, &r2, &dest))
gdk_pixbuf_composite (images[i],
frame,
dest.x, dest.y,
dest.width, dest.height,
xpos, ypos,
k, k,
GDK_INTERP_NEAREST,
((i & 1)
? MAX (127, fabs (255 * sin (f * 2.0 * G_PI)))
: MAX (127, fabs (255 * cos (f * 2.0 * G_PI)))));
}
GDK_THREADS_ENTER ();
gtk_widget_queue_draw (da);
GDK_THREADS_LEAVE ();
frame_num++;
return TRUE;
}
static GdkPixbuf* accessx_status_applet_slowkeys_image(AccessxStatusApplet* sapplet, XkbAccessXNotifyEvent* event)
{
GdkPixbuf* ret_pixbuf;
GdkWindow* window;
gboolean is_idle = TRUE;
gchar* stock_id = SLOWKEYS_IDLE_ICON;
GtkStyle* style = gtk_widget_get_style(GTK_WIDGET(sapplet->applet));
GdkColor bg = style->bg[GTK_STATE_NORMAL];
if (event != NULL)
{
is_idle = FALSE;
switch (event->detail)
{
case XkbAXN_SKPress:
stock_id = ACCESSX_BASE_ICON;
if (_sk_timeout)
{
g_source_remove(_sk_timeout);
_sk_timeout = 0;
}
break;
case XkbAXN_SKAccept:
stock_id = ACCESSX_ACCEPT_BASE;
gdk_color_parse("#009900", &bg);
break;
case XkbAXN_SKReject:
stock_id = ACCESSX_REJECT_BASE;
gdk_color_parse("#990000", &bg);
_sk_timeout = g_timeout_add_full(G_PRIORITY_HIGH_IDLE, MAX(event->sk_delay, 150), timer_reset_slowkeys_image, sapplet->slowfoo, NULL);
break;
case XkbAXN_SKRelease:
default:
stock_id = SLOWKEYS_IDLE_ICON;
is_idle = TRUE;
break;
}
}
ret_pixbuf = gtk_widget_render_icon(GTK_WIDGET(sapplet->applet), stock_id, icon_size_spec, NULL);
if (!is_idle)
{
GdkPixbuf* glyph_pixbuf;
GdkPixbuf* tmp_pixbuf;
GdkColor fg;
gchar* glyphstring = N_("a");
tmp_pixbuf = ret_pixbuf;
ret_pixbuf = gdk_pixbuf_copy(tmp_pixbuf);
g_object_unref(tmp_pixbuf);
window = gtk_widget_get_window(GTK_WIDGET(sapplet->applet));
if (event && window)
{
KeySym keysym = XKeycodeToKeysym(GDK_WINDOW_XDISPLAY(window), event->keycode, 0);
glyphstring = XKeysymToString(keysym);
if ((!g_utf8_validate(glyphstring, -1, NULL)) || (g_utf8_strlen(glyphstring, -1) > 1))
{
glyphstring = "";
}
}
#if GTK_CHECK_VERSION (3, 0, 0)
fg = style->fg[gtk_widget_get_state_flags (GTK_WIDGET (sapplet->applet))];
#else
fg = style->fg[gtk_widget_get_state(GTK_WIDGET(sapplet->applet))];
#endif
glyph_pixbuf = accessx_status_applet_get_glyph_pixbuf(sapplet, GTK_WIDGET(sapplet->applet), ret_pixbuf, &fg, &bg, glyphstring);
gdk_pixbuf_composite(glyph_pixbuf, ret_pixbuf, 0, 0, gdk_pixbuf_get_width(glyph_pixbuf), gdk_pixbuf_get_height(glyph_pixbuf), 0., 0., 1.0, 1.0, GDK_INTERP_NEAREST, 255);
g_object_unref(glyph_pixbuf);
}
return ret_pixbuf;
}
static void
update_icon (DrWright *dr)
{
GdkPixbuf *pixbuf;
GdkPixbuf *tmp_pixbuf;
gint width, height;
gfloat r;
gint offset;
gboolean set_pixbuf;
if (!dr->enabled) {
gtk_status_icon_set_from_pixbuf (dr->icon,
dr->disabled_bar);
return;
}
tmp_pixbuf = gdk_pixbuf_copy (dr->neutral_bar);
width = gdk_pixbuf_get_width (tmp_pixbuf);
height = gdk_pixbuf_get_height (tmp_pixbuf);
set_pixbuf = TRUE;
switch (dr->state) {
case STATE_BREAK:
case STATE_BREAK_SETUP:
r = 1;
break;
case STATE_BREAK_DONE:
case STATE_BREAK_DONE_SETUP:
case STATE_START:
r = 0;
break;
default:
r = (float) (drw_timer_elapsed (dr->timer) + dr->save_last_time) /
(float) dr->type_time;
break;
}
offset = CLAMP ((height - 0) * (1.0 - r), 1, height - 0);
switch (dr->state) {
case STATE_WARN:
pixbuf = dr->red_bar;
set_pixbuf = FALSE;
break;
case STATE_BREAK_SETUP:
case STATE_BREAK:
pixbuf = dr->red_bar;
break;
default:
pixbuf = dr->green_bar;
}
gdk_pixbuf_composite (pixbuf,
tmp_pixbuf,
0,
offset,
width,
height - offset,
0,
0,
1.0,
1.0,
GDK_INTERP_BILINEAR,
255);
if (set_pixbuf) {
gtk_status_icon_set_from_pixbuf (dr->icon,
tmp_pixbuf);
}
if (dr->composite_bar) {
g_object_unref (dr->composite_bar);
}
dr->composite_bar = tmp_pixbuf;
}