void gsd_locate_pointer (GdkScreen *screen) { if (!data) data = gsd_locate_pointer_data_new (screen); gsd_timeline_pause (data->timeline); gsd_timeline_rewind (data->timeline); /* Create again the window if it is not for the current screen */ if (gdk_screen_get_number (screen) != gdk_screen_get_number (gdk_drawable_get_screen (data->window))) { gdk_window_set_user_data (data->window, NULL); gdk_window_destroy (data->window); create_window (data, screen); } data->progress = 0.; g_signal_connect (data->widget, "composited-changed", G_CALLBACK (composited_changed), data); move_locate_pointer_window (data, screen); composited_changed (data->widget, data); gdk_window_show (data->window); gsd_timeline_start (data->timeline); }
GtkWidget* remmina_widget_pool_find(GType type, const gchar *tag) { GtkWidget *widget; gint i; GdkScreen *screen; gint screen_number; guint workspace; screen = gdk_screen_get_default(); screen_number = gdk_screen_get_number(screen); workspace = remmina_public_get_current_workspace(screen); if (remmina_widget_pool == NULL) return NULL; for (i = 0; i < remmina_widget_pool->len; i++) { widget = GTK_WIDGET(g_ptr_array_index(remmina_widget_pool, i)); if (!G_TYPE_CHECK_INSTANCE_TYPE(widget, type)) continue; if (screen_number != gdk_screen_get_number(gtk_window_get_screen(GTK_WINDOW(widget)))) continue; if (workspace != remmina_public_get_window_workspace(GTK_WINDOW(widget))) continue; if (tag && g_strcmp0((const gchar*) g_object_get_data(G_OBJECT(widget), "tag"), tag) != 0) continue; return widget; } return NULL; }
static gboolean is_in_viewport (GtkWindow *window, GdkScreen *screen, gint workspace, gint viewport_x, gint viewport_y) { GdkScreen *s; GdkDisplay *display; GdkWindow *gdkwindow; const gchar *cur_name; const gchar *name; gint cur_n; gint n; gint ws; gint sc_width, sc_height; gint x, y, width, height; gint vp_x, vp_y; /* Check for screen and display match */ display = gdk_screen_get_display (screen); cur_name = gdk_display_get_name (display); cur_n = gdk_screen_get_number (screen); s = gtk_window_get_screen (window); display = gdk_screen_get_display (s); name = gdk_display_get_name (display); n = gdk_screen_get_number (s); if (strcmp (cur_name, name) != 0 || cur_n != n) { return FALSE; } /* Check for workspace match */ ws = gedit_utils_get_window_workspace (window); if (ws != workspace && ws != GEDIT_ALL_WORKSPACES) { return FALSE; } /* Check for viewport match */ gdkwindow = gtk_widget_get_window (GTK_WIDGET (window)); gdk_window_get_position (gdkwindow, &x, &y); width = gdk_window_get_width (gdkwindow); height = gdk_window_get_height (gdkwindow); gedit_utils_get_current_viewport (screen, &vp_x, &vp_y); x += vp_x; y += vp_y; sc_width = gdk_screen_get_width (screen); sc_height = gdk_screen_get_height (screen); return x + width * .25 >= viewport_x && x + width * .75 <= viewport_x + sc_width && y >= viewport_y && y + height <= viewport_y + sc_height; }
// This code can only run after thumbnailer's drawing_area has been realized, // and after the main loop has run so that wnck_window is initialized. static void initialize_thumbnailer_pictures (SSThumbnailer *thumbnailer) { Display *display; GdkScreen *screen; XRenderPictFormat *format; XRenderPictureAttributes pa; display = gdk_x11_get_default_xdisplay (); screen = gtk_widget_get_screen (thumbnailer->drawing_area); format = XRenderFindVisualFormat (display, DefaultVisual ( display, gdk_screen_get_number (screen))); thumbnailer->thumbnail_pixmap = gdk_pixmap_new ( thumbnailer->drawing_area->window, THUMBNAIL_SIZE, THUMBNAIL_SIZE, -1); thumbnailer->thumbnail_picture = XRenderCreatePicture (display, GDK_DRAWABLE_XID (thumbnailer->thumbnail_pixmap), format, 0, NULL); pa.subwindow_mode = IncludeInferiors; thumbnailer->window_picture = XRenderCreatePicture (display, wnck_window_get_xid (thumbnailer->wnck_window), format, CPSubwindowMode, &pa); XRenderSetPictureFilter (display, thumbnailer->window_picture, "good", NULL, 0); }
static void create_stack_for_monitor(NotifyDaemon* daemon, GdkScreen* screen, int monitor_num) { int screen_num = gdk_screen_get_number(screen); NotifyScreen* nscreen = daemon->priv->screens[screen_num]; nscreen->stacks[monitor_num] = notify_stack_new(daemon, screen, monitor_num, daemon->priv->stack_location); }
static gboolean osk_audio_init_canberra(OskAudio* audio) { GdkScreen* screen; ca_proplist* props; const char* name; int nr; if (ca_context_create(&audio->ca) != CA_SUCCESS) return FALSE; screen = gdk_screen_get_default(); nr = gdk_screen_get_number(screen); name = gdk_display_get_name(gdk_screen_get_display(screen)); /* Set default application properties */ ca_proplist_create(&props); ca_proplist_sets(props, CA_PROP_APPLICATION_NAME, "Onboard"); ca_proplist_sets(props, CA_PROP_APPLICATION_ID, "org.onboard.Onboard"); ca_proplist_sets(props, CA_PROP_APPLICATION_ICON_NAME, "onboard"); ca_proplist_sets(props, CA_PROP_WINDOW_X11_DISPLAY, name); ca_proplist_setf(props, CA_PROP_WINDOW_X11_SCREEN, "%i", nr); ca_context_change_props_full(audio->ca, props); ca_proplist_destroy(props); return TRUE; }
static void on_screen_monitors_changed(GdkScreen* screen, NotifyDaemon* daemon) { NotifyScreen* nscreen; int screen_num; int n_monitors; int i; screen_num = gdk_screen_get_number(screen); nscreen = daemon->priv->screens[screen_num]; n_monitors = gdk_screen_get_n_monitors(screen); if (n_monitors > nscreen->n_stacks) { /* grow */ nscreen->stacks = g_renew(NotifyStack *, nscreen->stacks, n_monitors); /* add more stacks */ for (i = nscreen->n_stacks; i < n_monitors; i++) { create_stack_for_monitor(daemon, screen, i); } nscreen->n_stacks = n_monitors; }
static gboolean remmina_main_on_window_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data) { GdkScreen *screen; screen = gdk_screen_get_default(); if (remmina_pref.minimize_to_tray && (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED) != 0 && (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0 && remmina_public_get_current_workspace(screen) == remmina_public_get_window_workspace(GTK_WINDOW(widget)) && gdk_screen_get_number(screen) == gdk_screen_get_number(gtk_widget_get_screen(widget))) { gtk_widget_hide(widget); return TRUE; } return FALSE; }
static void tray_widget_realize(GtkWidget *widget) { struct _tray_widget_icon *widget_icon = TRAY_WIDGET_ICON(widget); if (GTK_WIDGET_CLASS(parent_class)->realize) GTK_WIDGET_CLASS(parent_class)->realize(widget); tray_widget_make_transparent(widget, NULL); int screen_number = gdk_screen_get_number(gtk_widget_get_screen(widget)); Display *display = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(widget)); char *buffer = g_strdup_printf("_NET_SYSTEM_TRAY_S%d", screen_number); widget_icon->selection_atom = XInternAtom(display, buffer, False); widget_icon->manager_atom = XInternAtom(display, "MANAGER", False); widget_icon->system_tray_opcode_atom = XInternAtom(display, "_NET_SYSTEM_TRAY_OPCODE", False); widget_icon->orientation_atom = XInternAtom(display, "_NET_SYSTEM_TRAY_ORIENTATION", False); free(buffer); tray_widget_update_manager_window(widget_icon, FALSE); tray_widget_send_dock_request(widget_icon); GdkWindow *root_window = gdk_screen_get_root_window(gtk_widget_get_screen(widget)); gdk_window_add_filter(root_window, tray_widget_filter, widget_icon); }
static void show_desktop_applet_realized(MatePanelApplet* applet, gpointer data) { ShowDesktopData* sdd; GdkScreen* screen; sdd = (ShowDesktopData*) data; if (sdd->matewnck_screen != NULL) g_signal_handlers_disconnect_by_func(sdd->matewnck_screen, show_desktop_changed_callback, sdd); if (sdd->icon_theme != NULL) g_signal_handlers_disconnect_by_func(sdd->icon_theme, theme_changed_callback, sdd); screen = gtk_widget_get_screen(sdd->applet); sdd->matewnck_screen = matewnck_screen_get(gdk_screen_get_number (screen)); if (sdd->matewnck_screen != NULL) wncklet_connect_while_alive(sdd->matewnck_screen, "showing_desktop_changed", G_CALLBACK(show_desktop_changed_callback), sdd, sdd->applet); else g_warning("Could not get MatewnckScreen!"); show_desktop_changed_callback(sdd->matewnck_screen, sdd); sdd->icon_theme = gtk_icon_theme_get_for_screen (screen); wncklet_connect_while_alive(sdd->icon_theme, "changed", G_CALLBACK(theme_changed_callback), sdd, sdd->applet); update_icon (sdd); }
static void gs_manager_create_windows_for_screen (GSManager *manager, GdkScreen *screen) { int n_monitors; int i; g_return_if_fail (manager != NULL); g_return_if_fail (GS_IS_MANAGER (manager)); g_return_if_fail (GDK_IS_SCREEN (screen)); g_object_ref (manager); g_object_ref (screen); n_monitors = gdk_screen_get_n_monitors (screen); gs_debug ("Creating %d windows for screen %d", n_monitors, gdk_screen_get_number (screen)); for (i = 0; i < n_monitors; i++) { gs_manager_create_window_for_monitor (manager, screen, i); } g_object_unref (screen); g_object_unref (manager); }
static void panel_layout_append_from_file_for_screen (const char *layout_file, GdkScreen *screen) { int screen_n = gdk_screen_get_number (screen); panel_layout_append_from_file_real (layout_file, screen_n); }
static GdkFilterReturn filter_func (GdkXEvent *gdkxevent, GdkEvent *event, gpointer data) { XEvent *xevent = gdkxevent; if (xevent->type == PropertyNotify) { if (xevent->xproperty.atom == _net_client_list_stacking) { int screen_n; GdkWindow *window; window = event->any.window; if (window) { screen_n = gdk_screen_get_number ( gdk_drawable_get_screen (GDK_DRAWABLE (window))); gail_screens [screen_n].update_stacked_windows = TRUE; if (!gail_screens [screen_n].update_handler) { gail_screens [screen_n].update_handler = gdk_threads_add_idle (update_screen_info, GINT_TO_POINTER (screen_n)); } } } else if (xevent->xproperty.atom == _net_wm_desktop) { int i; int j; GailScreenInfo *info; for (i = 0; i < num_screens; i++) { info = &gail_screens [i]; for (j = 0; j < info->stacked_windows_len; j++) { if (xevent->xany.window == info->stacked_windows [j]) { info->desktop_changed [j] = TRUE; if (!info->update_desktop_handler) { info->update_desktop_handler = gdk_threads_add_idle (update_desktop_info, GINT_TO_POINTER (i)); } break; } } } } } return GDK_FILTER_CONTINUE; }
static inline int x11Screen() { #if PLATFORM(QT) return XDefaultScreen(NetscapePlugin::x11HostDisplay()); #elif PLATFORM(GTK) return gdk_screen_get_number(gdk_screen_get_default()); #else return 0; #endif }
static gchar * gdk_x11_screen_make_display_name (GdkScreen *screen) { const gchar *old_display; old_display = gdk_display_get_name (gdk_screen_get_display (screen)); return substitute_screen_number (old_display, gdk_screen_get_number (screen)); }
static inline int x11Screen() { #if PLATFORM(GTK) return gdk_screen_get_number(gdk_screen_get_default()); #elif PLATFORM(EFL) && defined(HAVE_ECORE_X) return ecore_x_screen_index_get(ecore_x_default_screen_get()); #else return 0; #endif }
static void on_screen_monitors_changed (GdkScreen *screen, GSManager *manager) { GSList *l; int n_monitors; int n_windows; int i; n_monitors = gdk_screen_get_n_monitors (screen); n_windows = g_slist_length (manager->priv->windows); gs_debug ("Monitors changed for screen %d: num=%d", gdk_screen_get_number (screen), n_monitors); if (n_monitors > n_windows) { /* add more windows */ for (i = n_windows; i < n_monitors; i++) { gs_manager_create_window_for_monitor (manager, screen, i); } } else { gdk_x11_grab_server (); /* remove the extra windows */ l = manager->priv->windows; while (l != NULL) { GdkScreen *this_screen; int this_monitor; GSList *next = l->next; this_screen = gs_window_get_screen (GS_WINDOW (l->data)); this_monitor = gs_window_get_monitor (GS_WINDOW (l->data)); if (this_screen == screen && this_monitor >= n_monitors) { gs_window_destroy (GS_WINDOW (l->data)); manager->priv->windows = g_slist_delete_link (manager->priv->windows, l); } l = next; } gdk_flush (); gdk_x11_ungrab_server (); } for (l = manager->priv->windows; l != NULL; l = l->next) { GdkScreen *this_screen; this_screen = gs_window_get_screen (GS_WINDOW (l->data)); if (this_screen == screen) { gtk_widget_queue_resize (GTK_WIDGET (l->data)); } } }
void hildon_desktop_ms_is_at_visible_extreme (HildonDesktopMultiscreen *dms, GdkScreen *screen, gint monitor, gboolean *leftmost, gboolean *rightmost, gboolean *topmost, gboolean *bottommost) { g_return_if_fail (dms && HILDON_DESKTOP_IS_MULTISCREEN (dms)); MonitorBounds monitorb; gint n_screen, i; n_screen = gdk_screen_get_number (screen); *leftmost = *rightmost = *topmost = *bottommost = TRUE; g_return_if_fail (n_screen >= 0 && n_screen < dms->screens); g_return_if_fail (monitor >= 0 || monitor < dms->monitors[n_screen]); get_monitor_bounds (dms, n_screen, monitor, &monitorb); /* go through each monitor and try to find one either right, * below, above, or left of the specified monitor */ for (i = 0; i < dms->monitors[n_screen]; i++) { MonitorBounds iter; if (i == monitor) continue; get_monitor_bounds (dms, n_screen, i, &iter); if ((iter.y0 >= monitorb.y0 && iter.y0 < monitorb.y1) || (iter.y1 > monitorb.y0 && iter.y1 <= monitorb.y1)) { if (iter.x0 < monitorb.x0) *leftmost = FALSE; if (iter.x1 > monitorb.x1) *rightmost = FALSE; } if ((iter.x0 >= monitorb.x0 && iter.x0 < monitorb.x1) || (iter.x1 > monitorb.x0 && iter.x1 <= monitorb.x1)) { if (iter.y0 < monitorb.y0) *topmost = FALSE; if (iter.y1 > monitorb.y1) *bottommost = FALSE; } } }
static void egg_tray_icon_realize (GtkWidget *widget) { EggTrayIcon *icon = EGG_TRAY_ICON (widget); gint screen; Display *xdisplay; char buffer[256]; GdkWindow *root_window; if (GTK_WIDGET_CLASS (parent_class)->realize) GTK_WIDGET_CLASS (parent_class)->realize (widget); make_transparent (widget, NULL); xdisplay = egg_tray_icon_get_x_display(icon); if (xdisplay == NULL) return; #if GTK_CHECK_VERSION(2,1,0) screen = gdk_screen_get_number (gtk_widget_get_screen (widget)); #else screen = XScreenNumberOfScreen (DefaultScreenOfDisplay (gdk_display)); #endif /* Now see if there's a manager window around */ g_snprintf (buffer, sizeof (buffer), "_NET_SYSTEM_TRAY_S%d", screen); icon->selection_atom = XInternAtom (xdisplay, buffer, False); icon->manager_atom = XInternAtom (xdisplay, "MANAGER", False); icon->system_tray_opcode_atom = XInternAtom (xdisplay, "_NET_SYSTEM_TRAY_OPCODE", False); icon->orientation_atom = XInternAtom (xdisplay, "_NET_SYSTEM_TRAY_ORIENTATION", False); egg_tray_icon_update_manager_window (icon, FALSE); egg_tray_icon_send_dock_request (icon); #if GTK_CHECK_VERSION(2,1,0) root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget)); #else root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ()); #endif /* Add a root window filter so that we get changes on MANAGER */ gdk_window_add_filter (root_window, egg_tray_icon_manager_filter, icon); }
static MatewnckScreen * matewnck_selector_get_screen (MatewnckSelector *selector) { GdkScreen *screen; g_assert (gtk_widget_has_screen (GTK_WIDGET (selector))); screen = gtk_widget_get_screen (GTK_WIDGET (selector)); return matewnck_screen_get (gdk_screen_get_number (screen)); }
int panel_multiscreen_monitors (GdkScreen *screen) { int n_screen; n_screen = gdk_screen_get_number (screen); g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 1); return monitors [n_screen]; }
static inline int x11Screen() { #if PLATFORM(QT) return XDefaultScreen(NetscapePlugin::x11HostDisplay()); #elif PLATFORM(GTK) return gdk_screen_get_number(gdk_screen_get_default()); #elif PLATFORM(EFL) && defined(HAVE_ECORE_X) return ecore_x_screen_index_get(ecore_x_default_screen_get()); #else return 0; #endif }
static gchar * gdk_x11_screen_make_display_name (GdkScreen *screen) { const gchar *old_display; g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); old_display = gdk_display_get_name (gdk_screen_get_display (screen)); return substitute_screen_number (old_display, gdk_screen_get_number (screen)); }
static gboolean remmina_icon_foreach_window(GtkWidget *widget, gpointer data) { GtkWidget *popup_menu = GTK_WIDGET(data); GtkWidget *menuitem; GdkScreen *screen; gint screen_number; if (G_TYPE_CHECK_INSTANCE_TYPE(widget, REMMINA_TYPE_CONNECTION_WINDOW)) { screen = gdk_screen_get_default(); screen_number = gdk_screen_get_number(screen); if (screen_number == gdk_screen_get_number(gtk_window_get_screen(GTK_WINDOW(widget)))) { menuitem = gtk_menu_item_new_with_label(gtk_window_get_title(GTK_WINDOW(widget))); gtk_widget_show(menuitem); gtk_menu_shell_prepend(GTK_MENU_SHELL(popup_menu), menuitem); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_icon_on_activate_window), widget); return TRUE; } } return FALSE; }
int panel_multiscreen_height (GdkScreen *screen, int monitor) { int n_screen; n_screen = gdk_screen_get_number (screen); g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 0); g_return_val_if_fail (monitor >= 0 && monitor < monitors [n_screen], 0); return geometries [n_screen][monitor].height; }
/* determines whether a given monitor is along the visible * edge of the logical screen. */ void panel_multiscreen_is_at_visible_extreme (GdkScreen *screen, int n_monitor, gboolean *leftmost, gboolean *rightmost, gboolean *topmost, gboolean *bottommost) { MonitorBounds monitor; int n_screen, i; n_screen = gdk_screen_get_number (screen); *leftmost = TRUE; *rightmost = TRUE; *topmost = TRUE; *bottommost = TRUE; g_return_if_fail (n_screen >= 0 && n_screen < screens); g_return_if_fail (n_monitor >= 0 && n_monitor < monitors [n_screen]); get_monitor_bounds (n_screen, n_monitor, &monitor); /* go through each monitor and try to find one either right, * below, above, or left of the specified monitor */ for (i = 0; i < monitors [n_screen]; i++) { MonitorBounds iter; if (i == n_monitor) continue; get_monitor_bounds (n_screen, i, &iter); if ((iter.y0 >= monitor.y0 && iter.y0 < monitor.y1) || (iter.y1 > monitor.y0 && iter.y1 <= monitor.y1)) { if (iter.x0 < monitor.x0) *leftmost = FALSE; if (iter.x1 > monitor.x1) *rightmost = FALSE; } if ((iter.x0 >= monitor.x0 && iter.x0 < monitor.x1) || (iter.x1 > monitor.x0 && iter.x1 <= monitor.x1)) { if (iter.y0 < monitor.y0) *topmost = FALSE; if (iter.y1 > monitor.y1) *bottommost = FALSE; } } }
/* Sort in order of * 1) screen * 2) monitor * 3) top, bottom, left, right * 4) strut_start ascending * 5) strut_end descending */ static int panel_struts_compare (const PanelStrut *s1, const PanelStrut *s2) { if (s1->screen != s2->screen) return gdk_screen_get_number (s1->screen) - gdk_screen_get_number (s2->screen); if (s1->monitor != s2->monitor) return s1->monitor - s2->monitor; if (s1->orientation != s2->orientation) return orientation_to_order (s1->orientation) - orientation_to_order (s2->orientation); if (s1->strut_start != s2->strut_start) return s1->strut_start - s2->strut_start; if (s1->strut_end != s2->strut_end) return s2->strut_end - s1->strut_end; return 0; }
gint hildon_desktop_ms_get_monitors (HildonDesktopMultiscreen *dms, GdkScreen *screen) { gint n_screen; g_return_val_if_fail (dms && HILDON_DESKTOP_IS_MULTISCREEN (dms),0); n_screen = gdk_screen_get_number (screen); g_return_val_if_fail (n_screen >= 0 && n_screen < dms->screens, 1); return dms->monitors[n_screen]; }
gint hildon_desktop_ms_get_height (HildonDesktopMultiscreen *dms, GdkScreen *screen, gint monitor) { g_return_val_if_fail (dms && HILDON_DESKTOP_IS_MULTISCREEN (dms),0); gint n_screen = gdk_screen_get_number (screen); g_return_val_if_fail (n_screen >= 0 && n_screen < dms->screens,0); g_return_val_if_fail (monitor >= 0 || monitor < dms->monitors[n_screen],0); return dms->geometries[n_screen][monitor].height; }
PanelBackgroundMonitor * panel_background_monitor_get_for_screen (GdkScreen *screen) { int screen_number; screen_number = gdk_screen_get_number (screen); if (!global_background_monitors) { int n_screens; n_screens = gdk_display_get_n_screens (gdk_display_get_default ()); global_background_monitors = g_new0 (PanelBackgroundMonitor *, n_screens); }