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);
}
