int foo;
} d_options_t;
-static gint
-all_screens(d_display_t *dpy, d_screen_t **list)
-{
- static const xcb_setup_t *setup;
- xcb_screen_iterator_t it;
- int count, i;
- d_screen_t sc;
-
- setup = xcb_get_setup(dpy->conn);
-
- count = i = 0;
- for (it = xcb_setup_roots_iterator(setup); it.rem; xcb_screen_next(&it)) {
- sc.super = *it.data;
- sc.dpy = dpy;
- sc.num = i++;
- if (screen_register(&sc)) {
- ++count;
- *list = realloc(*list, sizeof(d_screen_t)*count);
- (*list)[count-1] = sc;
- printf(_("managing screen %d\n"), sc.num);
- }
- }
- return count;
-}
-
-static d_screen_t*
-screen_from_root(d_screen_t *list, int n, xcb_window_t root)
-{
- int i;
- for (i = 0; i < n; ++i)
- if (list->super.root == root) return &list[i];
- g_assert_not_reached();
- return NULL;
-}
-
static
void read_options(int argc, char **argv, d_options_t *opts)
{
main(int argc, char **argv)
{
d_display_t *dpy;
- d_screen_t *screens = NULL;
- int nscreens;
xcb_generic_event_t *ev;
d_options_t opts;
return 1;
}
- nscreens = all_screens(dpy, &screens);
- if (nscreens < 1) {
+ if (!display_claim_screens(dpy)) {
printf(_("found no screens to run on\n"));
display_unref(dpy);
return 0;
d_screen_t *sc;
cev = (xcb_create_notify_event_t*)ev;
- sc = screen_from_root(screens, nscreens, cev->parent);
+ sc = display_screen_from_root(dpy, cev->parent);
if (!sc) break;
screen_add_window(sc, cev->window);
break;
d_window_t *w;
dev = (xcb_destroy_notify_event_t*)ev;
- sc = screen_from_root(screens, nscreens, dev->event);
+ sc = display_screen_from_root(dpy, dev->event);
if (!sc) break;
w = screen_find_window(sc, dev->window);
w->hide(w);
d_window_t *w;
rev = (xcb_reparent_notify_event_t*)ev;
- sc = screen_from_root(screens, nscreens, rev->event);
+ sc = display_screen_from_root(dpy, rev->event);
if (!sc) break;
w = screen_find_window(sc, rev->window);
if (rev->parent == sc->super.root)
d_window_t *w;
mev = (xcb_map_notify_event_t*)ev;
- sc = screen_from_root(screens, nscreens, mev->event);
+ sc = display_screen_from_root(dpy, mev->event);
if (!sc) break;
w = screen_find_window(sc, mev->window);
window_show(w);
d_window_t *w;
mev = (xcb_unmap_notify_event_t*)ev;
- sc = screen_from_root(screens, nscreens, mev->event);
+ sc = display_screen_from_root(dpy, mev->event);
if (!sc) break;
w = screen_find_window(sc, mev->window);
window_hide(w);
#include "display.h"
+#include "screen.h"
+#include "gettext.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
dpy = malloc(sizeof(d_display_t));
dpy->conn = conn;
dpy->ref = 1;
+ dpy->screens = NULL;
+ dpy->nscreens = 0;
query_statics(dpy);
}
{
if (dpy && --dpy->ref == 0) {
xcb_disconnect(dpy->conn);
+ free(dpy->screens);
free(dpy);
}
}
abort();
}
+
+int
+display_claim_screens(d_display_t *dpy)
+{
+ static const xcb_setup_t *setup;
+ xcb_screen_iterator_t it;
+ int i;
+ d_screen_t sc;
+
+ setup = xcb_get_setup(dpy->conn);
+
+ i = 0;
+ for (it = xcb_setup_roots_iterator(setup); it.rem; xcb_screen_next(&it)) {
+ sc.super = *it.data;
+ sc.dpy = dpy;
+ sc.num = i++;
+ if (screen_register(dpy, i, &sc)) {
+ ++dpy->nscreens;
+ dpy->screens = realloc(dpy->screens,
+ sizeof(d_screen_t)*dpy->nscreens);
+ dpy->screens[dpy->nscreens-1] = sc;
+ printf(_("managing screen %d\n"), sc.num);
+ }
+ }
+ return dpy->nscreens;
+}
+
+d_screen_t*
+display_screen_from_root(d_display_t *dpy, xcb_window_t root)
+{
+ int i;
+ for (i = 0; i < dpy->nscreens; ++i)
+ if (dpy->screens[i].super.root == root) return &dpy->screens[i];
+ g_assert_not_reached();
+ return NULL;
+}
+
/*! Tries to register on the screen given by @sc. If it succeeds, it fills
in @sc and returns TRUE, otherwise it returns FALSE.
*/
-gboolean screen_register(d_screen_t *sc);
+gboolean screen_register(struct d_display *dpy, int num, d_screen_t *sc);
void screen_add_window(d_screen_t *sc, xcb_window_t wid);
void screen_remove_window(d_screen_t *sc, struct d_window *w);