static void
gsd_media_keys_window_real_realize (GtkWidget *widget)
{
GdkColormap *colormap;
GtkAllocation allocation;
GdkBitmap *mask;
cairo_t *cr;
colormap = gdk_screen_get_rgba_colormap (gtk_widget_get_screen (widget));
if (colormap != NULL) {
gtk_widget_set_colormap (widget, colormap);
}
if (GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->realize) {
GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->realize (widget);
}
gtk_widget_get_allocation (widget, &allocation);
mask = gdk_pixmap_new (gtk_widget_get_window (widget),
allocation.width,
allocation.height,
1);
cr = gdk_cairo_create (mask);
cairo_set_source_rgba (cr, 1., 1., 1., 0.);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
/* make the whole window ignore events */
gdk_window_input_shape_combine_mask (gtk_widget_get_window (widget), mask, 0, 0);
g_object_unref (mask);
cairo_destroy (cr);
}
static void
create_window (GsdLocatePointerData *data,
GdkScreen *screen)
{
GdkColormap *colormap;
GdkVisual *visual;
GdkWindowAttr attributes;
colormap = gdk_screen_get_rgba_colormap (screen);
visual = gdk_screen_get_rgba_visual (screen);
if (!colormap)
{
colormap = gdk_screen_get_rgb_colormap (screen);
visual = gdk_screen_get_rgb_visual (screen);
}
attributes.window_type = GDK_WINDOW_TEMP;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = visual;
attributes.colormap = colormap;
attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK;
attributes.width = 1;
attributes.height = 1;
data->window = gdk_window_new (gdk_screen_get_root_window (screen),
&attributes,
GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
gdk_window_set_user_data (data->window, data->widget);
}
void RenderThemeGtk::platformInit()
{
m_themePartsHaveRGBAColormap = true;
m_gtkWindow = 0;
m_gtkContainer = 0;
m_gtkButton = 0;
m_gtkEntry = 0;
m_gtkTreeView = 0;
m_gtkVScale = 0;
m_gtkHScale = 0;
m_gtkRadioButton = 0;
m_gtkCheckButton = 0;
m_gtkProgressBar = 0;
m_gtkComboBox = 0;
m_gtkComboBoxButton = 0;
m_gtkComboBoxArrow = 0;
m_gtkComboBoxSeparator = 0;
m_gtkVScrollbar = 0;
m_gtkHScrollbar = 0;
m_gtkSpinButton = 0;
m_colormap = gdk_screen_get_rgba_colormap(gdk_screen_get_default());
if (!m_colormap) {
m_themePartsHaveRGBAColormap = false;
m_colormap = gdk_screen_get_default_colormap(gdk_screen_get_default());
}
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *box;
GdkScreen *screen;
GdkColormap *map;
gtk_init (&argc, &argv);
screen = gdk_screen_get_default ();
map = gdk_screen_get_rgba_colormap (screen);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
if (map)
gtk_widget_set_colormap (window, map);
gtk_window_resize (GTK_WINDOW (window), 50, 100);
gtk_widget_show (window);
box = awn_icon_box_new ();
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show (box);
pixbuf_icon (box);
cairo_icon (box);
pixbuf_icon (box);
cairo_icon (box);
gtk_main ();
return 0;
}
GdkPixbuf *
meta_ui_get_pixbuf_from_pixmap (Pixmap pmap)
{
GdkPixmap *gpmap;
GdkScreen *screen;
GdkPixbuf *pixbuf;
GdkColormap *cmap;
int width, height, depth;
gpmap = gdk_pixmap_foreign_new (pmap);
screen = gdk_drawable_get_screen (gpmap);
gdk_drawable_get_size (GDK_DRAWABLE (gpmap), &width, &height);
depth = gdk_drawable_get_depth (GDK_DRAWABLE (gpmap));
if (depth <= 24)
cmap = gdk_screen_get_rgb_colormap (screen);
else
cmap = gdk_screen_get_rgba_colormap (screen);
pixbuf = gdk_pixbuf_get_from_drawable (NULL, gpmap, cmap, 0, 0, 0, 0,
width, height);
g_object_unref (gpmap);
return pixbuf;
}
int
setupwindow()
{
GdkPixmap *background;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled;
GdkScreen *screen;
GdkColormap *colormap;
GError *error=NULL;
GtkStyle *style;
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "expose_event", G_CALLBACK(expose_window),NULL);
gtk_window_set_title(GTK_WINDOW(window), "clock");
gtk_window_stick(GTK_WINDOW(window));
gtk_window_set_resizable(GTK_WINDOW(window),TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window),TRUE);
gtk_window_set_keep_above(GTK_WINDOW(window),TRUE);
gtk_container_set_border_width(GTK_CONTAINER(window), 3);
gtk_window_set_decorated(GTK_WINDOW(window),TRUE);
gtk_window_set_default_size(GTK_WINDOW(window),100,100);
gtk_widget_set_app_paintable(window,TRUE);
/* Get the screen to get the colormap */
screen=gtk_widget_get_screen(window);
colormap = gdk_screen_get_rgba_colormap(screen);
if(colormap != NULL){
alpha_channel_support=TRUE;
} else {
alpha_channel_support=FALSE;
colormap=gdk_screen_get_rgb_colormap(screen);
g_print("Sorry, no alpha!\n");
}
/* Tell the window to use the colormap */
gtk_widget_set_colormap(window,colormap);
/* Get a pixbuf from the image file */
pixbuf=gdk_pixbuf_new_from_file("clockface.png",&error);
if(pixbuf==NULL){
g_print("Failed to open background image: %s\n", error->message);
g_error_free(error);
error=NULL;
return 0;
}
/* Make it the same size as the window */
scaled=gdk_pixbuf_scale_simple(pixbuf,100,100, GDK_INTERP_BILINEAR);
/* Render it using the colormap of the window */
gdk_pixbuf_render_pixmap_and_mask_for_colormap(scaled,colormap,&background,NULL,0);
/* Make a new style, stick the background in it, tell window to use it. */
style = gtk_style_new();
style->bg_pixmap[0] = background;
gtk_widget_set_style(GTK_WIDGET(window),GTK_STYLE(style));
/*gtk_window_set_opacity(GTK_WINDOW(window),0.3);*/
gtk_window_move(GTK_WINDOW(window), 0, 0);
gtk_widget_show_all(window);
return 1;
}
void
on_alpha_screen_changed(GtkWidget* pWidget, GdkScreen* pOldScreen,GtkWidget* pLabel)
{
GdkScreen* pScreen = gtk_widget_get_screen(pWidget);
GdkColormap* pColormap = gdk_screen_get_rgba_colormap(pScreen);
if (!pColormap) pColormap = gdk_screen_get_rgb_colormap(pScreen);
gtk_widget_set_colormap(pWidget, pColormap);
}
static gboolean
on_expose_event_cb (GtkWidget *widget, GdkEventExpose *event,
Starter *wcm)
{
GtkAllocation allocation;
GdkWindow *window;
cairo_t *cr;
cairo_pattern_t *pattern;
window = gtk_widget_get_window (widget);
cr = gdk_cairo_create (window);
gtk_widget_get_allocation (widget, &allocation);
pattern = cairo_pattern_create_linear (0, 0, 0, allocation.height);
if (gdk_screen_get_rgba_colormap (gtk_widget_get_screen (widget)) &&
gtk_widget_is_composited (widget))
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
else
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_pattern_add_color_stop_rgba (pattern, 0.0,
0.6, 0.7, 0.9, 1.0); /* solid orange */
cairo_pattern_add_color_stop_rgba (pattern, 0.18,
1.0, 1.0, 1.0, 1.0); /* transparent orange */
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_paint (cr);
cairo_destroy (cr);
cr = gdk_cairo_create (window);
gdk_cairo_set_source_pixbuf (cr, wcm->priv->logo, 20, 20);
cairo_paint (cr);
cairo_destroy (cr);
GList *l, *list = NULL;
list = gtk_container_get_children (GTK_CONTAINER (widget));
for (l = list; l != NULL; l = g_list_next (l))
gtk_container_propagate_expose (GTK_CONTAINER (widget), l->data, event);
g_list_free (list);
return TRUE;
}
GdkColormap *
get_colormap_for_drawable (GdkDrawable *d)
{
GdkDisplay *display = gdk_display_get_default ();
GdkScreen *screen = gdk_display_get_default_screen (display);
if (gdk_drawable_get_depth (d) == 32)
return gdk_screen_get_rgba_colormap (screen);
return gdk_screen_get_rgb_colormap (screen);
}
//_____________________________________________________
gboolean ArgbHelper::styleSetHook( GSignalInvocationHint*, guint, const GValue* params, gpointer )
{
// get widget from params
GtkWidget* widget( GTK_WIDGET( g_value_get_object( params ) ) );
// check type
if( !GTK_IS_WIDGET( widget ) ) return FALSE;
if( !GTK_IS_WINDOW( widget ) ) return TRUE;
// make sure widget has not been realized already
#if GTK_CHECK_VERSION(2, 20, 0)
if( gtk_widget_get_realized( widget ) ) return TRUE;
#else
if( GTK_WIDGET_REALIZED( widget ) ) return TRUE;
#endif
// screen
GdkScreen* screen = gdk_screen_get_default();
if( !screen ) return TRUE;
// colormap
GdkColormap* colormap(gdk_screen_get_rgba_colormap( screen ) );
if( !colormap ) return TRUE;
// hint
GtkWindow* window( GTK_WINDOW( widget ) );
GdkWindowTypeHint hint = gtk_window_get_type_hint( window );
if(
hint == GDK_WINDOW_TYPE_HINT_MENU ||
hint == GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU ||
hint == GDK_WINDOW_TYPE_HINT_POPUP_MENU ||
hint == GDK_WINDOW_TYPE_HINT_TOOLTIP ||
hint == GDK_WINDOW_TYPE_HINT_COMBO
)
{
#if OXYGEN_DEBUG
std::cerr << "Oxygen::ArgbHelper::styleSetHook - "
<< widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")"
<< " hint: " << Gtk::TypeNames::windowTypeHint( hint )
<< std::endl;
#endif
// assign argb colormap to widget
gtk_widget_set_colormap( widget, colormap );
}
return TRUE;
}
void
screen_changed_handler (GtkWidget* window,
GdkScreen* old_screen,
gpointer data)
{
GdkScreen* screen = gtk_widget_get_screen (window);
GdkColormap* colormap = gdk_screen_get_rgba_colormap (screen);
if (!colormap)
colormap = gdk_screen_get_rgb_colormap (screen);
gtk_widget_set_colormap (window, colormap);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *icon_box, *vbox;
GdkScreen *screen;
GdkColormap *map;
gtk_init (&argc, &argv);
screen = gdk_screen_get_default ();
map = gdk_screen_get_rgba_colormap (screen);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
if (map)
gtk_widget_set_colormap (window, map);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add( GTK_CONTAINER(window), vbox);
icon_box = awn_icon_box_new ();
gtk_container_add (GTK_CONTAINER (vbox), icon_box);
icons[0] = AWN_ICON(pixbuf_icon (icon_box));
icons[1] = AWN_ICON(cairo_icon (icon_box));
icons[2] = AWN_ICON(surface_icon (icon_box));
icons[3] = AWN_ICON(thin_surface_icon (icon_box));
GtkWidget *button = gtk_button_new_with_label("Active");
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(on_active_click), NULL);
gtk_container_add (GTK_CONTAINER(vbox), button);
GtkWidget *button2 = gtk_button_new_with_label("Running");
g_signal_connect(G_OBJECT(button2), "clicked",
G_CALLBACK(on_running_click), NULL);
gtk_container_add (GTK_CONTAINER(vbox), button2);
GtkWidget *button3 = gtk_button_new_with_label("Signal");
g_signal_connect(G_OBJECT(button3), "clicked",
G_CALLBACK(on_signal_click), NULL);
gtk_container_add (GTK_CONTAINER(vbox), button3);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int main(int argc, char* argv[]) {
gtk_init(&argc, &argv);
if (argc == 1) {
printf("Usage: URI\n");
return 1;
}
const char *uri = argv[1];
if(!g_thread_supported())
g_thread_init(NULL);
// Create a Window, set colormap to RGBA
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkScreen *screen = gtk_widget_get_screen(window);
#if GTK_CHECK_VERSION(3, 0, 0)
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (visual && gdk_screen_is_composited (screen)) {
gtk_widget_set_visual(GTK_WIDGET(window), visual);
}
#else
GdkColormap *rgba = gdk_screen_get_rgba_colormap (screen);s
if (rgba && gdk_screen_is_composited (screen)) {
gtk_widget_set_default_colormap(rgba);
gtk_widget_set_default_colormap(rgba);
}
#endif
gtk_window_set_default_size(GTK_WINDOW(window), 600, 400);
g_signal_connect(window, "destroy", G_CALLBACK(destroy_cb), NULL);
// Optional: for dashboard style borderless windows
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
// Create a WebView, set it transparent, add it to the window
WebKitWebView* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
webkit_web_view_set_transparent(web_view, TRUE);
gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(web_view));
// Load a default page
webkit_web_view_load_uri(web_view, uri);
// Show it and continue running until the window closes
gtk_widget_grab_focus(GTK_WIDGET(web_view));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void
hd_bookmark_shortcut_realize (GtkWidget *widget)
{
GdkScreen *screen;
screen = gtk_widget_get_screen (widget);
gtk_widget_set_colormap (widget,
gdk_screen_get_rgba_colormap (screen));
gtk_widget_set_app_paintable (widget,
TRUE);
GTK_WIDGET_CLASS (hd_bookmark_shortcut_parent_class)->realize (widget);
}
static void
awn_tooltip_init (AwnTooltip *tooltip)
{
AwnTooltipPrivate *priv;
GError *error = NULL;
GdkScreen *screen;
priv = tooltip->priv = AWN_TOOLTIP_GET_PRIVATE (tooltip);
priv->client = awn_config_get_default (AWN_PANEL_ID_DEFAULT, &error);
if (error)
{
g_critical ("An error occurred while trying to retrieve the configuration client: %s",
error->message);
g_error_free (error);
return;
}
priv->text = NULL;
priv->font_name = NULL;
priv->font_color = NULL;
priv->position = GTK_POS_BOTTOM;
priv->size = 50;
priv->show_timer_id = 0;
priv->hide_timer_id = 0;
gtk_widget_set_app_paintable (GTK_WIDGET (tooltip), TRUE);
g_signal_connect (tooltip, "configure-event",
G_CALLBACK (_on_configure_event), NULL);
g_signal_connect (tooltip, "composited-changed",
G_CALLBACK (_on_composited_changed), NULL);
screen = gdk_screen_get_default ();
if (gdk_screen_get_rgba_colormap (screen))
gtk_widget_set_colormap (GTK_WIDGET (tooltip),
gdk_screen_get_rgba_colormap (screen));
}
// Look for an existing Colormap that known to be associated with visual.
static Colormap
LookupColormapForVisual(const Screen* screen, const Visual* visual)
{
// common case
if (visual == DefaultVisualOfScreen(screen))
return DefaultColormapOfScreen(screen);
#ifdef MOZ_WIDGET_GTK2
// I wish there were a gdk_x11_display_lookup_screen.
Display* dpy = DisplayOfScreen(screen);
GdkDisplay* gdkDpy = gdk_x11_lookup_xdisplay(dpy);
if (gdkDpy) {
gint screen_num = 0;
for (int s = 0; s < ScreenCount(dpy); ++s) {
if (ScreenOfDisplay(dpy, s) == screen) {
screen_num = s;
break;
}
}
GdkScreen* gdkScreen = gdk_display_get_screen(gdkDpy, screen_num);
GdkColormap* gdkColormap = NULL;
if (visual ==
GDK_VISUAL_XVISUAL(gdk_screen_get_rgb_visual(gdkScreen))) {
// widget/src/gtk2/mozcontainer.c uses gdk_rgb_get_colormap()
// which is inherited by child widgets, so this is the visual
// expected when drawing directly to widget surfaces or surfaces
// created using cairo_surface_create_similar with
// CAIRO_CONTENT_COLOR.
// gdk_screen_get_rgb_colormap is the generalization of
// gdk_rgb_get_colormap for any screen.
gdkColormap = gdk_screen_get_rgb_colormap(gdkScreen);
}
else if (visual ==
GDK_VISUAL_XVISUAL(gdk_screen_get_rgba_visual(gdkScreen))) {
// This is the visual expected on displays with the Composite
// extension enabled when the surface has been created using
// cairo_surface_create_similar with CAIRO_CONTENT_COLOR_ALPHA,
// as happens with non-unit opacity.
gdkColormap = gdk_screen_get_rgba_colormap(gdkScreen);
}
if (gdkColormap != NULL)
return GDK_COLORMAP_XCOLORMAP(gdkColormap);
}
#endif
return None;
}
static void
initialize_alpha_mode (GsdMediaKeysWindow *window, GdkScreen *screen)
{
GdkColormap *colormap = NULL;
if (gdk_screen_is_composited (screen)) {
colormap = gdk_screen_get_rgba_colormap (screen);
}
if (colormap != NULL) {
gtk_widget_set_colormap (GTK_WIDGET (window), colormap);
window->priv->is_composited = TRUE;
} else {
window->priv->is_composited = FALSE;
}
}
static void pp_make_panel(PPPanel *panel)
{
/* TODO: Use gtk_widget_show_all(); it's more efficient and concise. */
GtkWindow *window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
panel->window = window;
gtk_window_set_skip_taskbar_hint(window, TRUE);
gtk_window_set_decorated(window, FALSE);
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_set_app_paintable(GTK_WIDGET(window), TRUE);
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(window));
GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
gtk_widget_set_colormap(GTK_WIDGET(window), colormap);
g_signal_connect(G_OBJECT(window), "expose-event",
G_CALLBACK(pp_on_window_expose), NULL);
GtkBox *vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(vbox));
GtkBox *hbox = panel->hbox = GTK_BOX(gtk_hbox_new(FALSE, 3));
gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(hbox));
gtk_widget_set_size_request(GTK_WIDGET(hbox), -1, PP_PANEL_HEIGHT);
gtk_widget_show(GTK_WIDGET(hbox));
pp_create_spacer(GTK_CONTAINER(vbox), -1, 1);
gtk_widget_show(GTK_WIDGET(vbox));
/* Create the indicator menu. */
GtkMenuBar *indicator_menu = (GtkMenuBar *)(gtk_menu_bar_new());
panel->menu = indicator_menu;
pp_monkey_patch_gtk_menu_bar(indicator_menu);
gtk_widget_set_name(GTK_WIDGET(indicator_menu), "fast-user-switch");
gtk_container_add(GTK_CONTAINER(hbox), GTK_WIDGET(indicator_menu));
gtk_widget_show(GTK_WIDGET(indicator_menu));
/* Magic! */
GTK_WIDGET_SET_FLAGS(GTK_WIDGET(indicator_menu), GTK_NO_WINDOW);
/* Create the tray. */
pp_tray_create(panel);
pp_create_spacer(GTK_CONTAINER(hbox), 3, -1);
}
void gnomenu_menu_set_use_rgba_colormap (GnomenuMenu* self, gboolean value) {
GdkScreen* screen;
GdkColormap* colormap;
g_return_if_fail (self != NULL);
if (self->priv->_use_rgba_colormap == value) {
return;
}
self->priv->_use_rgba_colormap = value;
screen = _g_object_ref0 (gtk_widget_get_screen (((GtkMenu*) self)->toplevel));
colormap = _g_object_ref0 (gdk_screen_get_rgba_colormap (screen));
if (colormap != NULL) {
gtk_widget_set_colormap (((GtkMenu*) self)->toplevel, colormap);
gtk_widget_set_colormap ((GtkWidget*) self, colormap);
}
_g_object_unref0 (colormap);
_g_object_unref0 (screen);
g_object_notify ((GObject *) self, "use-rgba-colormap");
}
static void
on_screen_changed (GtkWidget *window,
GdkScreen *previous,
GtkTooltip *tooltip)
{
GdkScreen *screen;
GdkColormap *cmap;
screen = gtk_widget_get_screen (window);
cmap = NULL;
if (gdk_screen_is_composited (screen))
cmap = gdk_screen_get_rgba_colormap (screen);
if (cmap == NULL)
cmap = gdk_screen_get_rgb_colormap (screen);
gtk_widget_set_colormap (window, cmap);
}
void
omweather_plugin_realize (GtkWidget *widget)
{
GdkScreen *screen;
#ifdef DEBUGFUNCTIONCALL
START_FUNCTION;
#endif
screen = gtk_widget_get_screen (widget);
gtk_widget_set_colormap (widget,
gdk_screen_get_rgba_colormap (screen));
gtk_widget_set_app_paintable (widget,
TRUE);
GTK_WIDGET_CLASS(g_type_class_peek_parent
(GTK_FRAME_GET_CLASS(widget)))->realize(widget);
}
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;
}
DragIcon::DragIcon()
: m_window(gtk_window_new(GTK_WINDOW_POPUP))
{
#ifdef GTK_API_VERSION_2
g_signal_connect(m_window, "expose-event", G_CALLBACK(dragIconWindowDrawEventCallback), this);
#else
g_signal_connect(m_window, "draw", G_CALLBACK(dragIconWindowDrawEventCallback), this);
#endif
// This strategy originally comes from Chromium: src/chrome/browser/gtk/tab_contents_drag_source.cc
GdkScreen* screen = gtk_widget_get_screen(m_window);
#ifdef GTK_API_VERSION_2
GdkColormap* rgba = gdk_screen_get_rgba_colormap(screen);
if (rgba)
gtk_widget_set_colormap(m_window, rgba);
#else
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
if (!visual)
visual = gdk_screen_get_system_visual(screen);
gtk_widget_set_visual(m_window, visual);
#endif // GTK_API_VERSION_2
}
static void
cairo_menu_init (CairoMenu *self)
{
CairoMenuPrivate * priv = GET_PRIVATE (self);
priv->cairo_style = FALSE;
if (priv->cairo_style)
{
static GdkScreen * screen = NULL;
static GdkColormap * newmap = NULL;
if (!screen)
{
screen = gdk_screen_get_default();
}
if (!newmap)
{
newmap = gdk_screen_get_rgba_colormap (screen);
}
gtk_widget_set_colormap (GTK_WIDGET(self),newmap);
awn_utils_ensure_transparent_bg (GTK_WIDGET(self));
}
}
void cgraphics_screen_changed_handler( GtkWidget *widget, GdkScreen *arg1, widget_t *w )
{
GdkScreen *sc;
GdkColormap *cm;
gtk_widget_realize( widget );
sc = gtk_widget_get_screen( widget );
cm = gdk_screen_get_rgba_colormap( gtk_widget_get_screen(widget) );
w->supports_alpha = 0;
if ( cm == NULL )
{
printf( "Warning: Alpha not supported\n" );
cm = gdk_screen_get_rgb_colormap( gtk_widget_get_screen(widget) );
}
else
w->supports_alpha = 1;
gtk_widget_set_colormap( widget, cm );
}
static GtkWidget*
create_window ()
{
g_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (g_window), g_framebuffer_width, g_framebuffer_height);
gtk_widget_set_name (g_window, "eve-browser");
gtk_window_set_decorated(GTK_WINDOW(g_window), false);
GdkScreen *screen = gtk_widget_get_screen(g_window);
gtk_widget_set_colormap(g_window, gdk_screen_get_rgba_colormap(screen));
gtk_widget_set_app_paintable(g_window, true);
gtk_widget_realize(g_window);
gdk_window_set_back_pixmap(g_window->window, NULL, false);
g_signal_connect(g_window, "expose-event", G_CALLBACK(expose_event), g_window);
g_signal_connect (g_window, "destroy", G_CALLBACK (destroy_cb), NULL);
g_signal_connect (g_window, "key-press-event", G_CALLBACK (on_key_press), NULL);
g_signal_connect (g_window, "key-release-event", G_CALLBACK (on_key_press), NULL);
//g_signal_connect (g_window, "screen-changed", G_CALLBACK (screen_changed), NULL);
return g_window;
}
void build_mainwindow(void) {
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(mainwindow, TRUE);
gtk_widget_set_size_request(mainwindow, conf_get_width(), conf_get_height());
gtk_window_set_decorated(GTK_WINDOW(mainwindow), FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_resizable(GTK_WINDOW(mainwindow), TRUE);
mainwindow_reset_position();
fullscreen = FALSE;
toggled = FALSE;
GtkAccelGroup* accel_group;
GClosure *new_tab, *delete_tab, *next_tab, *prev_tab, *delete_all,
*maximize, *copy, *paste;
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(mainwindow), accel_group);
maximize = g_cclosure_new_swap(G_CALLBACK(mainwindow_toggle_fullscreen),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_F11, 0,
GTK_ACCEL_VISIBLE, maximize);
new_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_new_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 't', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, new_tab);
delete_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_delete_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'w', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_tab);
next_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_next_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Down, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, next_tab);
prev_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_prev_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Up, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, prev_tab);
delete_all = g_cclosure_new_swap(G_CALLBACK(mainwindow_destroy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'q', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_all);
copy = g_cclosure_new_swap(G_CALLBACK(mainwindow_copy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'c', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, copy);
paste = g_cclosure_new_swap(G_CALLBACK(mainwindow_paste),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'v', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, paste);
activetab = -1;
tabs = g_array_new(TRUE, FALSE, sizeof(VteTerminal*));
tabcount = 0;
GtkVBox* mainbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
tabbar = GTK_NOTEBOOK(gtk_notebook_new());
g_signal_connect(G_OBJECT(tabbar), "switch-page",
G_CALLBACK(mainwindow_switch_tab), NULL);
if (conf_get_opacity() < 100) {
GdkScreen *screen = gdk_screen_get_default();
GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
screen_is_composited = (colormap != NULL
&& gdk_screen_is_composited(screen));
if (screen_is_composited) {
gtk_widget_set_colormap(GTK_WIDGET(mainwindow), colormap);
gdk_screen_set_default_colormap(screen, colormap);
}
}
gtk_box_pack_start(GTK_BOX(mainbox), GTK_WIDGET(tabbar), TRUE, TRUE, 0);
mainwindow_create_tab();
gtk_widget_show_all(GTK_WIDGET(mainbox));
gtk_container_add(GTK_CONTAINER(mainwindow), GTK_WIDGET(mainbox));
int border = conf_get_border();
if (border == BORDER_THIN)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 1);
else if (border == BORDER_THICK)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
if (border != BORDER_NONE)
g_signal_connect(G_OBJECT(mainwindow), "expose-event",
G_CALLBACK(mainwindow_expose_event), NULL);
/*
* g_signal_connect connects a GCallback function to a signal for a
* particular object. For example, when the 'focus-out-event' signal is
* triggered (That is, when Stjerm loses focus), the
* 'mainwindow_focus_out_event' function will run.
*/
if (conf_get_auto_hide())
g_signal_connect(G_OBJECT(mainwindow), "focus-out-event",
G_CALLBACK(mainwindow_focus_out_event), NULL);
g_signal_connect(G_OBJECT(mainwindow), "show", G_CALLBACK(mainwindow_show),
NULL);
g_signal_connect(G_OBJECT(mainwindow), "destroy",
G_CALLBACK(mainwindow_destroy), NULL);
gtk_notebook_set_show_border(tabbar, FALSE);
gtk_notebook_set_scrollable(tabbar, TRUE);
if (conf_get_show_tab() == TABS_ONE|| conf_get_show_tab() == TABS_NEVER)
gtk_notebook_set_show_tabs(tabbar, FALSE);
gtk_notebook_set_tab_pos(tabbar, conf_get_tab_pos());
XSetErrorHandler(handle_x_error);
init_key(); // init_key and grab_key are
grab_key(); // defined globally in stjerm.h
g_thread_create((GThreadFunc)wait_key, NULL, FALSE, NULL);
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
GtkWidget* win;
GtkWidget* main_vbox;
GtkWidget* vbox;
GtkWidget* close_button;
GtkWidget* image;
GtkWidget* alignment;
AtkObject* atkobj;
GtkRcStyle* rcstyle;
WindowData* windata;
#ifdef USE_COMPOSITE
GdkColormap* colormap;
GdkScreen* screen;
#endif
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
gtk_widget_set_app_paintable(win, TRUE);
g_signal_connect(G_OBJECT(win), "style-set", G_CALLBACK(on_style_set), windata);
g_signal_connect(G_OBJECT(win), "map-event", G_CALLBACK(on_window_map), windata);
g_signal_connect(G_OBJECT(win), "expose-event", G_CALLBACK(on_window_expose), windata);
g_signal_connect(G_OBJECT(win), "realize", G_CALLBACK(on_window_realize), windata);
windata->win = win;
windata->composited = FALSE;
#ifdef USE_COMPOSITE
screen = gtk_window_get_screen(GTK_WINDOW(win));
colormap = gdk_screen_get_rgba_colormap(screen);
if (colormap != NULL)
{
gtk_widget_set_colormap(win, colormap);
if (gdk_screen_is_composited(screen))
{
windata->composited = TRUE;
}
}
g_signal_connect(win, "composited-changed", G_CALLBACK(on_composited_changed), windata);
#endif
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure-event", G_CALLBACK(on_configure_event), windata);
main_vbox = gtk_vbox_new(FALSE, 0);
g_signal_connect(G_OBJECT(main_vbox), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(main_vbox);
gtk_container_add(GTK_CONTAINER(win), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 12);
windata->main_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);
/* First row (icon, vbox, close) */
windata->iconbox = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(windata->iconbox);
gtk_alignment_set_padding(GTK_ALIGNMENT(windata->iconbox), 5, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_widget_show(windata->icon);
gtk_container_add(GTK_CONTAINER(windata->iconbox), windata->icon);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
/* Add the close button */
alignment = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), alignment, FALSE, FALSE, 0);
close_button = gtk_button_new();
g_signal_connect(G_OBJECT(close_button), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(close_button);
windata->close_button = close_button;
gtk_container_add(GTK_CONTAINER(alignment), close_button);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);
rcstyle = gtk_rc_style_new();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(close_button, rcstyle);
g_object_unref(rcstyle);
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
/* center vbox */
windata->summary_label = gtk_label_new(NULL);
g_signal_connect(G_OBJECT(windata->summary_label), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0);
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
windata->content_hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(windata->content_hbox);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
g_signal_connect(G_OBJECT(windata->body_label), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(windata->body_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0);
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
g_signal_connect_swapped(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(windata->url_clicked), win);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_hbox_new(FALSE, 6);
gtk_widget_show(windata->actions_box);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
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);
}
/* Create new notification */
GtkWindow *
create_notification(UrlClickedCb url_clicked)
{
GtkWidget *spacer;
GtkWidget *win;
GtkWidget *drawbox;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *close_button;
GtkWidget *image;
GtkWidget *alignment;
AtkObject *atkobj;
WindowData *windata;
GdkColormap *colormap;
GdkScreen *screen;
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
windata->win = win;
windata->enable_transparency = FALSE;
screen = gtk_window_get_screen(GTK_WINDOW(win));
colormap = gdk_screen_get_rgba_colormap(screen);
if (colormap != NULL)
{
gtk_widget_set_colormap(win, colormap);
if (gdk_screen_is_composited(screen))
windata->enable_transparency = TRUE;
}
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_realize(win);
gtk_widget_set_size_request(win, WIDTH, -1);
g_object_set_data_full(G_OBJECT(win), "windata", windata,
(GDestroyNotify)destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure_event",
G_CALLBACK(configure_event_cb), windata);
/*
* For some reason, there are occasionally graphics glitches when
* repainting the window. Despite filling the window with a background
* color, parts of the other windows on the screen or the shadows around
* notifications will appear on the notification. Somehow, adding this
* eventbox makes that problem just go away. Whatever works for now.
*/
drawbox = gtk_event_box_new();
gtk_widget_show(drawbox);
gtk_container_add(GTK_CONTAINER(win), drawbox);
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(main_vbox);
gtk_container_add(GTK_CONTAINER(drawbox), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 1);
g_signal_connect(G_OBJECT(main_vbox), "expose_event",
G_CALLBACK(paint_window), windata);
windata->top_spacer = gtk_image_new();
gtk_box_pack_start(GTK_BOX(main_vbox), windata->top_spacer,
FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->top_spacer, -1, DEFAULT_ARROW_HEIGHT);
windata->main_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox,
FALSE, FALSE, 0);
windata->bottom_spacer = gtk_image_new();
gtk_box_pack_start(GTK_BOX(main_vbox), windata->bottom_spacer,
FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->bottom_spacer, -1,
DEFAULT_ARROW_HEIGHT);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
spacer = gtk_image_new();
gtk_widget_show(spacer);
gtk_box_pack_start(GTK_BOX(hbox), spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(spacer, SPACER_LEFT, -1);
windata->summary_label = gtk_label_new(NULL);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(hbox), windata->summary_label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0);
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
/* Add the close button */
close_button = gtk_button_new();
gtk_widget_show(close_button);
gtk_box_pack_start(GTK_BOX(hbox), close_button, FALSE, FALSE, 0);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
gtk_widget_set_size_request(close_button, 24, 24);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked",
G_CALLBACK(gtk_widget_destroy), win);
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0,
"Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
windata->content_hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
windata->iconbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->iconbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), windata->iconbox,
FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_box_pack_start(GTK_BOX(windata->iconbox), windata->icon,
TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->icon), 0.5, 0.0);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0);
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
g_signal_connect(G_OBJECT(windata->body_label), "activate-link",
G_CALLBACK(activate_link), windata);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
