static VALUE
rg_colors(VALUE self)
{
GdkColormap *cmap;
GdkColor *colors;
GdkVisual *visual;
VALUE ary;
int i;
cmap = _SELF(self);
colors = cmap->colors;
visual = gdk_colormap_get_visual(cmap);
if (visual->type == GDK_VISUAL_GRAYSCALE ||
visual->type == GDK_VISUAL_PSEUDO_COLOR) {
ary = rb_ary_new2(cmap->size);
for (i = 0; i < cmap->size; i++) {
rb_ary_push(ary, BOXED2RVAL(colors, GDK_TYPE_COLOR));
colors++;
}
return ary;
} else {
return Qnil;
}
}
/**
* gdk_pixbuf_render_pixmap_and_mask_for_colormap:
* @pixbuf: A pixbuf.
* @colormap: A #GdkColormap
* @pixmap_return: Location to store a pointer to the created pixmap,
* or %NULL if the pixmap is not needed.
* @mask_return: Location to store a pointer to the created mask,
* or %NULL if the mask is not needed.
* @alpha_threshold: Threshold value for opacity values.
*
* Creates a pixmap and a mask bitmap which are returned in the @pixmap_return
* and @mask_return arguments, respectively, and renders a pixbuf and its
* corresponding tresholded alpha mask to them. This is merely a convenience
* function; applications that need to render pixbufs with dither offsets or to
* given drawables should use gdk_draw_pixbuf(), and gdk_pixbuf_render_threshold_alpha().
*
* The pixmap that is created uses the #GdkColormap specified by @colormap.
* This colormap must match the colormap of the window where the pixmap
* will eventually be used or an error will result.
*
* If the pixbuf does not have an alpha channel, then *@mask_return will be set
* to %NULL.
**/
void
gdk_pixbuf_render_pixmap_and_mask_for_colormap (GdkPixbuf *pixbuf,
GdkColormap *colormap,
GdkPixmap **pixmap_return,
GdkBitmap **mask_return,
int alpha_threshold)
{
GdkScreen *screen;
g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
g_return_if_fail (GDK_IS_COLORMAP (colormap));
screen = gdk_colormap_get_screen (colormap);
if (pixmap_return)
{
GdkGC *gc;
*pixmap_return = gdk_pixmap_new (gdk_screen_get_root_window (screen),
gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
gdk_colormap_get_visual (colormap)->depth);
gdk_drawable_set_colormap (GDK_DRAWABLE (*pixmap_return), colormap);
gc = _gdk_drawable_get_scratch_gc (*pixmap_return, FALSE);
/* If the pixbuf has an alpha channel, using gdk_pixbuf_draw would give
* random pixel values in the area that are within the mask, but semi-
* transparent. So we treat the pixbuf like a pixbuf without alpha channel;
* see bug #487865.
*/
if (gdk_pixbuf_get_has_alpha (pixbuf))
gdk_draw_rgb_32_image (*pixmap_return, gc,
0, 0,
gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
GDK_RGB_DITHER_NORMAL,
gdk_pixbuf_get_pixels (pixbuf), gdk_pixbuf_get_rowstride (pixbuf));
else
gdk_draw_pixbuf (*pixmap_return, gc, pixbuf,
0, 0, 0, 0,
gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
GDK_RGB_DITHER_NORMAL,
0, 0);
}
if (mask_return)
{
if (gdk_pixbuf_get_has_alpha (pixbuf))
{
*mask_return = gdk_pixmap_new (gdk_screen_get_root_window (screen),
gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), 1);
gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return,
0, 0, 0, 0,
gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
alpha_threshold);
}
else
*mask_return = NULL;
}
}
static void
na_tray_manager_set_visual_property (NaTrayManager *manager)
{
#ifdef GDK_WINDOWING_X11
GdkWindow *window;
GdkDisplay *display;
Visual *xvisual;
Atom visual_atom;
gulong data[1];
if (!manager->invisible)
return;
window = gtk_widget_get_window (manager->invisible);
if (!window)
return;
/* The visual property is a hint to the tray icons as to what visual they
* should use for their windows. If the X server has RGBA colormaps, then
* we tell the tray icons to use a RGBA colormap and we'll composite the
* icon onto its parents with real transparency. Otherwise, we just tell
* the icon to use our colormap, and we'll do some hacks with parent
* relative backgrounds to simulate transparency.
*/
display = gtk_widget_get_display (manager->invisible);
visual_atom = gdk_x11_get_xatom_by_name_for_display (display,
"_NET_SYSTEM_TRAY_VISUAL");
if (gdk_screen_get_rgba_visual (manager->screen) != NULL &&
gdk_display_supports_composite (display))
{
xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_rgba_visual (manager->screen));
}
else
{
/* We actually want the visual of the tray where the icons will
* be embedded. In almost all cases, this will be the same as the visual
* of the screen.
*/
GdkColormap *colormap;
colormap = gdk_screen_get_default_colormap (manager->screen);
xvisual = GDK_VISUAL_XVISUAL (gdk_colormap_get_visual (colormap));
}
data[0] = XVisualIDFromVisual (xvisual);
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XWINDOW (window),
visual_atom,
XA_VISUALID, 32,
PropModeReplace,
(guchar *) &data, 1);
#endif
}
static GdkColormap*
get_cmap (GdkPixmap *pixmap)
{
GdkColormap *cmap;
cmap = gdk_drawable_get_colormap (pixmap);
if (cmap)
g_object_ref (G_OBJECT (cmap));
if (cmap == NULL)
{
if (gdk_drawable_get_depth (pixmap) == 1)
{
/* try null cmap */
cmap = NULL;
}
else
{
/* Try system cmap */
GdkScreen *screen = gdk_drawable_get_screen (GDK_DRAWABLE (pixmap));
cmap = gdk_screen_get_system_colormap (screen);
g_object_ref (G_OBJECT (cmap));
}
}
/* Be sure we aren't going to blow up due to visual mismatch */
if (cmap &&
#if GTK_CHECK_VERSION(2,21,0)
(gdk_visual_get_depth (gdk_colormap_get_visual (cmap)) !=
gdk_drawable_get_depth (pixmap))
#else
(gdk_colormap_get_visual (cmap)->depth !=
gdk_drawable_get_depth (pixmap))
#endif
)
{
g_object_unref (G_OBJECT (cmap));
cmap = NULL;
}
return cmap;
}
void
gfxGdkNativeRenderer::Draw(gfxContext* ctx, nsIntSize size,
PRUint32 flags, GdkColormap* colormap)
{
mColormap = colormap;
Visual* visual =
gdk_x11_visual_get_xvisual(gdk_colormap_get_visual(colormap));
Screen* screen =
gdk_x11_screen_get_xscreen(gdk_colormap_get_screen(colormap));
gfxXlibNativeRenderer::Draw(ctx, size, flags, screen, visual, nsnull);
}
void
alloc_color (GtkStyle * style, GdkColor * color)
{
GdkColormap *cmap = style->colormap;
gint depth = style->depth;
if (!(cmap)) {
cmap = gdk_colormap_get_system();
depth = gdk_colormap_get_visual(cmap)->depth;
}
gdk_colormap_alloc_color (cmap, color, FALSE, TRUE);
}
void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
{
// get the right icon to display
wxIcon *icon = NULL;
if ( action & GDK_ACTION_MOVE )
icon = &m_iconMove;
else if ( action & GDK_ACTION_COPY )
icon = &m_iconCopy;
else
icon = &m_iconNone;
GdkBitmap *mask;
if ( icon->GetMask() )
mask = icon->GetMask()->GetBitmap();
else
mask = NULL;
GdkPixmap *pixmap = icon->GetPixmap();
gint width,height;
gdk_window_get_size (pixmap, &width, &height);
GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
gtk_widget_push_visual (gdk_colormap_get_visual (colormap));
gtk_widget_push_colormap (colormap);
m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (GTK_WIDGET (m_iconWindow), TRUE);
gtk_widget_pop_visual ();
gtk_widget_pop_colormap ();
gtk_widget_set_usize (m_iconWindow, width, height);
gtk_widget_realize (m_iconWindow);
gtk_signal_connect( GTK_OBJECT(m_iconWindow), "configure_event",
GTK_SIGNAL_FUNC(gtk_dnd_window_configure_callback), (gpointer)this );
gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE);
if (mask)
gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
}
GdkGC *
new_color_gc (GtkStyle * style, GdkColor * color)
{
GdkGCValues gc_values;
GdkColormap *cmap = style->colormap;
gint depth = style->depth;
if (!(cmap)) {
cmap = gdk_colormap_get_system();
depth = gdk_colormap_get_visual(cmap)->depth;
}
gdk_colormap_alloc_color (cmap, color, FALSE, TRUE);
gc_values.foreground = *color;
return gtk_gc_get (depth, cmap,
&gc_values, GDK_GC_FOREGROUND);
}
GtkWidget *build_line(gint start_x, gint start_y
, gint width, gint height, GtkWidget *hour_line, GdkColor *line_color)
{
GdkColormap *pic1_cmap;
GdkVisual *pic1_vis;
GdkPixmap *pic1;
GdkGC *pic1_gc;
GtkWidget *new_hour_line;
gint depth = 16;
gboolean first = FALSE;
/*
* GdkPixbuf *scaled;
scaled = gdk_pixbuf_scale_simple (pix, w, h, GDK_INTERP_BILINEAR);
*/
pic1_cmap = gdk_colormap_get_system();
pic1_vis = gdk_colormap_get_visual(pic1_cmap);
depth = pic1_vis->depth;
if (hour_line == NULL) {
pic1 = gdk_pixmap_new(NULL, width, height, depth);
gdk_drawable_set_colormap(pic1, pic1_cmap);
first = TRUE;
}
else
gtk_image_get_pixmap(GTK_IMAGE(hour_line), &pic1, NULL);
pic1_gc = gdk_gc_new(pic1);
if (first) {
gdk_gc_set_foreground(pic1_gc, line_color);
gdk_draw_rectangle(pic1, pic1_gc, TRUE, start_x, start_y, width, height);
}
else {
gdk_draw_rectangle(pic1, pic1_gc, TRUE, start_x, start_y, width, height);
}
new_hour_line = gtk_image_new_from_pixmap(pic1, NULL);
g_object_unref(pic1_gc);
g_object_unref(pic1);
return(new_hour_line);
}
GdkPixmap*
create_pixmap (int width,
int height)
{
GdkColormap* colormap;
GdkDrawable* drawable;
cairo_t * cr;
colormap = gdk_screen_get_system_colormap (gdk_screen_get_default ());
g_assert (colormap);
drawable = gdk_pixmap_new (NULL, 200, 200, gdk_colormap_get_visual (colormap)->depth);
g_test_queue_unref (drawable);
gdk_drawable_set_colormap (drawable, colormap);
cr = gdk_cairo_create (drawable);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
cairo_destroy (cr);
return drawable;
}
static GdkColormap*
get_cmap (GdkPixmap *pixmap)
{
GdkColormap *cmap;
cmap = gdk_drawable_get_colormap (pixmap);
if (cmap)
g_object_ref (G_OBJECT (cmap));
if (cmap == NULL)
{
if (gdk_drawable_get_depth (pixmap) == 1)
{
meta_verbose ("Using NULL colormap for snapshotting bitmap\n");
cmap = NULL;
}
else
{
meta_verbose ("Using system cmap to snapshot pixmap\n");
cmap = gdk_screen_get_system_colormap (gdk_drawable_get_screen (pixmap));
g_object_ref (G_OBJECT (cmap));
}
}
/* Be sure we aren't going to blow up due to visual mismatch */
if (cmap &&
(gdk_colormap_get_visual (cmap)->depth !=
gdk_drawable_get_depth (pixmap)))
{
cmap = NULL;
meta_verbose ("Switching back to NULL cmap because of depth mismatch\n");
}
return cmap;
}
static void setup_font_sample(GtkWidget* darea, Antialiasing antialiasing, Hinting hinting)
{
const char* string1 = "abcfgop AO ";
const char* string2 = "abcfgop";
XftColor black, white;
XRenderColor rendcolor;
Display* xdisplay = gdk_x11_get_default_xdisplay();
#if GTK_CHECK_VERSION (3, 0, 0)
Colormap xcolormap = DefaultColormap(xdisplay, 0);
#else
GdkColormap* colormap = gdk_rgb_get_colormap();
Colormap xcolormap = GDK_COLORMAP_XCOLORMAP(colormap);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
GdkVisual* visual = gdk_visual_get_system ();
#else
GdkVisual* visual = gdk_colormap_get_visual(colormap);
#endif
Visual* xvisual = GDK_VISUAL_XVISUAL(visual);
FcPattern* pattern;
XftFont* font1;
XftFont* font2;
XGlyphInfo extents1 = { 0 };
XGlyphInfo extents2 = { 0 };
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkPixmap* pixmap;
#endif
XftDraw* draw;
GdkPixbuf* tmp_pixbuf;
GdkPixbuf* pixbuf;
int width, height;
int ascent, descent;
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ROMAN,
FC_SIZE, FcTypeDouble, 18.,
NULL);
font1 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ITALIC,
FC_SIZE, FcTypeDouble, 20.,
NULL);
font2 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
ascent = 0;
descent = 0;
if (font1)
{
XftTextExtentsUtf8 (xdisplay, font1, (unsigned char*) string1,
strlen (string1), &extents1);
ascent = MAX (ascent, font1->ascent);
descent = MAX (descent, font1->descent);
}
if (font2)
{
XftTextExtentsUtf8 (xdisplay, font2, (unsigned char*) string2, strlen (string2), &extents2);
ascent = MAX (ascent, font2->ascent);
descent = MAX (descent, font2->descent);
}
width = extents1.xOff + extents2.xOff + 4;
height = ascent + descent + 2;
#if !GTK_CHECK_VERSION (3, 0, 0)
pixmap = gdk_pixmap_new (NULL, width, height, visual->depth);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
draw = XftDrawCreate (xdisplay, GDK_WINDOW_XID (gdk_screen_get_root_window (gdk_screen_get_default ())), xvisual, xcolormap);
#else
draw = XftDrawCreate (xdisplay, GDK_DRAWABLE_XID (pixmap), xvisual, xcolormap);
#endif
rendcolor.red = 0;
rendcolor.green = 0;
rendcolor.blue = 0;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &black);
rendcolor.red = 0xffff;
rendcolor.green = 0xffff;
rendcolor.blue = 0xffff;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &white);
XftDrawRect(draw, &white, 0, 0, width, height);
if (font1)
{
XftDrawStringUtf8(draw, &black, font1, 2, 2 + ascent, (unsigned char*) string1, strlen(string1));
}
if (font2)
{
XftDrawStringUtf8(draw, &black, font2, 2 + extents1.xOff, 2 + ascent, (unsigned char*) string2, strlen(string2));
}
XftDrawDestroy(draw);
if (font1)
{
XftFontClose(xdisplay, font1);
}
if (font2)
{
XftFontClose(xdisplay, font2);
}
#if GTK_CHECK_VERSION (3, 0, 0)
tmp_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE,8, width, height);
#else
tmp_pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, colormap, 0, 0, 0, 0, width, height);
#endif
pixbuf = gdk_pixbuf_scale_simple(tmp_pixbuf, 1 * width, 1 * height, GDK_INTERP_TILES);
#if !GTK_CHECK_VERSION (3, 0, 0)
g_object_unref(pixmap);
#endif
g_object_unref(tmp_pixbuf);
g_object_set_data_full(G_OBJECT(darea), "sample-pixbuf", pixbuf, (GDestroyNotify) g_object_unref);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_size_request (GTK_WIDGET(darea), width + 2, height + 2);
g_signal_connect(darea, "draw", G_CALLBACK(sample_draw), NULL);
#else
g_signal_connect(darea, "size_request", G_CALLBACK(sample_size_request), NULL);
g_signal_connect(darea, "expose_event", G_CALLBACK(sample_expose), NULL);
#endif
}
static VALUE
rg_visual(VALUE self)
{
return GOBJ2RVAL(gdk_colormap_get_visual(_SELF(self)));
}
/*#
@method get_visual GdkColormap
@brief Returns the visual for which a given colormap was created.
@return the visual of the colormap.
*/
FALCON_FUNC Colormap::get_visual( VMARG )
{
NO_ARGS
vm->retval( new Gdk::Visual( vm->findWKI( "GdkVisual" )->asClass(),
gdk_colormap_get_visual( GET_COLORMAP( vm->self() ) ) ) );
}
bool wxGLCanvas::Create( wxWindow *parent,
const wxGLContext *shared,
const wxGLCanvas *shared_context_of,
wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name,
int *attribList,
const wxPalette& palette)
{
m_sharedContext = (wxGLContext*)shared; // const_cast
m_sharedContextOf = (wxGLCanvas*)shared_context_of; // const_cast
m_glContext = (wxGLContext*) NULL;
m_exposed = false;
m_noExpose = true;
m_nativeSizeEvent = true;
m_fbc = NULL;
m_vi = NULL;
// to be sure the glx version is known
wxGLCanvas::QueryGLXVersion();
if (wxGLCanvas::GetGLXVersion() >= 13)
{
// GLX >= 1.3 uses a GLXFBConfig
GLXFBConfig * fbc = NULL;
if (wxTheApp->m_glFBCInfo != NULL)
{
fbc = (GLXFBConfig *) wxTheApp->m_glFBCInfo;
m_canFreeFBC = false; // owned by wxTheApp - don't free upon destruction
}
else
{
fbc = (GLXFBConfig *) wxGLCanvas::ChooseGLFBC(attribList);
m_canFreeFBC = true;
}
m_fbc = fbc; // save for later use
wxCHECK_MSG( m_fbc, false, _T("required FBConfig couldn't be found") );
}
XVisualInfo *vi = NULL;
if (wxTheApp->m_glVisualInfo != NULL)
{
vi = (XVisualInfo *)wxTheApp->m_glVisualInfo;
m_canFreeVi = false; // owned by wxTheApp - don't free upon destruction
}
else
{
if (wxGLCanvas::GetGLXVersion() >= 13)
// GLX >= 1.3
vi = glXGetVisualFromFBConfig(GDK_DISPLAY(), m_fbc[0]);
else
// GLX <= 1.2
vi = (XVisualInfo *) ChooseGLVisual(attribList);
m_canFreeVi = true;
}
m_vi = vi; // save for later use
wxCHECK_MSG( m_vi, false, _T("required visual couldn't be found") );
GdkVisual *visual;
GdkColormap *colormap;
// MR: This needs a fix for lower gtk+ versions too. Might need to rethink logic (FIXME)
#if 0
if (!gtk_check_version(2,2,0))
{
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
GdkScreen *screen = gtk_widget_get_screen( m_glWidget );
colormap = gdk_screen_get_default_colormap(screen);
visual = gdk_colormap_get_visual(colormap);
if (GDK_VISUAL_XVISUAL(visual)->visualid != vi->visualid)
{
visual = gdk_x11_screen_lookup_visual( screen, vi->visualid );
colormap = gdk_colormap_new(visual, FALSE);
}
gtk_widget_set_colormap( m_glWidget, colormap );
}
else
#endif
{
visual = gdkx_visual_get( vi->visualid );
colormap = gdk_colormap_new( visual, TRUE );
gtk_widget_push_colormap( colormap );
gtk_widget_push_visual( visual );
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
}
gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (GTK_WIDGET_REALIZED(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
if (GTK_WIDGET_MAPPED(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
return true;
}
SetIconText(GtkStatusIcon *tray_icon, const char *text, const char *color) {
// build background from image
GdkPixbuf* special_icon = gdk_pixbuf_new_from_file("message-mail-new.png", NULL); // GError **error);
GdkPixbuf *dest = gdk_pixbuf_copy(special_icon);
int w=gdk_pixbuf_get_width(special_icon);
int h=gdk_pixbuf_get_height(special_icon);
// prepare colors/alpha
GdkColormap* cmap=gdk_screen_get_system_colormap(gdk_screen_get_default());
int screen_depth=24;
GdkVisual* visual = gdk_colormap_get_visual(cmap);
screen_depth = visual->depth;
GdkColor fore = { 0, 0, 0, 0 };
GdkColor alpha = { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
gdk_color_parse(color, &fore);
if(fore.red==alpha.red && fore.green==alpha.green && fore.blue==alpha.blue) {
alpha.red=0; // make sure alpha is different from fore
}
gdk_colormap_alloc_color (cmap, &fore, TRUE, TRUE);
gdk_colormap_alloc_color (cmap, &alpha, TRUE, TRUE);
// build pixmap with rectangle
GdkPixmap *pm = gdk_pixmap_new (NULL, w, h, screen_depth);
cairo_t *cr = gdk_cairo_create(pm);
gdk_cairo_set_source_color(cr, &alpha);
/* void gdk_cairo_set_source_color (cairo_t *cr, */
/* const GdkColor *color); */
cairo_rectangle(cr, 0, 0, w, h);
/* void cairo_rectangle (cairo_t *cr, */
/* double x, */
/* double y, */
/* double width, */
/* double height); */
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_fill(cr);
// build text
GtkWidget *scratch = gtk_window_new(GTK_WINDOW_TOPLEVEL);
PangoLayout *layout = gtk_widget_create_pango_layout(scratch, NULL);
gtk_widget_destroy(scratch);
PangoFontDescription *fnt = pango_font_description_from_string("Sans 18");
pango_font_description_set_weight (fnt,PANGO_WEIGHT_SEMIBOLD);
pango_layout_set_spacing (layout,0);
pango_layout_set_font_description (layout, fnt);
pango_layout_set_text (layout, (gchar *)text,-1);
int tw=0;
int th=0;
int sz;
int border=4;
pango_layout_get_pixel_size(layout, &tw, &th);
while( (tw>w - border || th > h - border)) //fit text to the icon by decreasing font size
{
sz=pango_font_description_get_size (fnt);
if(sz<MIN_FONT_SIZE) {
sz=MIN_FONT_SIZE;
break;
}
sz-=PANGO_SCALE;
pango_font_description_set_size (fnt,sz);
pango_layout_set_font_description (layout, fnt);
pango_layout_get_pixel_size(layout, &tw, &th);
}
pango_font_description_free (fnt);
// center text
int px, py;
px=(w-tw)/2;
py=(h-th)/2;
// draw text on pixmap
gdk_cairo_set_source_color(cr, &fore);
cairo_move_to (cr, px, py);
pango_cairo_show_layout (cr, layout);
cairo_destroy(cr);
g_object_unref (layout);
GdkPixbuf *buf = gdk_pixbuf_get_from_drawable (NULL, pm, NULL, 0, 0, 0, 0, w, h);
g_object_unref (pm);
GdkPixbuf *alpha_buf = gdk_pixbuf_add_alpha(buf, TRUE, (guchar)alpha.red, (guchar)alpha.green, (guchar)alpha.blue);
g_object_unref (buf);
//merge the rendered text on top
gdk_pixbuf_composite(alpha_buf,dest,0,0,w,h,0,0,1,1,GDK_INTERP_NEAREST,255);
g_object_unref(alpha_buf);
/* gdk_pixbuf_composite(buf,dest,0,0,w,h,0,0,1,1,GDK_INTERP_NEAREST,255); */
/* g_object_unref(buf); */
gtk_status_icon_set_from_pixbuf(GTK_STATUS_ICON(tray_icon), GDK_PIXBUF(dest));
}
