static void
init_display (GdkDisplay *dpy,
XfceRc *rc,
gboolean disable_tcp)
{
const gchar *engine;
gint n;
xfce_rc_set_group (rc, "Splash Screen");
engine = xfce_rc_read_entry (rc, "Engine", NULL);
splash_screen = xfsm_splash_screen_new (dpy, engine);
xfsm_splash_screen_next (splash_screen, _("Loading desktop settings"));
gdk_flush ();
xfce_rc_set_group (rc, "General");
sm_init (rc, disable_tcp);
/* start a MCS manager process per screen (FIXME: parallel to loading logo) */
for (n = 0; n < gdk_display_get_n_screens (dpy); ++n)
{
mcs_client_check_manager (gdk_x11_display_get_xdisplay (dpy), n,
"xfce-mcs-manager");
}
/* gtk resource files may have changed */
gtk_rc_reparse_all ();
}
static void
mmkeys_init (MmKeys *object)
{
int keycodes[N_KEYCODES];
GdkDisplay *display;
GdkScreen *screen;
GdkWindow *root;
guint i, j;
display = gdk_display_get_default ();
keycodes[0] = XKeysymToKeycode (GDK_DISPLAY (), XF86XK_AudioPrev);
keycodes[1] = XKeysymToKeycode (GDK_DISPLAY (), XF86XK_AudioNext);
keycodes[2] = XKeysymToKeycode (GDK_DISPLAY (), XF86XK_AudioPlay);
keycodes[3] = XKeysymToKeycode (GDK_DISPLAY (), XF86XK_AudioPause);
keycodes[4] = XKeysymToKeycode (GDK_DISPLAY (), XF86XK_AudioStop);
for (i = 0; i < gdk_display_get_n_screens (display); i++) {
screen = gdk_display_get_screen (display, i);
if (screen != NULL) {
root = gdk_screen_get_root_window (screen);
for (j = 0; j < N_KEYCODES; j++) {
if (keycodes[j] > 0)
grab_mmkey (keycodes[j], root);
}
gdk_window_add_filter (root, filter_mmkeys, object);
}
}
}
static void
gs_manager_create_windows (GSManager *manager)
{
GdkDisplay *display;
int n_screens;
int i;
g_return_if_fail (manager != NULL);
g_return_if_fail (GS_IS_MANAGER (manager));
g_assert (manager->priv->windows == NULL);
display = gdk_display_get_default ();
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
g_signal_connect (gdk_display_get_screen (display, i),
"monitors-changed",
G_CALLBACK (on_screen_monitors_changed),
manager);
gs_manager_create_windows_for_screen (manager, gdk_display_get_screen (display, i));
}
}
static void
gs_manager_destroy_windows (GSManager *manager)
{
GdkDisplay *display;
GSList *l;
int n_screens;
int i;
g_return_if_fail (manager != NULL);
g_return_if_fail (GS_IS_MANAGER (manager));
if (manager->priv->windows == NULL) {
return;
}
display = gdk_display_get_default ();
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++) {
g_signal_handlers_disconnect_by_func (gdk_display_get_screen (display, i),
on_screen_monitors_changed,
manager);
}
for (l = manager->priv->windows; l; l = l->next) {
gs_window_destroy (l->data);
}
g_slist_free (manager->priv->windows);
manager->priv->windows = NULL;
}
/* Fills in the screen list based on the current display
*/
static void
fill_screens (ChangeDisplayInfo *info)
{
gtk_list_store_clear (GTK_LIST_STORE (info->screen_model));
if (info->current_display)
{
gint n_screens = gdk_display_get_n_screens (info->current_display);
gint i;
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (info->current_display, i);
GtkTreeIter iter;
gtk_list_store_append (GTK_LIST_STORE (info->screen_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (info->screen_model), &iter,
SCREEN_COLUMN_NUMBER, i,
SCREEN_COLUMN_SCREEN, screen,
-1);
if (i == 0)
gtk_tree_selection_select_iter (info->screen_selection, &iter);
}
}
}
static void
dh_base_init (DhBase *base)
{
DhBasePriv *priv = GET_PRIVATE (base);
IgeConf *conf;
gchar *path;
conf = ige_conf_get ();
path = dh_util_build_data_filename ("devhelp", "devhelp.defaults", NULL);
ige_conf_add_defaults (conf, path);
g_free (path);
priv->book_manager = dh_book_manager_new ();
dh_book_manager_populate (priv->book_manager);
#ifdef GDK_WINDOWING_X11
{
gint n_screens, i;
/* For some reason, libwnck doesn't seem to update its list of
* workspaces etc if we don't do this.
*/
n_screens = gdk_display_get_n_screens (gdk_display_get_default ());
for (i = 0; i < n_screens; i++)
wnck_screen_get (i);
}
#endif
}
void
xfsm_compat_kde_startup (XfsmSplashScreen *splash)
{
gchar command[256];
if (G_UNLIKELY (kde_compat_started))
return;
if (G_LIKELY (splash != NULL))
xfsm_splash_screen_next (splash, _("Starting KDE services"));
run ("kdeinit4");
/* tell klauncher about the session manager */
g_snprintf (command, 256, "qdbus org.kde.klauncher /KLauncher setLaunchEnv "
"SESSION_MANAGER \"%s\"",
g_getenv ("SESSION_MANAGER"));
run (command);
/* tell kde if we are running multi-head */
if (gdk_display_get_n_screens (gdk_display_get_default ()) > 1)
{
g_snprintf (command, 256, "qdbus org.kde.klauncher /KLauncher setLaunchEnv "
"KDE_MULTIHEAD \"true\"");
run (command);
}
kde_compat_started = TRUE;
}
void fm_turn_on_desktop_icons()
{
GdkDisplay * gdpy;
gint i;
int big = 0;
if( ! group )
group = gtk_window_group_new();
theme_change_notify = g_signal_connect( gtk_icon_theme_get_default(), "changed",
G_CALLBACK(on_icon_theme_changed), NULL );
vfs_mime_type_get_icon_size( &big, NULL );
gdpy = gdk_display_get_default();
n_screens = gdk_display_get_n_screens( gdpy );
desktops = g_new( GtkWidget *, n_screens );
for ( i = 0; i < n_screens; i++ )
{
desktops[ i ] = desktop_window_new();
desktop_window_set_icon_size( (DesktopWindow*)desktops[ i ], big );
desktop_window_set_single_click( (DesktopWindow*)desktops[ i ], app_settings.single_click );
gtk_widget_realize( desktops[ i ] ); /* without this, setting wallpaper won't work */
gtk_widget_show_all( desktops[ i ] );
gdk_window_lower( desktops[ i ] ->window );
gtk_window_group_add_window( GTK_WINDOW_GROUP(group), GTK_WINDOW( desktops[i] ) );
}
fm_desktop_update_colors();
fm_desktop_update_wallpaper();
}
int XttHotkey::grab_key( int keysym, int modifier)
{
GdkDisplay *display = gdk_display_get_default();
int n_screens = gdk_display_get_n_screens( display);
Display *dp = gdk_x11_display_get_xdisplay( display);
int mode = GrabModeAsync;
int keycode = XKeysymToKeycode( dp, keysym);
if ( !keycode)
return 0;
gdk_error_trap_push();
for ( int i = 0; i < n_screens; i++) {
GdkWindow *root = gdk_screen_get_root_window( gdk_display_get_screen( display, i));
Window w = gdk_x11_drawable_get_xid( root);
XGrabKey( dp, keycode, modifier, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | LockMask, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | Mod2Mask, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | LockMask | Mod2Mask, w, True, mode, mode);
}
gdk_flush();
gdk_error_trap_pop();
return 1;
}
void
window_actions_update (GimpActionGroup *group,
GtkWidget *window)
{
const gchar *group_name;
gint show_menu = FALSE;
gchar *name;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GTK_IS_WINDOW (window))
{
GdkDisplay *display;
GdkScreen *screen;
gchar *screen_name;
display = gtk_widget_get_display (window);
show_menu = (gdk_display_get_n_screens (display) > 1);
#ifdef GIMP_UNSTABLE
show_menu = TRUE;
#endif
if (! show_menu)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays;
displays = gdk_display_manager_list_displays (manager);
show_menu = (displays->next != NULL);
g_slist_free (displays);
}
screen = gtk_widget_get_screen (window);
screen_name = gdk_screen_make_display_name (screen);
name = g_strdup_printf ("%s-move-to-screen-%s", group_name, screen_name);
g_free (screen_name);
SET_ACTIVE (name, TRUE);
g_free (name);
}
name = g_strdup_printf ("%s-move-to-screen-menu", group_name);
SET_VISIBLE (name, show_menu);
g_free (name);
#undef SET_ACTIVE
#undef SET_VISIBLE
}
static void
init_gail_screens (void)
{
GdkDisplay *display;
display = gdk_display_get_default ();
num_screens = gdk_display_get_n_screens (display);
gail_screens = g_new0 (GailScreenInfo, num_screens);
gdk_window_add_filter (NULL, filter_func, NULL);
g_signal_connect (display, "closed", G_CALLBACK (display_closed), NULL);
}
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);
}
void release_filter()
{
GdkDisplay *display;
int screen;
display = gdk_display_get_default();
for (screen = 0; screen<gdk_display_get_n_screens(display); screen++)
{
gdk_window_remove_filter(gdk_screen_get_root_window(gdk_display_get_screen(display, screen)),
gdk_filter,
NULL);
}
}
static gboolean install_keygrab(const char *accelerator, struct keygrab_data *data)
{
GdkDisplay *display = gdk_display_get_default();
int i;
int xerr;
g_return_val_if_fail(accelerator, FALSE);
g_return_val_if_fail(data, FALSE);
gtk_accelerator_parse(accelerator,
&data->keyval,
&data->modifiers);
if(data->keyval==0) {
fprintf(stderr,
"error: invalid accelerator: '%s'\n",
accelerator);
return FALSE;
}
gdk_error_trap_push();
data->keycode=XKeysymToKeycode(GDK_DISPLAY(), data->keyval);
for (i = 0; i < gdk_display_get_n_screens (display); i++) {
GdkScreen *screen;
GdkWindow *root;
screen = gdk_display_get_screen (display, i);
if (!screen) {
continue;
}
root = gdk_screen_get_root_window (screen);
XGrabKey(GDK_DISPLAY(),
data->keycode,
data->modifiers,
GDK_WINDOW_XID(root),
True,
GrabModeAsync,
GrabModeAsync);
}
gdk_flush();
xerr=gdk_error_trap_pop();
if(xerr!=0) {
return FALSE;
}
printf("ocha: Type %s to open the seach window.\n",
accelerator);
return TRUE;
}
void
hildon_desktop_ms_reinit (HildonDesktopMultiscreen *dms)
{
GdkDisplay *display;
GList *toplevels, *l;
gint new_screens;
gint i;
if (dms->monitors)
g_free (dms->monitors);
if (dms->geometries)
{
gint i;
for (i = 0; i < dms->screens; i++)
g_free (dms->geometries[i]);
g_free (dms->geometries);
}
display = gdk_display_get_default ();
/* Don't use the screens variable since in the future, we might
* want to call this function when a screen appears/disappears. */
#ifndef ONE_SCREEN_MONITOR
new_screens = gdk_display_get_n_screens (display);
#else
new_screens = 1;
#endif
for (i = 0; i < new_screens; i++)
{
GdkScreen *screen;
screen = gdk_display_get_screen (display, i);
g_signal_handlers_disconnect_by_func (screen,
hildon_desktop_ms_reinit,
dms);
}
hildon_desktop_ms_init (dms);
toplevels = gtk_window_list_toplevels ();
for (l = toplevels; l; l = l->next)
gtk_widget_queue_resize (l->data);
g_list_free (toplevels);
}
gboolean setup_filter()
{
GdkDisplay *display;
int screen;
display = gdk_display_get_default();
for (screen = 0; screen<gdk_display_get_n_screens(display); screen++)
{
gdk_window_add_filter(gdk_screen_get_root_window(gdk_display_get_screen(display, screen)),
gdk_filter,
NULL);
}
return TRUE;
}
static void
window_actions_display_closed (GdkDisplay *display,
gboolean is_error,
GimpActionGroup *group)
{
const gchar *group_name;
gint n_screens;
gint i;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
GtkAction *action;
gchar *screen_name;
gchar *action_name;
screen_name = gdk_screen_make_display_name (screen);
action_name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
g_free (screen_name);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
if (action)
{
GSList *radio_group;
radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (action));
if (radio_group->data == (gpointer) action)
radio_group = radio_group->next;
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group",
radio_group);
}
g_free (action_name);
}
}
static MTClosure *
mt_closure_init (void)
{
MTClosure *mt;
gint ev_base, err_base, maj, min;
mt = g_slice_new0 (MTClosure);
mt->xtst_display = XOpenDisplay (NULL);
if (!XTestQueryExtension (mt->xtst_display,
&ev_base, &err_base, &maj, &min)) {
XCloseDisplay (mt->xtst_display);
g_slice_free (MTClosure, mt);
g_critical ("No XTest extension found. Aborting..");
return NULL;
}
mt->client = gconf_client_get_default ();
gconf_client_add_dir (mt->client, MT_GCONF_HOME,
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
g_signal_connect (mt->client, "value_changed",
G_CALLBACK (gconf_value_changed), mt);
mt->delay_timer = mt_timer_new ();
g_signal_connect (mt->delay_timer, "finished",
G_CALLBACK (delay_timer_finished), mt);
g_signal_connect (mt->delay_timer, "tick",
G_CALLBACK (mt_main_timer_tick), mt);
mt->dwell_timer = mt_timer_new ();
g_signal_connect (mt->dwell_timer, "finished",
G_CALLBACK (dwell_timer_finished), mt);
g_signal_connect (mt->dwell_timer, "tick",
G_CALLBACK (mt_main_timer_tick), mt);
mt->service = mt_service_get_default ();
mt_service_set_clicktype (mt->service, DWELL_CLICK_TYPE_SINGLE, NULL);
mt->n_screens = gdk_display_get_n_screens (gdk_display_get_default ());
mt->x_old = -1;
mt->y_old = -1;
return mt;
}
static void
hildon_desktop_ms_init (HildonDesktopMultiscreen *dms)
{
GdkDisplay *display;
gint i;
display = gdk_display_get_default ();
#ifndef ONE_SCREEN_MONITOR
dms->screens = gdk_display_get_n_screens (display);
dms->monitors = g_new0 (gint, dms->screens);
dms->geometries = g_new0 (GdkRectangle *, dms->screens);
#else
dms->screens = 1;
dms->monitors = g_new0(gint,1);
dms->geometries = g_new0(GdkRectangle *,1);
#endif
#ifndef ONE_SCREEN_MONITOR
for (i = 0; i < dms->screens; i++)
{
GdkScreen *screen;
gint j;
screen = gdk_display_get_screen (display, i);
g_signal_connect_swapped (screen, "size-changed",
G_CALLBACK (hildon_desktop_ms_reinit), dms);
dms->monitors [i] = gdk_screen_get_n_monitors (screen);
dms->geometries [i] = g_new0 (GdkRectangle, dms->monitors[i]);
for (j = 0; j < dms->monitors[i]; j++)
gdk_screen_get_monitor_geometry (screen, j, &(dms->geometries [i][j]));
}
#else
GdkScreen *screen = gdk_display_get_default_screen (display);
g_signal_connect_swapped (screen, "size-changed",
G_CALLBACK (hildon_desktop_ms_reinit), dms);
dms->monitors[0] = 1;
dms->geometries[0] = g_new0 (GdkRectangle,1);
gdk_screen_get_monitor_geometry (screen, 1, &geometries [0][0]);
#endif
}
void init_screens()
{
int i;
int num_screens = 1;
#ifndef GDK_VERSION_3_10
num_screens = gdk_display_get_n_screens(gdk_display_get_default());
#endif
for (i=0; i<num_screens; i++) {
WnckScreen *screen = wnck_screen_get(i);
g_signal_connect(screen, "window-opened",
(GCallback)window_opened_cb, NULL);
g_signal_connect(screen, "window-closed",
(GCallback)window_closed_cb, NULL);
}
}
int main (int argc, char** argv) {
GdkScreen *screen;
int monitor;
int i;
GError *error = NULL;
GdkPixbuf *background_pixbuf = NULL;
GdkRectangle monitor_geometry;
cairo_t *c;
cairo_surface_t *surface;
struct stat st;
gtk_init (&argc, &argv);
if (argc != 2 || stat(argv[1], &st) != 0) {
g_error ("First parameter must be an existing background");
return 1;
}
background_pixbuf = gdk_pixbuf_new_from_file (argv[1], &error);
if (!background_pixbuf) {
g_error ("Failed to load background: %s", error->message);
return 1;
}
g_clear_error (&error);
for (i = 0; i < gdk_display_get_n_screens (gdk_display_get_default ()); i++) {
screen = gdk_display_get_screen (gdk_display_get_default (), i);
surface = create_root_surface (screen);
c = cairo_create (surface);
for (monitor = 0; monitor < gdk_screen_get_n_monitors (screen); monitor++) {
gdk_screen_get_monitor_geometry (screen, monitor, &monitor_geometry);
GdkPixbuf *pixbuf = gdk_pixbuf_scale_simple (background_pixbuf,
monitor_geometry.width, monitor_geometry.height,
GDK_INTERP_BILINEAR);
gdk_cairo_set_source_pixbuf (c, pixbuf, monitor_geometry.x, monitor_geometry.y);
g_object_unref (pixbuf);
cairo_paint (c);
}
cairo_destroy (c);
gdk_flush ();
XClearWindow (GDK_SCREEN_XDISPLAY (screen), RootWindow (GDK_SCREEN_XDISPLAY (screen), i));
}
gtk_main ();
return 0;
}
int
main (int argc, char **argv)
{
GdkDisplay *display;
guint n_screens, i;
gtk_init (&argc, &argv);
display = gdk_display_get_default ();
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GtkStatusIcon *icon;
icon = gtk_status_icon_new ();
gtk_status_icon_set_screen (icon, gdk_display_get_screen (display, i));
update_icons ();
g_signal_connect (icon, "size-changed", G_CALLBACK (size_changed_cb), NULL);
g_signal_connect (icon, "notify::embedded", G_CALLBACK (embedded_changed_cb), NULL);
g_signal_connect (icon, "notify::orientation", G_CALLBACK (orientation_changed_cb), NULL);
g_signal_connect (icon, "notify::screen", G_CALLBACK (screen_changed_cb), NULL);
g_print ("icon size %d\n", gtk_status_icon_get_size (icon));
g_signal_connect (icon, "activate",
G_CALLBACK (icon_activated), NULL);
g_signal_connect (icon, "popup-menu",
G_CALLBACK (popup_menu), NULL);
icons = g_slist_append (icons, icon);
update_icons ();
timeout = gdk_threads_add_timeout (2000, timeout_handler, icon);
}
gtk_main ();
return 0;
}
void
panel_multiscreen_reinit (void)
{
GdkDisplay *display;
GList *toplevels, *l;
int new_screens;
int i;
if (monitors)
g_free (monitors);
if (geometries) {
int j;
for (j = 0; j < screens; j++)
g_free (geometries[j]);
g_free (geometries);
}
display = gdk_display_get_default ();
/* Don't use the screens variable since in the future, we might
* want to call this function when a screen appears/disappears. */
new_screens = gdk_display_get_n_screens (display);
for (i = 0; i < new_screens; i++) {
GdkScreen *screen;
screen = gdk_display_get_screen (display, i);
g_signal_handlers_disconnect_by_func (screen,
panel_multiscreen_queue_reinit,
NULL);
}
initialized = FALSE;
panel_multiscreen_init ();
toplevels = gtk_window_list_toplevels ();
for (l = toplevels; l; l = l->next)
gtk_widget_queue_resize (l->data);
g_list_free (toplevels);
}
static void install_keygrab_filters(struct keygrab_data *data)
{
GdkDisplay *display = gdk_display_get_default();
int i;
for (i = 0; i < gdk_display_get_n_screens (display); i++) {
GdkScreen *screen;
GdkWindow *root;
screen = gdk_display_get_screen (display, i);
if (!screen) {
continue;
}
root = gdk_screen_get_root_window (screen);
gdk_window_add_filter(root,
filter_keygrab,
data/*userdata*/);
}
}
static void uninstall_keygrab(void)
{
GdkDisplay *display = gdk_display_get_default();
int i;
for (i = 0; i < gdk_display_get_n_screens (display); i++) {
GdkScreen *screen;
GdkWindow *root;
screen = gdk_display_get_screen (display, i);
if (!screen) {
continue;
}
root = gdk_screen_get_root_window (screen);
XUngrabKey(GDK_DISPLAY(),
AnyKey,
AnyModifier,
GDK_WINDOW_XID(root));
}
}
static void
panel_layout_ensure_toplevel_per_screen (void)
{
GSList *toplevels;
GSList *empty_screens = NULL;
GSList *l;
GdkDisplay *display;
int n_screens, i;
char *default_layout_file;
toplevels = panel_toplevel_list_toplevels ();
display = gdk_display_get_default ();
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++) {
GdkScreen *screen;
screen = gdk_display_get_screen (display, i);
for (l = toplevels; l; l = l->next)
if (gtk_window_get_screen (l->data) == screen)
break;
if (!l)
empty_screens = g_slist_prepend (empty_screens, screen);
}
if (empty_screens == NULL)
return;
default_layout_file = panel_layout_get_default_layout_file ();
for (l = empty_screens; l; l = l->next)
panel_layout_append_from_file_for_screen (default_layout_file,
l->data);
g_free (default_layout_file);
g_slist_free (empty_screens);
}
static void
mmkeys_grab (RBMMKeysPlugin *plugin, gboolean grab)
{
gint keycodes[] = {0, 0, 0, 0, 0};
GdkDisplay *display;
GdkScreen *screen;
GdkWindow *root;
guint i, j;
display = gdk_display_get_default ();
keycodes[0] = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display), XF86XK_AudioPlay);
keycodes[1] = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display), XF86XK_AudioStop);
keycodes[2] = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display), XF86XK_AudioPrev);
keycodes[3] = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display), XF86XK_AudioNext);
keycodes[4] = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display), XF86XK_AudioPause);
for (i = 0; i < gdk_display_get_n_screens (display); i++) {
screen = gdk_display_get_screen (display, i);
if (screen != NULL) {
root = gdk_screen_get_root_window (screen);
for (j = 0; j < G_N_ELEMENTS (keycodes) ; j++) {
if (keycodes[j] != 0) {
if (grab)
grab_mmkey (keycodes[j], root);
else
ungrab_mmkey (keycodes[j], root);
}
}
if (grab)
gdk_window_add_filter (root, filter_mmkeys,
(gpointer) plugin->shell_player);
else
gdk_window_remove_filter (root, filter_mmkeys,
(gpointer) plugin->shell_player);
}
}
}
static void
nemo_application_create_desktop_windows (NemoApplication *application)
{
GdkDisplay *display;
NemoDesktopWindow *window;
GtkWidget *selection_widget;
int screens, i;
display = gdk_display_get_default ();
screens = gdk_display_get_n_screens (display);
for (i = 0; i < screens; i++) {
DEBUG ("Creating a desktop window for screen %d", i);
selection_widget = get_desktop_manager_selection (display, i);
if (selection_widget != NULL) {
window = nemo_desktop_window_new (gdk_display_get_screen (display, i));
g_signal_connect (selection_widget, "selection_clear_event",
G_CALLBACK (selection_clear_event_cb), window);
g_signal_connect (window, "unrealize",
G_CALLBACK (desktop_unrealize_cb), selection_widget);
/* We realize it immediately so that the NEMO_DESKTOP_WINDOW_ID
property is set so gnome-settings-daemon doesn't try to set the
background. And we do a gdk_flush() to be sure X gets it. */
gtk_widget_realize (GTK_WIDGET (window));
gdk_flush ();
nemo_application_desktop_windows =
g_list_prepend (nemo_application_desktop_windows, window);
gtk_application_add_window (GTK_APPLICATION (application),
GTK_WINDOW (window));
}
}
}
void
panel_multiscreen_init (void)
{
GdkDisplay *display;
int i;
if (initialized)
return;
display = gdk_display_get_default ();
screens = gdk_display_get_n_screens (display);
panel_multiscreen_init_randr (display);
monitors = g_new0 (int, screens);
geometries = g_new0 (GdkRectangle *, screens);
for (i = 0; i < screens; i++) {
GdkScreen *screen;
screen = gdk_display_get_screen (display, i);
/* We connect to both signals to be on the safe side, but in
* theory, it should be enough to only connect to
* monitors-changed. Since we'll likely get two signals, we do
* the real callback in the idle loop. */
g_signal_connect (screen, "size-changed",
G_CALLBACK (panel_multiscreen_queue_reinit), NULL);
g_signal_connect (screen, "monitors-changed",
G_CALLBACK (panel_multiscreen_queue_reinit), NULL);
panel_multiscreen_get_monitors_for_screen (screen,
&(monitors[i]),
&(geometries[i]));
}
initialized = TRUE;
}
int
main (int argc, char *argv[])
{
GdkDisplay *display;
GdkScreen *screen;
int n_screens, i;
gtk_init (&argc, &argv);
gtk_window_set_default_icon_name (NOTIFICATION_AREA_ICON);
display = gdk_display_get_default ();
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; ++i) {
screen = gdk_display_get_screen (display, i);
create_tray_on_screen (screen, FALSE);
}
gtk_main ();
return 0;
}
