Implement a control interface using properties on the root window

[geometrycompositor.git] / source / main.c

diff --git a/source/main.c b/source/main.c
index 92537e21a59bf3c01dee00ec66e94bb75109cde1..1aee407328a73fe924cd49626662a0fe6c60eaa9 100644 (file)
--- a/source/main.c
+++ b/source/main.c
@@ -5,6 +5,7 @@
 #include <signal.h>
 #include <math.h>
 #include <X11/Xlib.h>
+#include <X11/Xatom.h>
 #include <X11/extensions/Xcomposite.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/shape.h>
@@ -29,6 +30,7 @@ typedef struct CompositedWindow
 
 typedef struct CompositedMonitor
 {
+       char *name;
        int enabled;
        int x;
        int y;
@@ -80,6 +82,8 @@ typedef struct Compositor
        PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB;
        PFNGLXBINDTEXIMAGEEXTPROC glXBindTexImageEXT;
        PFNGLXRELEASETEXIMAGEEXTPROC glXReleaseTexImageEXT;
+       Atom correction_atom;
+       Atom monitors_atom;
        int dirty;
 } Compositor;
 
@@ -533,6 +537,7 @@ int initialize_monitor(Compositor *compositor, CompositedScreen *screen, XRRScre
 {
        CompositedMonitor *monitor;
        XRROutputInfo *output;
+       int namelen;
        XRRCrtcInfo *crtc;
        unsigned buffers[2];
        unsigned stride;
@@ -540,6 +545,9 @@ int initialize_monitor(Compositor *compositor, CompositedScreen *screen, XRRScre
        monitor = &screen->monitors[index];
 
        output = XRRGetOutputInfo(compositor->display, xrr_res, xrr_res->outputs[index]);
+       namelen = strlen(output->name);
+       monitor->name = (char *)malloc(namelen+1);
+       strcpy(monitor->name, output->name);
        monitor->enabled = !!output->crtc;
        if(!monitor->enabled)
        {
@@ -582,6 +590,70 @@ int initialize_monitor(Compositor *compositor, CompositedScreen *screen, XRRScre
        return 1;
 }
 
+CompositedMonitor *find_monitor_by_name(CompositedScreen *screen, char *name)
+{
+       unsigned i;
+
+       for(i=0; i<screen->nmonitors; ++i)
+               if(!strcmp(screen->monitors[i].name, name))
+                       return &screen->monitors[i];
+
+       return NULL;
+}
+
+void update_geometry_correction(Compositor *compositor, CompositedScreen *screen)
+{
+       Atom prop_type;
+       int prop_format;
+       unsigned long overflow;
+       unsigned long names_length;
+       char *names;
+       unsigned long values_length;
+       short *values;
+       char *name_ptr;
+       unsigned i;
+
+       XGetWindowProperty(compositor->display, screen->root, compositor->monitors_atom, 0, 64, False, XA_STRING,
+               &prop_type, &prop_format, &names_length, &overflow, (unsigned char **)&names);
+       if(prop_type!=XA_STRING || prop_format!=8)
+               return;
+
+       XGetWindowProperty(compositor->display, screen->root, compositor->correction_atom, 0, 64, False, XA_INTEGER,
+               &prop_type, &prop_format, &values_length, &overflow, (unsigned char **)&values);
+       if(prop_type!=XA_INTEGER || prop_format!=16)
+       {
+               XFree(names);
+               return;
+       }
+
+       use_gl(compositor, screen);
+
+       name_ptr = names;
+       for(i=0; i*4<values_length; ++i)
+       {
+               CompositedMonitor *monitor;
+
+               if(name_ptr>=names+names_length)
+                       break;
+
+               monitor = find_monitor_by_name(screen, name_ptr);
+               if(monitor)
+               {
+                       monitor->keystone_vertical = values[i*4]/10000.0f;
+                       monitor->cylinder_depth = values[i*4+1]/10000.0f;
+                       monitor->vertical_center = values[i*4+2]/10000.0f;
+                       monitor->perspective = values[i*4+3]/10000.0f;
+
+                       update_monitor_vertices(screen, monitor);
+               }
+
+               name_ptr += strlen(name_ptr)+1;
+       }
+
+       XFree(names);
+       XFree(values);
+}
+
 int initialize_screen(Compositor *compositor, unsigned number)
 {
        CompositedScreen *screen;
@@ -606,7 +678,7 @@ int initialize_screen(Compositor *compositor, unsigned number)
                return with_error("GLX_EXT_texture_from_pixmap is required");
 
        screen->root = RootWindow(compositor->display, screen->number);
-       XSelectInput(compositor->display, screen->root, SubstructureNotifyMask);
+       XSelectInput(compositor->display, screen->root, SubstructureNotifyMask|PropertyChangeMask);
        screen->overlay = XCompositeGetOverlayWindow(compositor->display, screen->root);
        XGetGeometry(compositor->display, screen->overlay, &dummy_root, &x, &y, &screen->width, &screen->height, &border, &depth);
        XShapeCombineRectangles(compositor->display, screen->overlay, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted);
@@ -625,6 +697,8 @@ int initialize_screen(Compositor *compositor, unsigned number)
                        return 0;
        XRRFreeScreenResources(xrr_res);
 
+       update_geometry_correction(compositor, screen);
+
        XQueryTree(compositor->display, screen->root, &dummy_root, &dummy_parent, &children, &nchildren);
 
        screen->windows = (CompositedWindow *)malloc(nchildren*sizeof(CompositedWindow));
@@ -694,6 +768,9 @@ int initialize_compositor(Compositor *compositor)
        compositor->glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress((unsigned char *)"glXBindTexImageEXT");
        compositor->glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress((unsigned char *)"glXReleaseTexImageEXT");
 
+       compositor->correction_atom = XInternAtom(compositor->display, "GEOMETRY_CORRECTION", False);
+       compositor->monitors_atom = XInternAtom(compositor->display, "GEOMETRY_CORRECTION_MONITORS", False);
+
        compositor->nscreens = ScreenCount(compositor->display);
        compositor->screens = (CompositedScreen *)malloc(compositor->nscreens*sizeof(CompositedScreen));
        for(i=0; i<compositor->nscreens; ++i)
@@ -723,12 +800,15 @@ void shutdown_screen(Compositor *compositor, CompositedScreen *screen)
        }
 
        for(i=0; i<screen->nmonitors; ++i)
+       {
+               free(screen->monitors[i].name);
                if(screen->monitors[i].enabled)
                {
                        glDeleteBuffers(1, &screen->monitors[i].vertex_buffer);
                        glDeleteBuffers(1, &screen->monitors[i].index_buffer);
                        glDeleteVertexArrays(1, &screen->monitors[i].vertex_array);
                }
+       }
 
        glDeleteBuffers(1, &screen->window_vertex_buffer);
        glDeleteVertexArrays(1, &screen->window_vertex_array);
@@ -871,6 +951,20 @@ void process_configure_event(Compositor *compositor, XConfigureEvent *event)
                mark_dirty(compositor, screen);
 }
 
+void process_property_event(Compositor *compositor, XPropertyEvent *event)
+{
+       CompositedScreen *screen;
+
+       if(event->atom!=compositor->correction_atom)
+               return;
+
+       screen = find_screen_by_root(compositor, event->window);
+       if(!screen)
+               return;
+
+       update_geometry_correction(compositor, screen);
+}
+
 void process_damage_event(Compositor *compositor, XDamageNotifyEvent *event)
 {
        CompositedScreen *screen;
@@ -916,6 +1010,9 @@ int process_event(Compositor *compositor)
        case ConfigureNotify:
                process_configure_event(compositor, &event.xconfigure);
                break;
+       case PropertyNotify:
+               process_property_event(compositor, &event.xproperty);
+               break;
        default:
                if(event.type==compositor->damage_event+XDamageNotify)
                        process_damage_event(compositor, (XDamageNotifyEvent *)&event);