+#include "efence.h"
+
#include "screen.h"
#include "window.h"
+#include "list.h"
#include "display.h"
#include "gettext.h"
+#include "time.h"
+#include "render.h"
#include <glib.h>
#include <stdio.h>
#include <sys/select.h>
#include <stdlib.h>
#include <string.h>
+#include <signal.h>
#include <xcb/xcb.h>
+#include <xcb/damage.h>
typedef struct {
int foo;
} d_options_t;
+static gboolean quit = FALSE;
+
static void
read_options(int argc, char **argv, d_options_t *opts)
{
}
static void
+signal_quit_handler(int sig)
+{
+ printf("caught signal %d, quitting\n", sig);
+ quit = TRUE;
+}
+
+static void
event(d_display_t *dpy)
{
xcb_generic_event_t *ev;
- ev = xcb_poll_for_event(dpy->conn);
- printf("event %d\n", ev->response_type);
+ while ((ev = xcb_poll_for_event(dpy->conn)) && !quit) {
+ //printf("event %d\n", ev->response_type);
- if (!ev->response_type) {
- display_error(dpy, (xcb_generic_error_t*)ev);
- free(ev);
- return;
- }
+ if (!ev->response_type) {
+ display_error(dpy, (xcb_generic_error_t*)ev);
+ free(ev);
+ continue;
+ }
- switch (ev->response_type) {
- case XCB_CREATE_NOTIFY:
- {
- xcb_create_notify_event_t *cev;
- d_screen_t *sc;
-
- cev = (xcb_create_notify_event_t*)ev;
- sc = display_screen_from_root(dpy, cev->parent);
- if (!sc) break;
- screen_add_window(sc, cev->window);
- break;
- }
- case XCB_DESTROY_NOTIFY:
- {
- xcb_destroy_notify_event_t *dev;
- d_screen_t *sc;
- d_window_t *w;
-
- dev = (xcb_destroy_notify_event_t*)ev;
- sc = display_screen_from_root(dpy, dev->event);
- if (!sc) break;
- w = screen_find_window(sc, dev->window);
- w->hide(w);
- screen_remove_window(sc, w);
- break;
- }
- case XCB_REPARENT_NOTIFY:
- {
- xcb_reparent_notify_event_t *rev;
- d_screen_t *sc;
- d_window_t *w;
-
- rev = (xcb_reparent_notify_event_t*)ev;
- sc = display_screen_from_root(dpy, rev->event);
- if (!sc) break;
- w = screen_find_window(sc, rev->window);
- if (rev->parent == sc->super.root)
- screen_add_window(sc, rev->window);
- else {
- w->hide(w);
+ switch (ev->response_type) {
+ case XCB_CREATE_NOTIFY:
+ {
+ xcb_create_notify_event_t *cev;
+ d_screen_t *sc;
+ d_window_t *w;
+
+ cev = (xcb_create_notify_event_t*)ev;
+ sc = display_screen_from_root(dpy, cev->parent);
+ if (!sc) break;
+ w = screen_add_window(sc, cev->window);
+ break;
+ }
+ case XCB_DESTROY_NOTIFY:
+ {
+ xcb_destroy_notify_event_t *dev;
+ d_screen_t *sc;
+ d_window_t *w;
+ gboolean vis;
+
+ dev = (xcb_destroy_notify_event_t*)ev;
+ sc = display_screen_from_root(dpy, dev->event);
+ if (!sc) break;
+ w = screen_find_window(sc, dev->window);
+ vis = window_is_mapped(w);
+ if (vis)
+ sc->window_hide(w);
screen_remove_window(sc, w);
+ if (vis) screen_refresh(sc);
+ break;
}
- break;
- }
- case XCB_MAP_NOTIFY:
- {
- xcb_map_notify_event_t *mev;
- d_screen_t *sc;
- d_window_t *w;
-
- mev = (xcb_map_notify_event_t*)ev;
- sc = display_screen_from_root(dpy, mev->event);
- if (!sc) break;
- w = screen_find_window(sc, mev->window);
- w->show(w);
- break;
- }
- case XCB_UNMAP_NOTIFY:
- {
- xcb_unmap_notify_event_t *mev;
- d_screen_t *sc;
- d_window_t *w;
-
- mev = (xcb_unmap_notify_event_t*)ev;
- sc = display_screen_from_root(dpy, mev->event);
- if (!sc) break;
- w = screen_find_window(sc, mev->window);
- w->hide(w);
- break;
- }
- default:
- break;
+ case XCB_REPARENT_NOTIFY:
+ {
+ xcb_reparent_notify_event_t *rev;
+ d_screen_t *sc;
+ d_window_t *w;
+
+ rev = (xcb_reparent_notify_event_t*)ev;
+ sc = display_screen_from_root(dpy, rev->event);
+ if (!sc) break;
+ w = screen_find_window(sc, rev->window);
+ if (rev->parent == sc->super.root)
+ screen_add_window(sc, rev->window);
+ else {
+ if (window_is_mapped(w))
+ sc->window_hide(w);
+ screen_remove_window(sc, w);
+ }
+ screen_refresh(sc);
+ break;
+ }
+ case XCB_MAP_NOTIFY:
+ {
+ xcb_map_notify_event_t *mev;
+ d_screen_t *sc;
+ d_window_t *w;
+
+ mev = (xcb_map_notify_event_t*)ev;
+ sc = display_screen_from_root(dpy, mev->event);
+ if (!sc) break;
+ w = screen_find_window(sc, mev->window);
+ sc->window_show(w);
+ screen_refresh(w->sc);
+ break;
+ }
+ case XCB_UNMAP_NOTIFY:
+ {
+ xcb_unmap_notify_event_t *mev;
+ d_screen_t *sc;
+ d_window_t *w;
+
+ mev = (xcb_unmap_notify_event_t*)ev;
+ sc = display_screen_from_root(dpy, mev->event);
+ if (!sc) break;
+ w = screen_find_window(sc, mev->window);
+ sc->window_hide(w);
+ screen_refresh(w->sc);
+ break;
+ }
+ case XCB_CONFIGURE_NOTIFY:
+ {
+ xcb_configure_notify_event_t *cev;
+ d_screen_t *sc;
+ d_window_t *w, *above;
+ int x, y, width, height, bwidth;
+
+ cev = (xcb_configure_notify_event_t*)ev;
+ sc = display_screen_from_root(dpy, cev->event);
+ if (!sc) break;
+ //printf("configure 0x%x", cev->window);
+ w = screen_find_window(sc, cev->window);
+ window_get_area(w, &x, &y, &width, &height, &bwidth);
+ if (x != cev->x || y != cev->y || width != cev->width ||
+ height != cev->height || bwidth != cev->border_width)
+ {
+ window_configure(w, cev->x, cev->y,
+ cev->width, cev->height,
+ cev->border_width);
+ if (window_is_mapped(w)) {
+ if (x != cev->x || y != cev->y)
+ sc->window_move(w);
+ if (width != cev->width ||
+ height != cev->height || bwidth != cev->border_width)
+ sc->window_resize(w);
+ }
+ }
+ above = screen_find_window(sc, cev->above_sibling);
+ screen_stacking_move_above(sc, w, above);
+ screen_refresh(w->sc);
+ break;
+ }
+ default:
+ if (ev->response_type - dpy->damage.event == XCB_DAMAGE_NOTIFY) {
+ xcb_damage_notify_event_t *dev;
+ d_list_it_t *it;
+
+ dev = (xcb_damage_notify_event_t*)ev;
+ for (it = list_top(dpy->screens); it; it = it->next) {
+ d_screen_t *sc = it->data;
+ d_window_t *w;
+
+ w = screen_find_window(sc, dev->drawable);
+ if (w) {
+ screen_refresh(w->sc);
+ break;
+ }
+ }
+ xcb_damage_subtract(dpy->conn, dev->damage,
+ XCB_NONE, XCB_NONE);
+ }
+ break;
+ }
+ free(ev);
+ xcb_flush(dpy->conn);
}
- free(ev);
}
static void
paint(d_display_t *dpy)
{
- int i;
+ d_list_it_t *it;
+ struct timeval now;
- for (i = 0; i < dpy->nscreens; ++i) {
- d_screen_t *sc = display_screen_n(dpy, i);
+ gettimeofday(&now, NULL);
+
+ for (it = list_top(dpy->screens); it; it = it->next) {
+ d_screen_t *sc = it->data;
- sc->paint(sc);
+ if (time_compare(&sc->next_repaint, &now) <= 0)
+ sc->screen_paint(sc);
}
}
static void
run(d_display_t *dpy)
{
- gboolean quit;
- fd_set fds;
- int max = -1;
+ while (!quit) {
+ struct timeval next, now, *wait;
+ int r, npaint;
+ d_list_it_t *it;
+ fd_set fds;
- FD_ZERO(&fds);
- FD_SET(dpy->fd, &fds);
- max = MAX(max, dpy->fd);
+ event(dpy);
- paint(dpy);
+ npaint = 0;
+ for (it = list_top(dpy->screens); it; it = it->next) {
+ d_screen_t *sc = it->data;
+ if (sc->need_repaint &&
+ (!npaint || time_compare(&sc->next_repaint, &next) < 0))
+ {
+ next = sc->next_repaint;
+ ++npaint;
+ }
+ }
- quit = FALSE;
- while (!quit) {
- int r;
+ gettimeofday(&now, 0);
- r = select(max+1, &fds, NULL, NULL, NULL);
- if (r < 0)
- printf("select error\n");
- else if (r == 0)
- printf("select timeout\n");
+ if (!npaint)
+ /* wait forever, there is nothing that needs drawing */
+ wait = NULL;
+ else if (time_compare(&next, &now) > 0) {
+ /* wait until the next allowed redraw time */
+ time_difference(&next, &now, &next);
+ wait = &next;
+ }
else {
- printf("select data\n");
- /*if (FD_ISSET(dpy->fd, &fds))*/ {
- event(dpy);
- paint(dpy);
- }
+ /* don't wait cuz a redraw is due now already */
+ next.tv_sec = 0;
+ next.tv_usec = 100;
+ wait = &next;
+ }
+
+ FD_ZERO(&fds);
+ FD_SET(dpy->fd, &fds);
+
+ //printf("select %d\n", npaint);
+
+ r = select(dpy->fd+1, &fds, NULL, NULL, wait);
+ if (r == 0) {
+ //printf("select timeout\n");
+ paint(dpy);
+ xcb_flush(dpy->conn);
}
if (xcb_connection_has_error(dpy->conn))
}
}
+static void
+setup_functions(d_display_t *dpy)
+{
+ d_list_it_t *it;
+
+ for (it = list_top(dpy->screens); it; it = it->next) {
+ d_screen_t *sc = it->data;
+ int id;
+ screen_setup_default_functions(sc);
+
+ /* these can be plugins.. */
+ id = 1;
+ render_init(sc, id++);
+ }
+}
+
+static void
+cleanup_functions(d_display_t *dpy)
+{
+ d_list_it_t *it;
+
+ for (it = list_top(dpy->screens); it; it = it->next) {
+ d_screen_t *sc = it->data;
+
+ /* these can be plugins.. */
+ render_free(sc);
+ }
+}
+
int
main(int argc, char **argv)
{
return 0;
}
+ signal(SIGINT, signal_quit_handler);
+ signal(SIGHUP, signal_quit_handler);
+ signal(SIGTERM, signal_quit_handler);
+ signal(SIGQUIT, signal_quit_handler);
+
+ setup_functions(dpy);
+
+ {
+ /* some of the windows may already be visible */
+ d_list_it_t *sc_it;
+
+ for (sc_it = list_top(dpy->screens); sc_it; sc_it = sc_it->next) {
+ d_screen_t *sc = sc_it->data;
+ d_list_it_t *it;
+ for (it = list_bottom(sc->stacking); it; it = it->prev)
+ if (window_is_mapped(it->data)) {
+ /* make the window think it is unmapped so that the
+ show works right */
+ window_fake_unmapped(it->data);
+ sc->window_show(it->data);
+ }
+ }
+ }
+
run(dpy);
+ {
+ /* make everything hidden */
+ d_list_it_t *sc_it;
+
+ for (sc_it = list_top(dpy->screens); sc_it; sc_it = sc_it->next) {
+ d_screen_t *sc = sc_it->data;
+ d_list_it_t *it;
+ for (it = list_top(sc->stacking); it; it = it->next) {
+ if (window_is_mapped(it->data))
+ sc->window_hide(it->data);
+ }
+ }
+ }
+
+ cleanup_functions(dpy);
+
display_unref(dpy);
return 0;
}