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;
}
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 gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = (XVisualInfo*)win->m_vi;
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
#if GTK_CHECK_VERSION(2, 2, 0)
if (gtk_check_version(2, 2, 0) == NULL)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
}
else
#endif
{
visual = gdkx_visual_get(xvi->visualid);
}
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
}
// remove hook
return false;
}
return true;
}
static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = win->GetXVisualInfo();
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
#ifdef __WXGTK3__
gtk_widget_set_visual(win->m_wxwindow, visual);
#else
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
#endif
}
// remove hook
return false;
}
return true;
}
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);
}
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");
}
//_____________________________________________________
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;
}
static void
widget_set_best_colormap (GtkWidget *widget)
{
GdkColormap *colormap;
g_return_if_fail (widget != NULL);
colormap = get_best_colormap_for_screen (gtk_widget_get_screen (widget));
if (colormap != NULL)
{
gtk_widget_set_colormap (widget, colormap);
g_object_unref (colormap);
}
}
static gint
ensure_window_widget()
{
if (!gParts->protoWindow) {
gParts->protoWindow = gtk_window_new(GTK_WINDOW_POPUP);
if (gParts->colormap)
gtk_widget_set_colormap(gParts->protoWindow, gParts->colormap);
gtk_widget_realize(gParts->protoWindow);
moz_gtk_set_widget_name(gParts->protoWindow);
}
return MOZ_GTK_SUCCESS;
}
GtkWidget* RenderThemeGtk::gtkContainer() const
{
if (m_gtkContainer)
return m_gtkContainer;
m_gtkWindow = gtk_window_new(GTK_WINDOW_POPUP);
gtk_widget_set_colormap(m_gtkWindow, m_themeParts.colormap);
gtk_widget_realize(m_gtkWindow);
gtk_widget_set_name(m_gtkWindow, "MozillaGtkWidget");
m_gtkContainer = gtk_fixed_new();
setupWidgetAndAddToContainer(m_gtkContainer, m_gtkWindow);
return m_gtkContainer;
}
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
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);
}
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);
}
static void
gtku_gl_drawing_area_init (GtkuGLDrawingArea * self)
{
GtkuGLDrawingAreaPrivate * priv = GTKU_GL_DRAWING_AREA_GET_PRIVATE (self);
gtk_widget_set_double_buffered (GTK_WIDGET (self), FALSE);
priv->dpy = NULL;
priv->visual = NULL;
priv->context = NULL;
#ifdef USE_VBLANK
priv->vblank_watch = 0;
priv->pipe[0] = -1;
priv->thread = 0;
priv->quit_thread = 0;
priv->swap_requested = 0;
#endif
XVisualInfo * vinfo = glXChooseVisual (GDK_DISPLAY (),
GDK_SCREEN_XNUMBER (gdk_screen_get_default ()),
attr_list);
if (!vinfo) {
fprintf (stderr, "Preferred visual not found, using default...\n");
return;
}
VisualID desired_id = vinfo->visualid;
XFree (vinfo);
GList * visuals = gdk_list_visuals ();
GList * vis;
for (vis = visuals; vis; vis = vis->next) {
Visual * xv = GDK_VISUAL_XVISUAL (vis->data);
if (XVisualIDFromVisual (xv) == desired_id) {
GdkColormap * colormap = gdk_colormap_new (vis->data, FALSE);
gtk_widget_set_colormap (GTK_WIDGET (self), colormap);
g_object_unref (G_OBJECT (colormap));
break;
}
}
g_list_free (visuals);
}
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));
}
}
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
}
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;
}
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));
}
int
main (int argc,
char *argv[])
{
gint major, minor;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *drawing_area;
GtkWidget *button;
/*
* Init GTK.
*/
gtk_init (&argc, &argv);
/*
* Init GtkGLExt.
*/
gtk_gl_init (&argc, &argv);
/*
* Query OpenGL extension version.
*/
gdk_gl_query_version (&major, &minor);
g_print ("\nOpenGL extension version - %d.%d\n",
major, minor);
/*
* Configure OpenGL-capable visual.
*/
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_SINGLE);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
examine_gl_config_attrib (glconfig);
/*
* Top-level window.
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "pixmap");
/*
* If window manager doesn't watch the WM_COLORMAP_WINDOWS property on
* the top-level window, we have to set OpenGL window's colormap to the
* top-level window.
*/
gtk_widget_set_colormap (window,
gdk_gl_config_get_colormap (glconfig));
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
/*
* VBox.
*/
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/*
* Drawing area for drawing OpenGL scene.
*/
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 200, 200);
/* Set OpenGL-capable colormap. */
gtk_widget_set_colormap (drawing_area,
gdk_gl_config_get_colormap (glconfig));
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (configure_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/*
* Simple quit button.
*/
button = gtk_button_new_with_label ("Quit");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_main_quit), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/*
* Show window.
*/
gtk_widget_show (window);
/*
* Main loop.
*/
/* Destroy the GLX context explicitly when application is terminated. */
gtk_quit_add (0, (GtkFunction) destroy_gl_context, NULL);
gtk_main ();
return 0;
}
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);
}
GtkWindow* create_notification(Settings settings) {
WindowData *windata;
GtkWidget *win;
#ifdef USE_COMPOSITE
GdkColormap *colormap;
GdkScreen *screen;
#endif
// create WindowData object
windata = g_new0(WindowData, 1);
// create GTK window
win = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_resizable(GTK_WINDOW (win), FALSE);
gtk_widget_set_app_paintable(win, TRUE);
windata->win = win;
windata->settings = settings;
// connect signals
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);
// prepare composite
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_window_set_default_size(GTK_WINDOW(win), 400, 400);
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_CENTER);
g_object_set_data_full (G_OBJECT (win),
"windata", windata,
(GDestroyNotify)destroy_windata);
g_signal_connect (G_OBJECT (win),
"configure-event",
G_CALLBACK (on_configure_event),
windata);
windata->main_vbox = gtk_vbox_new(FALSE, 0);
g_signal_connect(G_OBJECT(windata->main_vbox),
"style-set",
G_CALLBACK(on_style_set),
windata);
gtk_widget_show(windata->main_vbox);
gtk_container_add(GTK_CONTAINER(win), windata->main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(windata->main_vbox), DEFAULT_BORDER);
// 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);
// icon box
windata->iconbox = gtk_alignment_new (0.5f, 0, 0, 0);
gtk_widget_show (windata->iconbox);
gtk_alignment_set_padding (GTK_ALIGNMENT (windata->iconbox),
0, IMAGE_PADDING, 0, 0);
gtk_box_pack_start (GTK_BOX (windata->main_vbox),
windata->iconbox,
FALSE, FALSE, 0);
gtk_widget_set_size_request (windata->iconbox, BODY_X_OFFSET, -1);
// icon
windata->icon = gtk_image_new ();
gtk_widget_show (windata->icon);
gtk_container_add (GTK_CONTAINER (windata->iconbox), windata->icon);
// progress bar box
windata->progressbarbox = gtk_alignment_new (0.5f, 0, 0, 0);
gtk_widget_show (windata->progressbarbox);
// gtk_alignment_set_padding (GTK_ALIGNMENT (windata->iconbox),
// 5, 0, 0, 0);
gtk_box_pack_start (GTK_BOX (windata->main_vbox),
windata->progressbarbox,
FALSE, FALSE, 0);
gtk_widget_set_size_request (windata->progressbarbox, BODY_X_OFFSET, -1);
// progress bar
windata->progressbar = gtk_image_new ();
gtk_widget_show (windata->progressbar);
gtk_container_add (GTK_CONTAINER (windata->progressbarbox), windata->progressbar);
return GTK_WINDOW(win);
}
