static GdkColormap * gdk_gl_config_setup_colormap (GdkScreen *screen, PIXELFORMATDESCRIPTOR *pfd, gboolean is_rgba) { GDK_GL_NOTE_FUNC_PRIVATE (); if (is_rgba) { /* * For RGBA mode. */ /* System default colormap. */ GDK_GL_NOTE (MISC, g_message (" -- Colormap: system default")); return g_object_ref (G_OBJECT (gdk_screen_get_system_colormap (screen))); } else { /* * For color index mode. */ /* New private colormap. */ GDK_GL_NOTE (MISC, g_message (" -- Colormap: new allocated writable")); return gdk_colormap_new (gdk_screen_get_system_visual (screen), TRUE); } /* not reached */ return NULL; }
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); }
gboolean xfwmPixmapRenderGdkPixbuf (xfwmPixmap * pm, GdkPixbuf *pixbuf) { GdkPixbuf *src; GdkPixmap *destw; GdkVisual *gvisual; GdkColormap *cmap; gint width, height; gint dest_x, dest_y; g_return_val_if_fail (pm != NULL, FALSE); g_return_val_if_fail (pm->pixmap != None, FALSE); g_return_val_if_fail (pm->mask != None, FALSE); destw = gdk_xid_table_lookup (pm->pixmap); if (destw) { g_object_ref (G_OBJECT (destw)); } else { destw = gdk_pixmap_foreign_new (pm->pixmap); } if (!destw) { g_warning ("Cannot get pixmap"); return FALSE; } gvisual = gdk_screen_get_system_visual (pm->screen_info->gscr); cmap = gdk_x11_colormap_foreign_new (gvisual, pm->screen_info->cmap); if (!cmap) { g_warning ("Cannot create colormap"); g_object_unref (destw); return FALSE; } width = MIN (gdk_pixbuf_get_width (pixbuf), pm->width); height = MIN (gdk_pixbuf_get_height (pixbuf), pm->height); /* Add 1 for rounding */ dest_x = (pm->width - width + 1) / 2; dest_y = (pm->height - height + 1) / 2; src = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (destw), cmap, dest_x, dest_y, 0, 0, width, height); gdk_pixbuf_composite (pixbuf, src, 0, 0, width, height, 0, 0, 1.0, 1.0, GDK_INTERP_NEAREST, 0xFF); gdk_draw_pixbuf (GDK_DRAWABLE (destw), NULL, src, 0, 0, dest_x, dest_y, width, height, GDK_RGB_DITHER_NONE, 0, 0); g_object_unref (cmap); g_object_unref (src); g_object_unref (destw); return TRUE; }
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); }
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; }
NS_IMETHODIMP nsScreenGtk :: GetPixelDepth(int32_t *aPixelDepth) { GdkVisual * visual = gdk_screen_get_system_visual(gdk_screen_get_default()); *aPixelDepth = gdk_visual_get_depth(visual); return NS_OK; } // GetPixelDepth
static inline int displayDepth() { #if PLATFORM(GTK) return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default())); #elif PLATFORM(EFL) && defined(HAVE_ECORE_X) return ecore_x_default_depth_get(x11HostDisplay(), ecore_x_default_screen_get()); #else return 0; #endif }
static inline int displayDepth() { #if PLATFORM(QT) return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen()); #elif PLATFORM(GTK) return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default())); #else return 0; #endif }
/* This function queries the _XROOTPMAP_ID property from the root window * to determine the current root window background pixmap and returns a * surface to draw directly to it. * If _XROOTPMAP_ID is not set, then NULL returned. */ static cairo_surface_t * get_root_pixmap_id_surface (GdkDisplay *display) { GdkScreen *screen; Display *xdisplay; Visual *xvisual; Window xroot; Atom type; int format, result; unsigned long nitems, bytes_after; unsigned char *data; cairo_surface_t *surface = NULL; g_return_val_if_fail (display != NULL, NULL); screen = gdk_display_get_default_screen (display); xdisplay = GDK_DISPLAY_XDISPLAY (display); xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen)); xroot = RootWindow (xdisplay, GDK_SCREEN_XNUMBER (screen)); result = XGetWindowProperty (xdisplay, xroot, gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), 0L, 1L, False, XA_PIXMAP, &type, &format, &nitems, &bytes_after, &data); if (result != Success || type != XA_PIXMAP || format != 32 || nitems != 1) { XFree (data); data = NULL; } if (data != NULL) { Pixmap pixmap = *(Pixmap *) data; Window root_ret; int x_ret, y_ret; unsigned int w_ret, h_ret, bw_ret, depth_ret; gdk_x11_display_error_trap_push (display); if (XGetGeometry (xdisplay, pixmap, &root_ret, &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret)) { surface = cairo_xlib_surface_create (xdisplay, pixmap, xvisual, w_ret, h_ret); } gdk_x11_display_error_trap_pop_ignored (display); XFree (data); } gdk_display_flush (display); return surface; }
/** * 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); }
static GdkVisual* getVisual(Widget* widget) { GtkWidget* container = widget ? GTK_WIDGET(widget->root()->hostWindow()->platformPageClient()) : 0; if (!container) { GdkScreen* screen = gdk_screen_get_default(); return screen ? gdk_screen_get_system_visual(screen) : 0; } if (!gtk_widget_get_realized(container)) container = getToplevel(container); return container ? gdk_window_get_visual(gtk_widget_get_window(container)) : 0; }
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); }
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); }
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]; g_return_if_fail (manager->invisible != NULL); window = gtk_widget_get_window (manager->invisible); g_return_if_fail (window != NULL); /* 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. */ xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (manager->screen)); } data[0] = XVisualIDFromVisual (xvisual); XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window), visual_atom, XA_VISUALID, 32, PropModeReplace, (guchar *) &data, 1); #endif }
static cairo_surface_t * create_root_surface (GdkScreen *screen) { Atom prop_root, prop_esetroot; gint number, width, height; Display *display; Pixmap pixmap; cairo_surface_t *surface; number = gdk_screen_get_number (screen); width = gdk_screen_get_width (screen); height = gdk_screen_get_height (screen); /* Open a new connection so with Retain Permanent so the pixmap remains when the greeter quits */ gdk_flush (); display = XOpenDisplay (gdk_display_get_name (gdk_screen_get_display (screen))); if (!display) { g_warning ("Failed to create root pixmap"); return NULL; } XSetCloseDownMode (display, RetainPermanent); pixmap = XCreatePixmap (display, RootWindow (display, number), width, height, DefaultDepth (display, number)); XCloseDisplay (display); /* Convert into a Cairo surface */ surface = cairo_xlib_surface_create (GDK_SCREEN_XDISPLAY (screen), pixmap, GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen)), width, height); /* Use this pixmap for the background */ XSetWindowBackgroundPixmap (GDK_SCREEN_XDISPLAY (screen), RootWindow (GDK_SCREEN_XDISPLAY (screen), number), cairo_xlib_surface_get_drawable (surface)); /* Fix to make the code work when a compositor is running */ Pixmap xpm = cairo_xlib_surface_get_drawable (surface); prop_root = XInternAtom(GDK_SCREEN_XDISPLAY (screen), "_XROOTPMAP_ID", False); prop_esetroot = XInternAtom(GDK_SCREEN_XDISPLAY (screen), "ESETROOT_PMAP_ID", False); XChangeProperty(GDK_SCREEN_XDISPLAY (screen), RootWindow (GDK_SCREEN_XDISPLAY (screen), number), prop_root, XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &xpm, 1); XChangeProperty(GDK_SCREEN_XDISPLAY (screen), RootWindow (GDK_SCREEN_XDISPLAY (screen), number), prop_esetroot, XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &xpm, 1); return surface; }
void set_desktop_background(GdkWindow *window) { Pixmap xpm = get_pixmap_prop(GDK_WINDOW_XWINDOW(window), "_XROOTPMAP_ID"); #ifdef HAVE_GTK3 if (xpm != None) { GdkScreen *screen = gdk_window_get_screen(window); Window root_return; int x, y; unsigned int width, height, bw, depth_ret; cairo_surface_t *surface = NULL; gdk_error_trap_push(); if (XGetGeometry(GDK_SCREEN_XDISPLAY(screen), xpm, &root_return, &x, &y, &width, &height, &bw, &depth_ret)) { surface = cairo_xlib_surface_create(GDK_SCREEN_XDISPLAY (screen), xpm, GDK_VISUAL_XVISUAL(gdk_screen_get_system_visual(screen)), width, height); } gdk_error_trap_pop_ignored (); cairo_pattern_t *pattern = cairo_pattern_create_for_surface(surface); gdk_window_set_background_pattern(window, pattern); cairo_surface_destroy(surface); // cairo_pattern_destroy ??? } else { GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 }; gdk_window_set_background_rgba(window, &black); } #else if (xpm != None) { GDKPIXMAP *gpm = gdk_pixmap_foreign_new(xpm); gdk_window_set_back_pixmap (window, gpm, FALSE); g_object_unref (gpm); } #endif }
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); }
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); }
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); }
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); }
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 }
/* 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); }
/************************************************************* Get display color type of default visual *************************************************************/ enum Display_color_type get_visual(void) { GdkVisual *visual; GdkVisualType type; visual = gdk_screen_get_system_visual(gdk_screen_get_default()); type = gdk_visual_get_visual_type(visual); if (type == GDK_VISUAL_STATIC_GRAY) { /* StaticGray, use black and white */ log_verbose("found B/W display."); return BW_DISPLAY; } if(type < GDK_VISUAL_STATIC_COLOR) { /* No color visual available at default depth */ log_verbose("found grayscale(?) display."); return GRAYSCALE_DISPLAY; } log_verbose("color system booted ok."); return COLOR_DISPLAY; }
static GtkWidget* create_new_window (GtkApplication *application, GVariantDict *options) { dg_lmem gchar* command = NULL; dg_lmem gchar* title = NULL; gboolean opt_show_title; gboolean opt_update_title; gboolean opt_no_headerbar; g_object_get (dwt_settings_get_instance (), "show-title", &opt_show_title, "update-title", &opt_update_title, "no-header-bar", &opt_no_headerbar, "command", &command, "title", &title, NULL); const gchar *opt_command = command; const gchar *opt_title = title; const gchar *opt_workdir = NULL; if (options) { gboolean opt_no_auto_title = FALSE; g_variant_dict_lookup (options, "title-on-maximize", "b", &opt_show_title); g_variant_dict_lookup (options, "no-header-bar", "b", &opt_no_headerbar); g_variant_dict_lookup (options, "no-auto-title", "b", &opt_no_auto_title); g_variant_dict_lookup (options, "workdir", "&s", &opt_workdir); g_variant_dict_lookup (options, "command", "&s", &opt_command); g_variant_dict_lookup (options, "title", "&s", &opt_title); if (opt_no_auto_title) opt_update_title = FALSE; } if (!opt_workdir) opt_workdir = g_get_home_dir (); if (!opt_command) opt_command = guess_shell (); /* * Title either comes from the default value of the "title" setting, * or from the command line flag, but should never be NULL at this * point. */ g_assert (opt_title); dg_lerr GError *gerror = NULL; gint command_argv_len = 0; gchar **command_argv = NULL; if (!g_shell_parse_argv (opt_command, &command_argv_len, &command_argv, &gerror)) { g_printerr ("%s: coult not parse command: %s\n", __func__, gerror->message); return NULL; } GtkWidget *window = gtk_application_window_new (application); gtk_widget_set_visual (window, gdk_screen_get_system_visual (gtk_widget_get_screen (window))); gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (window), FALSE); gtk_window_set_title (GTK_WINDOW (window), opt_title); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), !opt_show_title); g_action_map_add_action_entries (G_ACTION_MAP (window), win_actions, G_N_ELEMENTS (win_actions), window); VteTerminal *vtterm = VTE_TERMINAL (vte_terminal_new ()); configure_term_widget (vtterm, options); term_char_size_changed (vtterm, vte_terminal_get_char_width (vtterm), vte_terminal_get_char_height (vtterm), window); g_signal_connect (G_OBJECT (window), "notify::has-toplevel-focus", G_CALLBACK (window_has_toplevel_focus_notified), vtterm); g_signal_connect (G_OBJECT (vtterm), "char-size-changed", G_CALLBACK (term_char_size_changed), window); g_signal_connect (G_OBJECT (vtterm), "child-exited", G_CALLBACK (term_child_exited), window); g_signal_connect (G_OBJECT (vtterm), "bell", G_CALLBACK (term_beeped), window); g_signal_connect (G_OBJECT (vtterm), "button-release-event", G_CALLBACK (term_mouse_button_released), setup_popover (vtterm)); /* * Propagate title changes to the window. */ if (opt_update_title) g_object_bind_property (G_OBJECT (vtterm), "window-title", G_OBJECT (window), "title", G_BINDING_DEFAULT); if (!opt_no_headerbar) setup_header_bar (window, vtterm, opt_show_title); gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (vtterm)); gtk_widget_set_receives_default (GTK_WIDGET (vtterm), TRUE); /* We need to realize and show the window for it to have a valid XID */ gtk_widget_show_all (window); gchar **command_env = g_get_environ (); #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_SCREEN (gtk_widget_get_screen (window))) { GdkWindow *gdk_window = gtk_widget_get_window (window); if (gdk_window) { gchar window_id[NDIGITS10(unsigned long)]; snprintf (window_id, sizeof (window_id), "%lu", GDK_WINDOW_XID (gdk_window)); command_env = g_environ_setenv (command_env, "WINDOWID", window_id, TRUE); } else { g_printerr ("No window, cannot set $WINDOWID!\n"); } }
/** * gdk_visual_get_system: * * Get the system’s default visual for the default GDK screen. * This is the visual for the root window of the display. * The return value should not be freed. * * Returns: (transfer none): system visual */ GdkVisual* gdk_visual_get_system (void) { return gdk_screen_get_system_visual (gdk_screen_get_default()); }
GtkWidget* gtk_xtbin_new (GtkWidget *parent_widget, String *f) { GtkXtBin *xtbin; gpointer user_data; GdkScreen *screen; GdkVisual* visual; Colormap colormap; GdkWindow* parent_window = gtk_widget_get_window(parent_widget); assert(parent_window != NULL); xtbin = g_object_new (GTK_TYPE_XTBIN, NULL); if (!xtbin) return (GtkWidget*)NULL; if (f) fallback = f; /* Initialize the Xt toolkit */ xtbin->parent_window = parent_window; screen = gtk_widget_get_screen(parent_widget); visual = gdk_screen_get_system_visual(screen); colormap = XCreateColormap(GDK_DISPLAY_XDISPLAY(gdk_screen_get_display(screen)), GDK_WINDOW_XWINDOW(gdk_screen_get_root_window(screen)), GDK_VISUAL_XVISUAL(visual), AllocNone); xt_client_init(&(xtbin->xtclient), GDK_VISUAL_XVISUAL(visual), colormap, gdk_visual_get_depth(visual)); if (!xtbin->xtclient.xtdisplay) { /* If XtOpenDisplay failed, we can't go any further. * Bail out. */ #ifdef DEBUG_XTBIN printf("gtk_xtbin_init: XtOpenDisplay() returned NULL.\n"); #endif g_free (xtbin); return (GtkWidget *)NULL; } /* If this is the first running widget, hook this display into the mainloop */ if (0 == num_widgets) { int cnumber; /* * hook Xt event loop into the glib event loop. */ /* the assumption is that gtk_init has already been called */ GSource* gs = g_source_new(&xt_event_funcs, sizeof(GSource)); if (!gs) { return NULL; } g_source_set_priority(gs, GDK_PRIORITY_EVENTS); g_source_set_can_recurse(gs, TRUE); tag = g_source_attach(gs, (GMainContext*)NULL); #ifdef VMS cnumber = XConnectionNumber(xtdisplay); #else cnumber = ConnectionNumber(xtdisplay); #endif xt_event_poll_fd.fd = cnumber; xt_event_poll_fd.events = G_IO_IN; xt_event_poll_fd.revents = 0; /* hmm... is this correct? */ g_main_context_add_poll ((GMainContext*)NULL, &xt_event_poll_fd, G_PRIORITY_LOW); /* add a timer so that we can poll and process Xt timers */ xt_polling_timer_id = g_timeout_add(25, (GSourceFunc)xt_event_polling_timer_callback, xtdisplay); } /* Bump up our usage count */ num_widgets++; /* Build the hierachy */ xtbin->xtdisplay = xtbin->xtclient.xtdisplay; gtk_widget_set_parent_window(GTK_WIDGET(xtbin), parent_window); gdk_window_get_user_data(xtbin->parent_window, &user_data); if (user_data) gtk_container_add(GTK_CONTAINER(user_data), GTK_WIDGET(xtbin)); return GTK_WIDGET (xtbin); }
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); }
static gboolean xfwmPixmapDrawFromGdkPixbuf (xfwmPixmap * pm, GdkPixbuf *pixbuf) { GdkPixmap *dest_pixmap; GdkPixmap *dest_bitmap; GdkVisual *gvisual; GdkColormap *cmap; gint width, height; gint dest_x, dest_y; gint alpha_threshold; g_return_val_if_fail (pm != NULL, FALSE); g_return_val_if_fail (pm->pixmap != None, FALSE); g_return_val_if_fail (pm->mask != None, FALSE); dest_pixmap = gdk_xid_table_lookup (pm->pixmap); if (dest_pixmap) { g_object_ref (G_OBJECT (dest_pixmap)); } else { dest_pixmap = gdk_pixmap_foreign_new (pm->pixmap); } if (!dest_pixmap) { g_warning ("Cannot get pixmap"); return FALSE; } dest_bitmap = gdk_xid_table_lookup (pm->mask); if (dest_bitmap) { g_object_ref (G_OBJECT (dest_bitmap)); } else { dest_bitmap = gdk_pixmap_foreign_new (pm->mask); } if (!dest_bitmap) { g_warning ("Cannot get bitmap"); g_object_unref (dest_pixmap); return FALSE; } gvisual = gdk_screen_get_system_visual (pm->screen_info->gscr); cmap = gdk_x11_colormap_foreign_new (gvisual, pm->screen_info->cmap); if (!cmap) { g_warning ("Cannot create colormap"); g_object_unref (dest_pixmap); g_object_unref (dest_bitmap); return FALSE; } width = MIN (gdk_pixbuf_get_width (pixbuf), pm->width); height = MIN (gdk_pixbuf_get_height (pixbuf), pm->height); dest_x = (pm->width - width) / 2; dest_y = (pm->height - height) / 2; gdk_drawable_set_colormap (GDK_DRAWABLE (dest_pixmap), cmap); gdk_draw_pixbuf (GDK_DRAWABLE (dest_pixmap), NULL, pixbuf, 0, 0, dest_x, dest_y, width, height, GDK_RGB_DITHER_NONE, 0, 0); alpha_threshold = (gdk_pixbuf_get_has_alpha (pixbuf) ? 0xFF : 0); gdk_pixbuf_render_threshold_alpha (pixbuf, dest_bitmap, 0, 0, dest_x, dest_y, width, height, alpha_threshold); g_object_unref (cmap); g_object_unref (dest_pixmap); g_object_unref (dest_bitmap); return TRUE; }
static void gth_media_viewer_page_real_activate (GthViewerPage *base, GthBrowser *browser) { GthMediaViewerPage *self; gboolean rtl; if (! gstreamer_init ()) return; self = (GthMediaViewerPage*) base; self->priv->browser = browser; g_action_map_add_action_entries (G_ACTION_MAP (browser), actions, G_N_ELEMENTS (actions), browser); self->priv->screenshot_button = gth_browser_add_header_bar_button (browser, GTH_BROWSER_HEADER_SECTION_VIEWER_VIEW, "camera-photo-symbolic", _("Take a screenshot"), "win.video-screenshot", NULL); rtl = gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL; /* video area */ self->priv->area = gtk_drawing_area_new (); /* do not use the rgba visual on the drawing area */ { GdkVisual *visual; visual = gdk_screen_get_system_visual (gtk_widget_get_screen (GTK_WIDGET (self->priv->area))); if (visual != NULL) gtk_widget_set_visual (GTK_WIDGET (self->priv->area), visual); } gtk_widget_set_double_buffered (self->priv->area, FALSE); gtk_widget_add_events (self->priv->area, (gtk_widget_get_events (self->priv->area) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK | GDK_SCROLL_MASK)); gtk_widget_set_can_focus (self->priv->area, TRUE); gtk_widget_show (self->priv->area); g_signal_connect (G_OBJECT (self->priv->area), "realize", G_CALLBACK (video_area_realize_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "unrealize", G_CALLBACK (video_area_unrealize_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "draw", G_CALLBACK (video_area_draw_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "button_press_event", G_CALLBACK (video_area_button_press_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "popup-menu", G_CALLBACK (video_area_popup_menu_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "scroll_event", G_CALLBACK (video_area_scroll_event_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "key_press_event", G_CALLBACK (video_area_key_press_cb), self); /* mediabar */ self->priv->builder = _gtk_builder_new_from_file ("mediabar.ui", "gstreamer_tools"); self->priv->mediabar = GET_WIDGET ("mediabar"); gtk_widget_set_halign (self->priv->mediabar, GTK_ALIGN_FILL); gtk_widget_set_valign (self->priv->mediabar, GTK_ALIGN_END); gtk_image_set_from_icon_name (GTK_IMAGE (GET_WIDGET ("play_slower_image")), rtl ? "media-seek-backward-rtl-symbolic" : "media-seek-backward-symbolic", GTK_ICON_SIZE_MENU); gtk_image_set_from_icon_name (GTK_IMAGE (GET_WIDGET ("play_faster_image")), rtl ? "media-seek-forward-rtl-symbolic" : "media-seek-forward-symbolic", GTK_ICON_SIZE_MENU); g_signal_connect (GET_WIDGET ("volume_adjustment"), "value-changed", G_CALLBACK (volume_value_changed_cb), self); g_signal_connect (GET_WIDGET ("position_adjustment"), "value-changed", G_CALLBACK (position_value_changed_cb), self); g_signal_connect (GET_WIDGET ("play_button"), "clicked", G_CALLBACK (play_button_clicked_cb), self); g_signal_connect (GET_WIDGET ("play_slower_button"), "clicked", G_CALLBACK (play_slower_button_clicked_cb), self); g_signal_connect (GET_WIDGET ("play_faster_button"), "clicked", G_CALLBACK (play_faster_button_clicked_cb), self); self->priv->mediabar_revealer = gtk_revealer_new (); gtk_revealer_set_transition_type (GTK_REVEALER (self->priv->mediabar_revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP); gtk_widget_set_halign (self->priv->mediabar_revealer, GTK_ALIGN_FILL); gtk_widget_set_valign (self->priv->mediabar_revealer, GTK_ALIGN_END); gtk_widget_show (self->priv->mediabar_revealer); gtk_container_add (GTK_CONTAINER (self->priv->mediabar_revealer), self->priv->mediabar); self->priv->area_box = gtk_overlay_new (); gtk_container_add (GTK_CONTAINER (self->priv->area_box), self->priv->area); gtk_overlay_add_overlay (GTK_OVERLAY (self->priv->area_box), self->priv->mediabar_revealer); gtk_widget_show (self->priv->area_box); gth_browser_set_viewer_widget (browser, self->priv->area_box); gtk_widget_realize (self->priv->area); gth_browser_register_viewer_control (self->priv->browser, self->priv->mediabar); gth_viewer_page_focus (GTH_VIEWER_PAGE (self)); }