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 }