static GdkColormap *
gdk_gl_config_setup_colormap (GdkScreen *screen,
PIXELFORMATDESCRIPTOR *pfd,
gboolean is_rgba)
{
GDK_GL_NOTE_FUNC_PRIVATE ();
if (is_rgba)
{
/*
* For RGBA mode.
*/
/* System default colormap. */
GDK_GL_NOTE (MISC, g_message (" -- Colormap: system default"));
return g_object_ref (G_OBJECT (gdk_screen_get_system_colormap (screen)));
}
else
{
/*
* For color index mode.
*/
/* New private colormap. */
GDK_GL_NOTE (MISC, g_message (" -- Colormap: new allocated writable"));
return gdk_colormap_new (gdk_screen_get_system_visual (screen), TRUE);
}
/* not reached */
return NULL;
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));
if (display_name == NULL ||
g_ascii_strcasecmp (display_name,
gdk_display_get_name (_gdk_display)) == 0)
{
if (_gdk_display != NULL)
{
GDK_NOTE (MISC, g_print ("... return _gdk_display\n"));
return _gdk_display;
}
}
else
{
GDK_NOTE (MISC, g_print ("... return NULL\n"));
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_monitor_init ();
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init (_gdk_display);
_gdk_dnd_init ();
/* Precalculate display name */
(void) gdk_display_get_name (_gdk_display);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
GDK_NOTE (MISC, g_print ("... _gdk_display now set up\n"));
return _gdk_display;
}
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;
}
GdkPixbuf* meta_ui_get_pixbuf_from_pixmap(Pixmap pmap)
{
GdkPixmap* gpmap;
GdkScreen* screen;
GdkPixbuf* pixbuf;
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkColormap* cmap;
#endif
int width;
int height;
int depth;
gpmap = gdk_pixmap_foreign_new(pmap);
screen = gdk_drawable_get_screen(gpmap);
#if GTK_CHECK_VERSION(3, 0, 0)
width = gdk_window_get_width(GDK_WINDOW(gpmap));
height = gdk_window_get_height(GDK_WINDOW(gpmap));
#else
gdk_drawable_get_size(GDK_DRAWABLE(gpmap), &width, &height);
#endif
depth = gdk_drawable_get_depth(GDK_DRAWABLE(gpmap));
#if !GTK_CHECK_VERSION (3, 0, 0)
if (depth <= 24)
{
cmap = gdk_screen_get_system_colormap(screen);
}
else
{
cmap = gdk_screen_get_rgba_colormap(screen);
}
#endif
pixbuf = gdk_pixbuf_get_from_drawable(NULL, gpmap, cmap, 0, 0, 0, 0, width, height);
g_object_unref(gpmap);
return pixbuf;
}
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;
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
if (gdk_display == NULL || _gdk_display != NULL)
return NULL; /* single display only */
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init ();
_gdk_dnd_init ();
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return _gdk_display;
}
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;
}
GtkWidget *
na_tray_child_new (GdkScreen *screen,
Window icon_window)
{
XWindowAttributes window_attributes;
Display *xdisplay;
NaTrayChild *child;
GdkVisual *visual;
gboolean visual_has_alpha;
GdkColormap *colormap;
gboolean new_colormap;
int red_prec, green_prec, blue_prec, depth;
int result;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (icon_window != None, NULL);
xdisplay = GDK_SCREEN_XDISPLAY (screen);
/* We need to determine the visual of the window we are embedding and create
* the socket in the same visual.
*/
gdk_error_trap_push ();
result = XGetWindowAttributes (xdisplay, icon_window,
&window_attributes);
gdk_error_trap_pop ();
if (!result) /* Window already gone */
return NULL;
visual = gdk_x11_screen_lookup_visual (screen,
window_attributes.visual->visualid);
if (!visual) /* Icon window is on another screen? */
return NULL;
new_colormap = FALSE;
if (visual == gdk_screen_get_rgb_visual (screen))
colormap = gdk_screen_get_rgb_colormap (screen);
else if (visual == gdk_screen_get_rgba_visual (screen))
colormap = gdk_screen_get_rgba_colormap (screen);
else if (visual == gdk_screen_get_system_visual (screen))
colormap = gdk_screen_get_system_colormap (screen);
else
{
colormap = gdk_colormap_new (visual, FALSE);
new_colormap = TRUE;
}
child = g_object_new (NA_TYPE_TRAY_CHILD, NULL);
child->icon_window = icon_window;
gtk_widget_set_colormap (GTK_WIDGET (child), colormap);
/* We have alpha if the visual has something other than red, green,
* and blue */
gdk_visual_get_red_pixel_details (visual, NULL, NULL, &red_prec);
gdk_visual_get_green_pixel_details (visual, NULL, NULL, &green_prec);
gdk_visual_get_blue_pixel_details (visual, NULL, NULL, &blue_prec);
depth = gdk_visual_get_depth (visual);
visual_has_alpha = red_prec + blue_prec + green_prec < depth;
child->has_alpha = (visual_has_alpha &&
gdk_display_supports_composite (gdk_screen_get_display (screen)));
child->composited = child->has_alpha;
if (new_colormap)
g_object_unref (colormap);
return GTK_WIDGET (child);
}
/* Main entry point for gdk in 2.6 args are parsed
*/
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
IDirectFB *directfb;
IDirectFBDisplayLayer *layer;
IDirectFBInputDevice *keyboard;
DFBResult ret;
if (_gdk_display)
{
return GDK_DISPLAY_OBJECT (_gdk_display); /* single display only */
}
ret = DirectFBInit (NULL, NULL);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBInit", ret);
return NULL;
}
ret = DirectFBCreate (&directfb);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBCreate", ret);
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY_DFB, NULL);
_gdk_display->directfb = directfb;
ret = directfb->GetDisplayLayer (directfb, DLID_PRIMARY, &layer);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetDisplayLayer", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
ret = directfb->GetInputDevice (directfb, DIDID_KEYBOARD, &keyboard);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetInputDevice", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
_gdk_display->layer = layer;
_gdk_display->keyboard = keyboard;
_gdk_directfb_keyboard_init ();
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_visual_init ();
_gdk_windowing_window_init (_gdk_screen);
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init ();
_gdk_dnd_init ();
layer->EnableCursor (layer, 1);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return GDK_DISPLAY_OBJECT (_gdk_display);
}
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));
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
HMODULE user32;
if (_gdk_display != NULL)
return NULL; /* single display only */
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
#ifdef HAVE_MONITOR_INFO
user32 = GetModuleHandle ("USER32.dll");
g_assert (user32 != NULL);
p_EnumDisplayMonitors = (t_EnumDisplayMonitors) GetProcAddress (user32, "EnumDisplayMonitors");
p_GetMonitorInfoA = (t_GetMonitorInfoA) GetProcAddress (user32, "GetMonitorInfoA");
if (p_EnumDisplayMonitors != NULL && p_GetMonitorInfoA != NULL)
{
gint i, index;
_gdk_num_monitors = 0;
(*p_EnumDisplayMonitors) (NULL, NULL, count_monitor, (LPARAM) &_gdk_num_monitors);
_gdk_monitors = g_new (GdkRectangle, _gdk_num_monitors);
index = 0;
(*p_EnumDisplayMonitors) (NULL, NULL, enum_monitor, (LPARAM) &index);
#if 1
_gdk_offset_x = G_MININT;
_gdk_offset_y = G_MININT;
/* Calculate offset */
for (i = 0; i < _gdk_num_monitors; i++)
{
_gdk_offset_x = MAX (_gdk_offset_x, -_gdk_monitors[i].x);
_gdk_offset_y = MAX (_gdk_offset_y, -_gdk_monitors[i].y);
}
GDK_NOTE (MISC, g_print ("Multi-monitor offset: (%d,%d)\n",
_gdk_offset_x, _gdk_offset_y));
/* Translate monitor coords into GDK coordinate space */
for (i = 0; i < _gdk_num_monitors; i++)
{
_gdk_monitors[i].x += _gdk_offset_x;
_gdk_monitors[i].y += _gdk_offset_y;
GDK_NOTE (MISC, g_print ("Monitor %d: %dx%d@+%d+%d\n",
i, _gdk_monitors[i].width,
_gdk_monitors[i].height,
_gdk_monitors[i].x, _gdk_monitors[i].y));
}
#endif
}
else
#endif /* HAVE_MONITOR_INFO */
{
RECT rect;
_gdk_num_monitors = 1;
_gdk_monitors = g_new (GdkRectangle, 1);
SystemParametersInfo (SPI_GETWORKAREA, 0, &rect, 0);
_gdk_monitors[0].x = rect.left;
_gdk_monitors[0].y = rect.top;
_gdk_monitors[0].width = rect.right - rect.left;
_gdk_monitors[0].height = rect.bottom - rect.top;
_gdk_offset_x = 0;
_gdk_offset_y = 0;
}
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init (_gdk_display);
_gdk_dnd_init ();
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return _gdk_display;
}
