Move shader program linking to a separate function

[geometrycompositor.git] / source / main.c

diff --git a/source/main.c b/source/main.c
index b26c46597beb22008963c5f01758aa96162ef73b..0992542fa960d3bcf1ef400b3685925b1b4cf98e 100644 (file)
--- a/source/main.c
+++ b/source/main.c
@@ -181,12 +181,36 @@ unsigned compile_shader(GLenum type, const char *source)
        return shader;
 }
 
-int create_gl_resources(Compositor *compositor, CompositedScreen *screen)
+unsigned link_program(unsigned *shaders, unsigned nshaders)
 {
+       unsigned program;
+       unsigned i;
        int status;
        char info_log[1024];
        GLsizei length;
 
+       program = glCreateProgram();
+       for(i=0; i<nshaders; ++i)
+               glAttachShader(program, shaders[i]);
+       glBindAttribLocation(program, 0, "vertex");
+       glLinkProgram(program);
+
+       glGetProgramiv(program, GL_LINK_STATUS, &status);
+       glGetProgramInfoLog(program, sizeof(info_log), &length, info_log);
+       if(!status)
+       {
+               fprintf(stderr, "Program link failed:\n%s\n", info_log);
+               glDeleteProgram(program);
+               return 0;
+       }
+       else if(length)
+               printf("Program info log:\n%s\n", info_log);
+
+       return program;
+}
+
+int create_gl_resources(Compositor *compositor, CompositedScreen *screen)
+{
        use_gl(compositor, screen);
 
        screen->shaders[0] = compile_shader(GL_VERTEX_SHADER, vshader);
@@ -194,25 +218,12 @@ int create_gl_resources(Compositor *compositor, CompositedScreen *screen)
        if(!screen->shaders[0] || !screen->shaders[1])
                return 0;
 
-       screen->program = glCreateProgram();
-       glAttachShader(screen->program, screen->shaders[0]);
-       glAttachShader(screen->program, screen->shaders[1]);
-       glBindAttribLocation(screen->program, 0, "vertex");
-       glLinkProgram(screen->program);
+       screen->program = link_program(screen->shaders, 2);
+       if(!screen->program)
+               return 0;
 
        screen->geometry_loc = glGetUniformLocation(screen->program, "geometry");
 
-       glGetProgramiv(screen->program, GL_LINK_STATUS, &status);
-       glGetProgramInfoLog(screen->program, sizeof(info_log), &length, info_log);
-       if(!status)
-       {
-               fprintf(stderr, "Program link failed:\n%s\n", info_log);
-               glDeleteProgram(screen->program);
-               return 0;
-       }
-       else if(length)
-               printf("Program info log:\n%s\n", info_log);
-
        glGenBuffers(1, &screen->vertex_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, screen->vertex_buffer);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
@@ -333,6 +344,43 @@ void remove_window(Compositor *compositor, CompositedScreen *screen, CompositedW
                screen->windows[i] = screen->windows[i+1];
 }
 
+CompositedWindow *reorder_window(CompositedScreen *screen, CompositedWindow *window, Window above)
+{
+       unsigned i, j;
+       CompositedWindow hold;
+
+       i = window-screen->windows;
+       if(above)
+       {
+               for(j=0; j<screen->nwindows; ++j)
+                       if(screen->windows[j].window==above)
+                               break;
+
+               if(j>=screen->nwindows || i==j+1)
+                       return window;
+
+               if(j<i)
+                       ++j;
+       }
+       else
+               j = 0;
+
+       hold = *window;
+       if(i<j)
+       {
+               for(; i<j; ++i)
+                       screen->windows[i] = screen->windows[i+1];
+       }
+       else
+       {
+               for(; i>j; --i)
+                       screen->windows[i] = screen->windows[i-1];
+       }
+       screen->windows[j] = hold;
+
+       return &screen->windows[j];
+}
+
 CompositedScreen *find_screen_by_root(Compositor *compositor, Window root)
 {
        unsigned i;
@@ -518,22 +566,28 @@ void process_create_window_event(Compositor *compositor, XCreateWindowEvent *eve
 
 void process_destroy_window_event(Compositor *compositor, XDestroyWindowEvent *event)
 {
-       CompositedScreen *screen = find_screen_by_root(compositor, event->event);
+       CompositedScreen *screen;
+       CompositedWindow *window;
+
+       screen = find_screen_by_root(compositor, event->event);
        if(!screen)
                return;
 
-       CompositedWindow *window = find_window(screen, event->window);
+       window = find_window(screen, event->window);
        if(window)
                remove_window(compositor, screen, window, 1);
 }
 
 void process_map_event(Compositor *compositor, XMapEvent *event)
 {
-       CompositedScreen *screen = find_screen_by_root(compositor, event->event);
+       CompositedScreen *screen;
+       CompositedWindow *window;
+
+       screen = find_screen_by_root(compositor, event->event);
        if(!screen)
                return;
 
-       CompositedWindow *window = find_window(screen, event->window);
+       window = find_window(screen, event->window);
        if(!window)
                return;
 
@@ -545,11 +599,14 @@ void process_map_event(Compositor *compositor, XMapEvent *event)
 
 void process_unmap_event(Compositor *compositor, XUnmapEvent *event)
 {
-       CompositedScreen *screen = find_screen_by_root(compositor, event->event);
+       CompositedScreen *screen;
+       CompositedWindow *window;
+
+       screen = find_screen_by_root(compositor, event->event);
        if(!screen)
                return;
 
-       CompositedWindow *window = find_window(screen, event->window);
+       window = find_window(screen, event->window);
        if(window)
                window->map_state = IsUnviewable;
 
@@ -558,11 +615,13 @@ void process_unmap_event(Compositor *compositor, XUnmapEvent *event)
 
 void process_reparent_event(Compositor *compositor, XReparentEvent *event)
 {
-       CompositedScreen *screen = find_screen_by_root(compositor, event->event);
+       CompositedScreen *screen;
+       CompositedWindow *window;
+
+       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
@@ -578,13 +637,44 @@ void process_reparent_event(Compositor *compositor, XReparentEvent *event)
                mark_dirty(compositor, screen);
 }
 
+void process_configure_event(Compositor *compositor, XConfigureEvent *event)
+{
+       CompositedScreen *screen;
+       CompositedWindow *window;
+
+       screen = find_screen_by_root(compositor, event->event);
+       if(!screen)
+               return;
+
+       window = find_window(screen, event->window);
+       if(!window)
+               return;
+
+       window->x = event->x;
+       window->y = event->y;
+       if((unsigned)event->width!=window->width || (unsigned)event->height!=window->height || (unsigned)event->border_width!=window->border)
+       {
+               window->width = event->width;
+               window->height = event->height;
+               window->border = event->border_width;
+               create_window_pixmap(compositor, screen, window);
+       }
+       reorder_window(screen, window, event->above);
+
+       if(window->map_state==IsViewable)
+               mark_dirty(compositor, screen);
+}
+
 void process_damage_event(Compositor *compositor, XDamageNotifyEvent *event)
 {
-       CompositedScreen *screen = find_screen_by_window(compositor, event->drawable);
+       CompositedScreen *screen;
+       CompositedWindow *window;
+
+       screen = find_screen_by_window(compositor, event->drawable);
        if(!screen)
                return;
 
-       CompositedWindow *window = find_window(screen, event->drawable);
+       window = find_window(screen, event->drawable);
        if(window->map_state==IsViewable)
                mark_dirty(compositor, screen);
 }
@@ -617,6 +707,9 @@ int process_event(Compositor *compositor)
        case ReparentNotify:
                process_reparent_event(compositor, &event.xreparent);
                break;
+       case ConfigureNotify:
+               process_configure_event(compositor, &event.xconfigure);
+               break;
        default:
                if(event.type==compositor->damage_event+XDamageNotify)
                        process_damage_event(compositor, (XDamageNotifyEvent *)&event);
@@ -634,6 +727,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);