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