dcompmgr.c

   1 #include "screen.h"
   2 #include "window.h"
   3 #include "display.h"
   4 #include "gettext.h"
   5
   6 #include <glib.h>
   7 #include <stdio.h>
   8 #include <sys/select.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <xcb/xcb.h>
  12
  13 typedef struct {
  14     int foo;
  15 } d_options_t;
  16
  17 static void
  18 read_options(int argc, char **argv, d_options_t *opts)
  19 {
  20     opts->foo = argc && argv;
  21 }
  22
  23 static void
  24 event(d_display_t *dpy)
  25 {
  26     xcb_generic_event_t *ev;
  27
  28     ev = xcb_poll_for_event(dpy->conn);
  29     printf("event %d\n", ev->response_type);
  30
  31     if (!ev->response_type) {
  32         display_error(dpy, (xcb_generic_error_t*)ev);
  33         free(ev);
  34         return;
  35     }
  36
  37     switch (ev->response_type) {
  38     case XCB_CREATE_NOTIFY:
  39     {
  40         xcb_create_notify_event_t *cev;
  41         d_screen_t *sc;
  42
  43         cev = (xcb_create_notify_event_t*)ev;
  44         sc = display_screen_from_root(dpy, cev->parent);
  45         if (!sc) break;
  46         screen_add_window(sc, cev->window);
  47         break;
  48     }
  49     case XCB_DESTROY_NOTIFY:
  50     {
  51         xcb_destroy_notify_event_t *dev;
  52         d_screen_t *sc;
  53         d_window_t *w;
  54
  55         dev = (xcb_destroy_notify_event_t*)ev;
  56         sc = display_screen_from_root(dpy, dev->event);
  57         if (!sc) break;
  58         w = screen_find_window(sc, dev->window);
  59         w->hide(w);
  60         screen_remove_window(sc, w);
  61         break;
  62     }
  63     case XCB_REPARENT_NOTIFY:
  64     {
  65         xcb_reparent_notify_event_t *rev;
  66         d_screen_t *sc;
  67         d_window_t *w;
  68
  69         rev = (xcb_reparent_notify_event_t*)ev;
  70         sc = display_screen_from_root(dpy, rev->event);
  71         if (!sc) break;
  72         w = screen_find_window(sc, rev->window);
  73         if (rev->parent == sc->super.root)
  74             screen_add_window(sc, rev->window);
  75         else {
  76             w->hide(w);
  77             screen_remove_window(sc, w);
  78         }
  79         break;
  80     }
  81     case XCB_MAP_NOTIFY:
  82     {
  83         xcb_map_notify_event_t *mev;
  84         d_screen_t *sc;
  85         d_window_t *w;
  86
  87         mev = (xcb_map_notify_event_t*)ev;
  88         sc = display_screen_from_root(dpy, mev->event);
  89         if (!sc) break;
  90         w = screen_find_window(sc, mev->window);
  91         w->show(w);
  92         break;
  93     }
  94     case XCB_UNMAP_NOTIFY:
  95     {
  96         xcb_unmap_notify_event_t *mev;
  97         d_screen_t *sc;
  98         d_window_t *w;
  99
 100         mev = (xcb_unmap_notify_event_t*)ev;
 101         sc = display_screen_from_root(dpy, mev->event);
 102         if (!sc) break;
 103         w = screen_find_window(sc, mev->window);
 104         w->hide(w);
 105         break;
 106     }
 107     default:
 108         break;
 109     }
 110     free(ev);
 111 }
 112
 113 static void
 114 run(d_display_t *dpy)
 115 {
 116     gboolean quit;
 117     fd_set   fds;
 118     int      max = -1;
 119
 120     FD_ZERO(&fds);
 121     FD_SET(dpy->fd, &fds);
 122     max = MAX(max, dpy->fd);
 123
 124     quit = FALSE;
 125     while (!quit) {
 126         int r;
 127
 128         r = select(max+1, &fds, NULL, NULL, NULL);
 129         if (r < 0)
 130             printf("select error\n");
 131         else if (r == 0)
 132             printf("select timeout\n");
 133         else {
 134             printf("select data\n");
 135             /*if (FD_ISSET(dpy->fd, &fds))*/ {
 136                 event(dpy);
 137             }
 138         }
 139
 140         if (xcb_connection_has_error(dpy->conn))
 141             quit = TRUE;
 142     }
 143 }
 144
 145 int
 146 main(int argc, char **argv)
 147 {
 148     d_display_t         *dpy;
 149     d_options_t          opts;
 150
 151     read_options(argc, argv, &opts);
 152
 153     dpy = display_open(NULL);
 154     if (!dpy) {
 155         printf(_("Unable to connect to display\n"));
 156         return 1;
 157     }
 158
 159     if (!dpy->composite.present) {
 160         printf(_("no composite extension present on the display\n"));
 161         display_unref(dpy);
 162         return 1;
 163     }
 164     if (!dpy->xfixes.present) {
 165         printf(_("no xfixes extension present on the display\n"));
 166         display_unref(dpy);
 167         return 1;
 168     }
 169     if (!dpy->damage.present) {
 170         printf(_("no damage extension present on the display\n"));
 171         display_unref(dpy);
 172         return 1;
 173     }
 174     if (!dpy->render.present) {
 175         printf(_("no render extension present on the display\n"));
 176         display_unref(dpy);
 177         return 1;
 178     }
 179     if (dpy->composite.major_version <= 0 && dpy->composite.minor_version < 3)
 180     {
 181         printf(_("composite extension does not support the overlay window"));
 182         display_unref(dpy);
 183         return 1;
 184     }
 185
 186     if (!display_claim_screens(dpy)) {
 187         printf(_("found no screens to run on\n"));
 188         display_unref(dpy);
 189         return 0;
 190     }
 191
 192     run(dpy);
 193
 194     display_unref(dpy);
 195     return 0;
 196 }