Don't refresh non-dirty screens

[geometrycompositor.git] / source / main.c

diff --git a/source/main.c b/source/main.c
index 15486e61c83f3dfef06c88816d1f4db2ade4985b..6886685605d828f59c05af77b61358d841e6f464 100644 (file)
--- a/source/main.c
+++ b/source/main.c
@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <signal.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/Xcomposite.h>
 #include <X11/extensions/Xdamage.h>
@@ -87,6 +88,8 @@ static const float vertices[] =
        1.0f, 0.0f
 };
 
+int terminate_requested = 0;
+
 int x_error_handler(Display *display, XErrorEvent *event)
 {
        printf("Ignoring X error %d on resource %lx\n", event->error_code, event->resourceid);
@@ -257,24 +260,24 @@ void create_window_pixmap(Compositor *compositor, CompositedScreen *screen, Comp
        window->glx_pixmap = glXCreatePixmap(compositor->display, screen->fbconfig, window->pixmap, attribs);
 }
 
-void add_window(Compositor *compositor, CompositedScreen *screen, Window w)
+CompositedWindow *add_window(Compositor *compositor, CompositedScreen *screen, Window w)
 {
        CompositedWindow *window;
        XWindowAttributes win_attr;
 
        if(w==screen->root || w==screen->overlay)
-               return;
+               return NULL;
 
        if(!XGetWindowAttributes(compositor->display, w, &win_attr))
        {
                printf("XGetWindowAttributes failed; probably the window was already destroyed\n");
-               return;
+               return NULL;
        }
        if(win_attr.class==InputOnly)
-               return;
+               return NULL;
 
        if(find_window(screen, w))
-               return;
+               return NULL;
 
        if(screen->nwindows==screen->windows_capacity)
        {
@@ -305,6 +308,29 @@ void add_window(Compositor *compositor, CompositedScreen *screen, Window w)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+       return window;
+}
+
+void remove_window(Compositor *compositor, CompositedScreen *screen, CompositedWindow *window, int destroyed)
+{
+       unsigned i;
+
+       glDeleteTextures(1, &window->texture);
+       if(!destroyed)
+       {
+               XDamageDestroy(compositor->display, window->damage);
+               if(window->pixmap)
+               {
+                       glXDestroyPixmap(compositor->display, window->glx_pixmap);
+                       XFreePixmap(compositor->display, window->pixmap);
+               }
+               XCompositeUnredirectWindow(compositor->display, window->window, CompositeRedirectManual);
+       }
+
+       --screen->nwindows;
+       for(i=window-screen->windows; i<screen->nwindows; ++i)
+               screen->windows[i] = screen->windows[i+1];
 }
 
 CompositedScreen *find_screen_by_root(Compositor *compositor, Window root)
@@ -439,20 +465,46 @@ int initialize_compositor(Compositor *compositor)
 
 void shutdown_screen(Compositor *compositor, CompositedScreen *screen)
 {
+       unsigned i;
+
+       use_gl(compositor, screen);
+
+       for(i=0; i<screen->nwindows; ++i)
+       {
+               glDeleteTextures(1, &screen->windows[i].texture);
+               if(screen->windows[i].pixmap)
+               {
+                       glXDestroyPixmap(compositor->display, screen->windows[i].glx_pixmap);
+                       XFreePixmap(compositor->display, screen->windows[i].pixmap);
+                       XDamageDestroy(compositor->display, screen->windows[i].damage);
+               }
+       }
+
+       glXMakeContextCurrent(compositor->display, 0, 0, NULL);
        glXDestroyContext(compositor->display, screen->glx_context);
        glXDestroyWindow(compositor->display, screen->glx_window);
        XDestroyWindow(compositor->display, screen->render_window);
 
        XCompositeReleaseOverlayWindow(compositor->display, screen->overlay);
+
+       free(screen->windows);
 }
 
 void shutdown_compositor(Compositor *compositor)
 {
        unsigned i;
 
-       glXMakeContextCurrent(compositor->display, 0, 0, NULL);
        for(i=0; i<compositor->nscreens; ++i)
                shutdown_screen(compositor, &compositor->screens[i]);
+       free(compositor->screens);
+
+       XCloseDisplay(compositor->display);
+}
+
+void mark_dirty(Compositor *compositor, CompositedScreen *screen)
+{
+       compositor->dirty = 1;
+       screen->dirty = 1;
 }
 
 void process_create_window_event(Compositor *compositor, XCreateWindowEvent *event)
@@ -464,7 +516,7 @@ void process_create_window_event(Compositor *compositor, XCreateWindowEvent *eve
        add_window(compositor, screen, event->window);
 }
 
-void process_map_event(Compositor *compositor, XMapEvent *event)
+void process_destroy_window_event(Compositor *compositor, XDestroyWindowEvent *event)
 {
        CompositedScreen *screen = find_screen_by_root(compositor, event->event);
        if(!screen)
@@ -472,10 +524,23 @@ void process_map_event(Compositor *compositor, XMapEvent *event)
 
        CompositedWindow *window = find_window(screen, event->window);
        if(window)
-       {
-               window->map_state = IsViewable;
-               create_window_pixmap(compositor, screen, window);
-       }
+               remove_window(compositor, screen, window, 1);
+}
+
+void process_map_event(Compositor *compositor, XMapEvent *event)
+{
+       CompositedScreen *screen = find_screen_by_root(compositor, event->event);
+       if(!screen)
+               return;
+
+       CompositedWindow *window = find_window(screen, event->window);
+       if(!window)
+               return;
+
+       window->map_state = IsViewable;
+       create_window_pixmap(compositor, screen, window);
+
+       mark_dirty(compositor, screen);
 }
 
 void process_unmap_event(Compositor *compositor, XUnmapEvent *event)
@@ -487,6 +552,30 @@ void process_unmap_event(Compositor *compositor, XUnmapEvent *event)
        CompositedWindow *window = find_window(screen, event->window);
        if(window)
                window->map_state = IsUnviewable;
+
+       mark_dirty(compositor, screen);
+}
+
+void process_reparent_event(Compositor *compositor, XReparentEvent *event)
+{
+       CompositedScreen *screen = find_screen_by_root(compositor, event->event);
+       if(!screen)
+               return;
+
+       CompositedWindow *window;
+       if(event->parent==screen->root)
+               window = add_window(compositor, screen, event->window);
+       else
+       {
+               window = find_window(screen, event->window);
+               if(!window)
+                       return;
+
+               remove_window(compositor, screen, window, 0);
+       }
+
+       if(window && window->map_state==IsViewable)
+               mark_dirty(compositor, screen);
 }
 
 void process_damage_event(Compositor *compositor, XDamageNotifyEvent *event)
@@ -495,8 +584,9 @@ void process_damage_event(Compositor *compositor, XDamageNotifyEvent *event)
        if(!screen)
                return;
 
-       screen->dirty = 1;
-       compositor->dirty = 1;
+       CompositedWindow *window = find_window(screen, event->drawable);
+       if(window->map_state==IsViewable)
+               mark_dirty(compositor, screen);
 }
 
 int process_event(Compositor *compositor)
@@ -515,12 +605,18 @@ int process_event(Compositor *compositor)
        case CreateNotify:
                process_create_window_event(compositor, &event.xcreatewindow);
                break;
+       case DestroyNotify:
+               process_destroy_window_event(compositor, &event.xdestroywindow);
+               break;
        case MapNotify:
                process_map_event(compositor, &event.xmap);
                break;
        case UnmapNotify:
                process_unmap_event(compositor, &event.xunmap);
                break;
+       case ReparentNotify:
+               process_reparent_event(compositor, &event.xreparent);
+               break;
        default:
                if(event.type==compositor->damage_event+XDamageNotify)
                        process_damage_event(compositor, (XDamageNotifyEvent *)&event);
@@ -538,6 +634,9 @@ void refresh_screens(Compositor *compositor)
        for(i=0; i<compositor->nscreens; ++i)
        {
                CompositedScreen *screen = &compositor->screens[i];
+               if(!screen->dirty)
+                       continue;
+
                use_gl(compositor, screen);
 
                glClearColor(0.5f, 0.5f, 0.5f, 0.0f);
@@ -566,14 +665,23 @@ void refresh_screens(Compositor *compositor)
        compositor->dirty = 0;
 }
 
+void sighandler(int sig)
+{
+       terminate_requested = 1;
+       (void)sig;
+}
+
 int main()
 {
        Compositor compositor;
 
+       signal(SIGINT, &sighandler);
+       signal(SIGTERM, &sighandler);
+
        if(!initialize_compositor(&compositor))
                return 1;
 
-       while(1)
+       while(!terminate_requested)
        {
                if(!process_event(&compositor))
                        refresh_screens(&compositor);