static void
na_tray_manager_set_visual_property (NaTrayManager *manager)
{
#ifdef GDK_WINDOWING_X11
GdkWindow *window;
GdkDisplay *display;
Visual *xvisual;
Atom visual_atom;
gulong data[1];
if (!manager->invisible)
return;
window = gtk_widget_get_window (manager->invisible);
if (!window)
return;
/* The visual property is a hint to the tray icons as to what visual they
* should use for their windows. If the X server has RGBA colormaps, then
* we tell the tray icons to use a RGBA colormap and we'll composite the
* icon onto its parents with real transparency. Otherwise, we just tell
* the icon to use our colormap, and we'll do some hacks with parent
* relative backgrounds to simulate transparency.
*/
display = gtk_widget_get_display (manager->invisible);
visual_atom = gdk_x11_get_xatom_by_name_for_display (display,
"_NET_SYSTEM_TRAY_VISUAL");
if (gdk_screen_get_rgba_visual (manager->screen) != NULL &&
gdk_display_supports_composite (display))
{
xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_rgba_visual (manager->screen));
}
else
{
/* We actually want the visual of the tray where the icons will
* be embedded. In almost all cases, this will be the same as the visual
* of the screen.
*/
GdkColormap *colormap;
colormap = gdk_screen_get_default_colormap (manager->screen);
xvisual = GDK_VISUAL_XVISUAL (gdk_colormap_get_visual (colormap));
}
data[0] = XVisualIDFromVisual (xvisual);
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XWINDOW (window),
visual_atom,
XA_VISUALID, 32,
PropModeReplace,
(guchar *) &data, 1);
#endif
}
static void
create_window (int width,
int height,
gboolean alpha,
gboolean maximized)
{
WindowInfo *info;
info = g_new0 (WindowInfo, 1);
info->width = width;
info->height = height;
info->alpha = alpha;
info->maximized = maximized;
info->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (alpha)
gtk_widget_set_visual (info->window, gdk_screen_get_rgba_visual (gdk_screen_get_default ()));
if (maximized)
gtk_window_maximize (GTK_WINDOW (info->window));
info->pending = TRUE;
gtk_widget_set_size_request (info->window, width, height);
gtk_widget_set_app_paintable (info->window, TRUE);
g_signal_connect (info->window, "map-event", G_CALLBACK (on_window_map_event), info);
g_signal_connect (info->window, "draw", G_CALLBACK (on_window_draw), info);
gtk_widget_show (info->window);
our_windows = g_list_prepend (our_windows, info);
}
static void
msd_osd_window_real_realize (GtkWidget *widget)
{
GdkScreen *screen;
GdkVisual *visual;
cairo_region_t *region;
screen = gtk_widget_get_screen (widget);
visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL) {
visual = gdk_screen_get_system_visual (screen);
}
gtk_widget_set_visual (widget, visual);
if (GTK_WIDGET_CLASS (msd_osd_window_parent_class)->realize) {
GTK_WIDGET_CLASS (msd_osd_window_parent_class)->realize (widget);
}
/* make the whole window ignore events */
region = cairo_region_create ();
gtk_widget_input_shape_combine_region (widget, region);
cairo_region_destroy (region);
}
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);
}
static void
create_window (CsdLocatePointerData *data,
GdkScreen *screen)
{
GdkVisual *visual;
GdkWindowAttr attributes;
gint attributes_mask;
visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
attributes_mask = GDK_WA_X | GDK_WA_Y;
if (visual != NULL)
attributes_mask = attributes_mask | GDK_WA_VISUAL;
attributes.window_type = GDK_WINDOW_TEMP;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = visual;
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,
attributes_mask);
gdk_window_set_user_data (data->window, data->widget);
}
static GtkWidget *
create_select_window (void)
{
GtkWidget *window;
GdkScreen *screen;
GdkVisual *visual;
screen = gdk_screen_get_default ();
visual = gdk_screen_get_rgba_visual (screen);
window = gtk_window_new (GTK_WINDOW_POPUP);
if (gdk_screen_is_composited (screen) && visual)
{
gtk_widget_set_visual (window, visual);
gtk_widget_set_app_paintable (window, TRUE);
}
g_signal_connect (window, "draw", G_CALLBACK (select_window_draw), NULL);
gtk_window_move (GTK_WINDOW (window), -100, -100);
gtk_window_resize (GTK_WINDOW (window), 10, 10);
gtk_widget_show (window);
return window;
}
static void
ensure_size_window (MetaResizePopup *popup)
{
GdkVisual *visual;
GdkScreen *screen;
if (popup->size_window)
return;
popup->size_window = gtk_window_new (GTK_WINDOW_POPUP);
screen = gdk_display_get_screen (gdk_x11_lookup_xdisplay (popup->display),
popup->screen_number);
visual = gdk_screen_get_rgba_visual (screen);
gtk_window_set_screen (GTK_WINDOW (popup->size_window), screen);
if (visual != NULL)
gtk_widget_set_visual (popup->size_window, visual);
gtk_window_set_type_hint (GTK_WINDOW (popup->size_window),
GDK_WINDOW_TYPE_HINT_TOOLTIP);
gtk_window_set_resizable (GTK_WINDOW (popup->size_window), FALSE);
gtk_widget_set_app_paintable (popup->size_window, TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (popup->size_window),
GTK_STYLE_CLASS_TOOLTIP);
g_signal_connect (popup->size_window, "draw",
G_CALLBACK (size_window_draw), popup);
popup->size_label = gtk_label_new ("");
g_object_set (popup->size_label, "margin", 6, NULL);
gtk_container_add (GTK_CONTAINER (popup->size_window), popup->size_label);
gtk_widget_show (popup->size_label);
}
static void
realize (GtkWidget *widget)
{
NemoDesktopWindow *window;
NemoDesktopWindowDetails *details;
GdkVisual *visual;
window = NEMO_DESKTOP_WINDOW (widget);
details = window->details;
/* Make sure we get keyboard events */
gtk_widget_set_events (widget, gtk_widget_get_events (widget)
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
/* Do the work of realizing. */
GTK_WIDGET_CLASS (nemo_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
set_desktop_window_id (window, gtk_widget_get_window (widget));
details->size_changed_id =
g_signal_connect (gtk_window_get_screen (GTK_WINDOW (window)), "size_changed",
G_CALLBACK (nemo_desktop_window_screen_size_changed), window);
}
decor_frame_t *
decor_frame_new (const gchar *type)
{
GdkScreen *gdkscreen = gdk_screen_get_default ();
GdkVisual *visual;
decor_frame_t *frame = malloc (sizeof (decor_frame_t));
if (!frame)
{
g_critical ("Couldn't allocate frame!");
return NULL;
}
frame->type = strdup (type);
frame->refcount = 0;
frame->titlebar_height = 17;
frame->max_titlebar_height = 17;
frame->border_shadow_active = NULL;
frame->border_shadow_inactive = NULL;
frame->border_no_shadow = NULL;
frame->max_border_no_shadow = NULL;
frame->max_border_shadow_active = NULL;
frame->max_border_shadow_inactive = NULL;
frame->titlebar_font = NULL;
frame->style_window_rgba = gtk_window_new (GTK_WINDOW_POPUP);
visual = gdk_screen_get_rgba_visual (gdkscreen);
if (visual)
gtk_widget_set_visual (frame->style_window_rgba, visual);
gtk_widget_realize (frame->style_window_rgba);
gtk_widget_set_size_request (frame->style_window_rgba, 0, 0);
gtk_window_move (GTK_WINDOW (frame->style_window_rgba), -100, -100);
frame->pango_context = gtk_widget_create_pango_context (frame->style_window_rgba);
g_signal_connect_data (frame->style_window_rgba, "style-updated",
G_CALLBACK (style_updated),
(gpointer) frame->pango_context, 0, 0);
frame->style_window_rgb = gtk_window_new (GTK_WINDOW_POPUP);
visual = gdk_screen_get_system_visual (gdkscreen);
if (visual)
gtk_widget_set_visual (frame->style_window_rgb, visual);
gtk_widget_realize (frame->style_window_rgb);
gtk_widget_set_size_request (frame->style_window_rgb, 0, 0);
gtk_window_move (GTK_WINDOW (frame->style_window_rgb), -100, -100);
g_signal_connect_data (frame->style_window_rgb, "style-updated",
G_CALLBACK (style_updated),
(gpointer) frame->pango_context, 0, 0);
return frame;
}
/**
* xfce_workspace_set_workspace_num:
* @workspace: An #XfceWorkspace.
* @GdkScreen: screen the workspace is on.
*
* Updates the backdrops to correctly display the right settings since GTK/GDK
* uses monitor numbers rather than names.
**/
void
xfce_workspace_monitors_changed(XfceWorkspace *workspace,
GdkScreen *gscreen)
{
guint i;
guint n_monitors;
GdkVisual *vis = NULL;
TRACE("entering");
vis = gdk_screen_get_rgba_visual(gscreen);
if(vis == NULL)
vis = gdk_screen_get_system_visual(gscreen);
if(workspace->priv->nbackdrops > 0 &&
xfce_workspace_get_xinerama_stretch(workspace)) {
/* When spanning screens we only need one backdrop */
n_monitors = 1;
} else {
n_monitors = gdk_screen_get_n_monitors(gscreen);
}
/* Remove all backdrops so that the correct monitor is added/removed and
* things stay in the correct order */
xfce_workspace_remove_backdrops(workspace);
/* Allocate space for the backdrops and their color properties so they
* can correctly be removed */
workspace->priv->backdrops = g_realloc(workspace->priv->backdrops,
sizeof(XfceBackdrop *) * n_monitors);
workspace->priv->first_color_id = g_realloc(workspace->priv->first_color_id,
sizeof(gulong) * n_monitors);
workspace->priv->second_color_id = g_realloc(workspace->priv->second_color_id,
sizeof(gulong) * n_monitors);
for(i = 0; i < n_monitors; ++i) {
DBG("Adding workspace %d backdrop %d", workspace->priv->workspace_num, i);
workspace->priv->backdrops[i] = xfce_backdrop_new(vis);
xfce_workspace_connect_backdrop_settings(workspace,
workspace->priv->backdrops[i],
i);
g_signal_connect(G_OBJECT(workspace->priv->backdrops[i]),
"changed",
G_CALLBACK(backdrop_changed_cb), workspace);
g_signal_connect(G_OBJECT(workspace->priv->backdrops[i]),
"cycle",
G_CALLBACK(backdrop_cycle_cb),
workspace);
g_signal_connect(G_OBJECT(workspace->priv->backdrops[i]),
"ready",
G_CALLBACK(backdrop_changed_cb), workspace);
}
workspace->priv->nbackdrops = n_monitors;
}
static void set_colormap(GtkWidget *window)
{
/*Set RGBA visual*/
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (window, visual);
}
void eric_window_screen_changed( GtkWidget *widget, GdkScreen *old_screen, gpointer userdata )
{
GdkVisual *visual;
GdkScreen* screen=gtk_widget_get_screen(widget);
if(!screen) return;
visual = gdk_screen_get_rgba_visual(screen);
if(visual==NULL) visual=gdk_screen_get_system_visual(screen);
gtk_widget_set_visual(widget,visual);
}
static void
gtk_bubble_window_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GdkScreen *screen;
GdkVisual *visual;
screen = gtk_widget_get_screen (widget);
visual = gdk_screen_get_rgba_visual (screen);
if (visual)
gtk_widget_set_visual (widget, visual);
}
void
screen_changed_handler (GtkWidget* window,
GdkScreen* old_screen,
gpointer data)
{
GdkScreen* screen = gtk_widget_get_screen (GTK_WIDGET (window));
GdkVisual* visual = gdk_screen_get_rgba_visual (screen);
if (!visual)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (GTK_WIDGET (window), visual);
}
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 setup(GtkWidget *win)
{
GdkScreen *screen;
GdkVisual *visual;
gtk_widget_set_app_paintable(win, TRUE);
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_DOCK);
// gtk_window_set_keep_below(GTK_WINDOW(win), TRUE);
screen = gdk_screen_get_default();
visual = gdk_screen_get_rgba_visual(screen);
if(visual != NULL && gdk_screen_is_composited(screen))
gtk_widget_set_visual(win, visual);
}
static void
realize (GtkWidget *widget)
{
GdkVisual *visual;
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
GTK_WIDGET_CLASS (nemo_blank_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
}
// 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;
}
void on_screen_changed(GtkWidget *widget,
GdkScreen *previous_screen,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
if(data->debug)
g_printerr("DEBUG: got screen-changed event\n");
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET (widget));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (widget, visual);
}
/*
* http://web.mit.edu/ghudson/dev/nokrb/third/libwnck/libwnck/test-wnck.c
* constructor
* set the window transparence
*/
AppWindow::AppWindow()
{
add_events(Gdk::BUTTON_PRESS_MASK);
set_app_paintable(true);
GdkScreen *screen;
GdkVisual *visual;
gtk_widget_set_app_paintable(GTK_WIDGET(gobj()), TRUE);
screen = gdk_screen_get_default();
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL && gdk_screen_is_composited(screen)) {
gtk_widget_set_visual(GTK_WIDGET(gobj()), visual);
}
}
void on_screen_change_event(GtkWidget *widget, gboolean *supportsAlpha)
{
GdkScreen *screen = gtk_widget_get_screen(widget);
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (!visual)
g_print("Your screen doesn't support alpha\n");
else
*supportsAlpha = TRUE;
gtk_widget_set_visual(widget, visual);
g_object_unref(visual);
return;
}
static void
update_opacity_sensitivity (PanelPropertiesDialog *dialog)
{
GtkWidget *widget;
GdkScreen *screen;
GdkVisual *visual;
widget = GTK_WIDGET (dialog);
screen = gtk_widget_get_screen (widget);
visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL || gtk_widget_is_composited (widget) == FALSE) {
gtk_widget_set_sensitive (dialog->priv->background_opacity_box, FALSE);
} else {
gtk_widget_set_sensitive (dialog->priv->background_opacity_box, TRUE);
}
}
void ly_3lrc_desktop_create ()
{
int lrc_desktop_visible=1;
int lrc_desktop_fixed=0;
if(!ly_reg_get("3lrc_desktop_state", "%d:%d", &lrc_desktop_visible, &lrc_desktop_fixed))
{
ly_reg_set("3lrc_desktop_state", "%d:%d", lrc_desktop_visible, lrc_desktop_fixed);
}
int w=1000;
int h=50;
int x=0;
int y=0;
ly_reg_get("3lrc_desktop_pos_and_size", "%d:%d:%d:%d", &x, &y, &w, &h);
ly_3lrc_desktop=gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_default_size(GTK_WINDOW(ly_3lrc_desktop),w,h);
gtk_window_move(GTK_WINDOW(ly_3lrc_desktop),x,y);
gtk_widget_set_app_paintable(ly_3lrc_desktop, TRUE);
gtk_window_set_decorated(GTK_WINDOW(ly_3lrc_desktop), FALSE);
GdkVisual *visual;
GdkScreen *screen;
screen = gtk_widget_get_screen(ly_3lrc_desktop);
visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (GTK_WIDGET (ly_3lrc_desktop), visual);
gtk_widget_set_events(ly_3lrc_desktop,GDK_ALL_EVENTS_MASK);
if(lrc_desktop_visible<=0)
gtk_widget_hide(ly_3lrc_desktop);
if(lrc_desktop_fixed>0)
gtk_widget_set_sensitive(ly_3lrc_desktop,FALSE);
gtk_widget_show_all(ly_3lrc_desktop);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "draw", G_CALLBACK(ly_3lrc_desktop_on_expose_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "button_press_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "button_release_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "motion_notify_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "enter_notify_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "leave_notify_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
ly_3lrc_desktop_timeout=g_timeout_add(100, ly_3lrc_desktop_on_update_cb, NULL);
}
static GtkWidget *
create_fake_menu (MateMenuTreeDirectory *directory)
{
GtkWidget *menu;
guint idle_id;
menu = create_empty_menu ();
g_object_set_data_full (G_OBJECT (menu),
"panel-menu-tree-directory",
matemenu_tree_item_ref (directory),
(GDestroyNotify) matemenu_tree_item_unref);
g_object_set_data (G_OBJECT (menu),
"panel-menu-needs-loading",
GUINT_TO_POINTER (TRUE));
g_signal_connect (menu, "show",
G_CALLBACK (submenu_to_display), NULL);
idle_id = g_idle_add_full (G_PRIORITY_LOW,
submenu_to_display_in_idle,
menu,
NULL);
g_object_set_data_full (G_OBJECT (menu),
"panel-menu-idle-id",
GUINT_TO_POINTER (idle_id),
remove_submenu_to_display_idle);
g_signal_connect (menu, "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
#if GTK_CHECK_VERSION (3, 0, 0)
GtkWidget *toplevel = gtk_widget_get_toplevel (menu);
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
#endif
return menu;
}
static void
realize (GtkWidget *widget)
{
GdkVisual *visual;
/* Make sure we get keyboard events */
gtk_widget_set_events (widget, gtk_widget_get_events (widget)
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
/* Do the work of realizing. */
GTK_WIDGET_CLASS (nemo_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
}
void screen_changed(GtkWidget *widget, GdkScreen *old_screen, gpointer userdata)
{
/* To check if the display supports alpha channels, get the visual */
GdkScreen *screen = gtk_widget_get_screen(widget);
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (!visual)
{
printf("Your screen does not support alpha channels!\n");
visual = gdk_screen_get_system_visual(screen);
supports_alpha = FALSE;
}
else
{
printf("Your screen supports alpha channels!\n");
supports_alpha = TRUE;
}
gtk_widget_set_visual(widget, visual);
}
void
populate_menu (charpick_data *curr_data)
{
GList *list = curr_data->chartable;
GSList *group = NULL;
GtkMenu *menu;
GtkWidget *menuitem;
if (curr_data->menu)
gtk_widget_destroy (curr_data->menu);
curr_data->menu = gtk_menu_new ();
menu = GTK_MENU (curr_data->menu);
while (list) {
gchar *string = list->data;
menuitem = gtk_radio_menu_item_new_with_label (group, string);
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
gtk_widget_show (menuitem);
g_object_set_data (G_OBJECT (menuitem), "string", string);
g_signal_connect (G_OBJECT (menuitem), "activate",
G_CALLBACK (menuitem_activated), curr_data);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
if (g_ascii_strcasecmp (curr_data->charlist, string) == 0)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
list = g_list_next (list);
}
build_table(curr_data);
/*Set up custom theme and transparency support*/
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu));
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
/* Set menu and it's toplevel window to follow panel theme */
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));
gtk_style_context_add_class(context,"gnome-panel-menu-bar");
gtk_style_context_add_class(context,"mate-panel-menu-bar");
}
static void ghtml_window_initialize(int width, int height, bool as_dialog, void *file) {
ghtml_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ghtml_window));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (ghtml_window, visual);
g_signal_connect(ghtml_window, "destroy", G_CALLBACK(ghtml_window_destroy), NULL);
void *ghtml_window_scrollable_content_area = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(
ghtml_window_scrollable_content_area, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC
);
if (ghtml_app_title) gtk_window_set_title(ghtml_window, ghtml_app_title);
gtk_window_set_default_size(ghtml_window, width, height);
ghtml_webview = WEBKIT_WEB_VIEW(webkit_web_view_new());
gtk_container_add(ghtml_window, ghtml_window_scrollable_content_area);
if (as_dialog) {
gtk_window_set_type_hint((void*) ghtml_window, GDK_WINDOW_TYPE_HINT_DIALOG);
GtkAccelGroup *gtk_accel = gtk_accel_group_new ();
GClosure *closure;
closure = g_cclosure_new (G_CALLBACK (ghtml_window_escaped), NULL, NULL);
gtk_accel_group_connect (gtk_accel, gdk_keyval_from_name ("Escape"), 0, GTK_ACCEL_LOCKED, closure);
gtk_window_add_accel_group (ghtml_window, gtk_accel);
}
ghtml_webview_initialize(ghtml_window_scrollable_content_area, file, true);
}
/* On screen changed. */
G_MODULE_EXPORT void
on_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
if (data->debug)
{
g_printerr ("DEBUG: Annotation window get screen-changed event\n");
}
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (widget));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
{
visual = gdk_screen_get_system_visual (screen);
}
gtk_widget_set_visual (widget, visual);
}
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
}
