diff --git a/CMakeLists.txt b/CMakeLists.txt
index b0cf2a4e..c99d1fc8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,8 +8,7 @@ set(GLFW_VERSION_MINOR "0")
 set(GLFW_VERSION_PATCH "0")
 set(GLFW_VERSION_EXTRA "")
 set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}")
-set(GLFW_VERSION_FULL  
-    "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
+set(GLFW_VERSION_FULL "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
 
 include(CheckFunctionExists)
 include(CheckSymbolExists)
@@ -159,8 +158,7 @@ install(FILES COPYING.txt readme.html
 # Uninstall operation
 #--------------------------------------------------------------------
 configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in
-               ${GLFW_BINARY_DIR}/cmake_uninstall.cmake
-               IMMEDIATE @ONLY)
+               ${GLFW_BINARY_DIR}/cmake_uninstall.cmake IMMEDIATE @ONLY)
 
 add_custom_target(uninstall
                   ${CMAKE_COMMAND} -P
diff --git a/examples/boing.c b/examples/boing.c
index 007f3f0f..b90f3732 100644
--- a/examples/boing.c
+++ b/examples/boing.c
@@ -585,7 +585,7 @@ int main( void )
        exit( EXIT_FAILURE );
    }
 
-   glfwSetWindowSizeCallback( window, reshape );
+   glfwSetWindowSizeCallback( reshape );
    glfwEnable( window, GLFW_STICKY_KEYS );
    glfwSwapInterval( 1 );
    glfwSetTime( 0.0 );
diff --git a/examples/gears.c b/examples/gears.c
index 1c2b209c..7271cf64 100644
--- a/examples/gears.c
+++ b/examples/gears.c
@@ -346,8 +346,8 @@ int main(int argc, char *argv[])
     init(argc, argv);
 
     // Set callback functions
-    glfwSetWindowSizeCallback( window, reshape );
-    glfwSetKeyCallback( window, key );
+    glfwSetWindowSizeCallback( reshape );
+    glfwSetKeyCallback( key );
 
     // Main loop
     while( running )
diff --git a/examples/heightmap.c b/examples/heightmap.c
index b5f2fdbc..4f8c1c0a 100644
--- a/examples/heightmap.c
+++ b/examples/heightmap.c
@@ -597,8 +597,8 @@ int main(int argc, char** argv)
         free(fragment_shader_src);
         exit(EXIT_FAILURE);
     }
-    glfwSetWindowCloseCallback(window, window_close_callback);
-    glfwSetKeyCallback(window, key_callback);
+    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetKeyCallback(key_callback);
     /* Register events callback */
 
     if (GL_TRUE != init_opengl())
diff --git a/examples/mipmaps.c b/examples/mipmaps.c
deleted file mode 100644
index 59bbef2e..00000000
--- a/examples/mipmaps.c
+++ /dev/null
@@ -1,122 +0,0 @@
-//========================================================================
-// This is an example program for the GLFW library
-//
-// It shows texture loading with mipmap generation and rendering with
-// trilienar texture filtering
-//========================================================================
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <GL/glfw.h>
-
-int main( void )
-{
-    int width, height, x;
-    double time;
-    GLboolean running;
-    GLuint textureID;
-    char* texturePath = "mipmaps.tga";
-
-    // Initialise GLFW
-    if( !glfwInit() )
-    {
-        fprintf( stderr, "Failed to initialize GLFW\n" );
-        exit( EXIT_FAILURE );
-    }
-
-    // Open OpenGL window
-    if( !glfwOpenWindow( 640, 480, 0,0,0,0, 0,0, GLFW_WINDOW ) )
-    {
-        fprintf( stderr, "Failed to open GLFW window\n" );
-        glfwTerminate();
-        exit( EXIT_FAILURE );
-    }
-
-    glfwSetWindowTitle( "Trilinear interpolation" );
-
-    // Enable sticky keys
-    glfwEnable( GLFW_STICKY_KEYS );
-
-    // Enable vertical sync (on cards that support it)
-    glfwSwapInterval( 1 );
-
-    // Generate and bind our texture ID
-    glGenTextures( 1, &textureID );
-    glBindTexture( GL_TEXTURE_2D, textureID );
-
-    // Load texture from file into video memory, including mipmap levels
-    if( !glfwLoadTexture2D( texturePath, GLFW_BUILD_MIPMAPS_BIT ) )
-    {
-        fprintf( stderr, "Failed to load texture %s\n", texturePath );
-        glfwTerminate();
-        exit( EXIT_FAILURE );
-    }
-
-    // Use trilinear interpolation (GL_LINEAR_MIPMAP_LINEAR)
-    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                     GL_LINEAR_MIPMAP_LINEAR );
-    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-                     GL_LINEAR );
-
-    // Enable plain 2D texturing
-    glEnable( GL_TEXTURE_2D );
-
-    running = GL_TRUE;
-    while( running )
-    {
-        // Get time and mouse position
-        time = glfwGetTime();
-        glfwGetMousePos( &x, NULL );
-
-        // Get window size (may be different than the requested size)
-        glfwGetWindowSize( &width, &height );
-        height = height > 0 ? height : 1;
-
-        // Set viewport
-        glViewport( 0, 0, width, height );
-
-        // Clear color buffer
-        glClearColor( 0.0f, 0.0f, 0.0f, 0.0f);
-        glClear( GL_COLOR_BUFFER_BIT );
-
-        // Select and setup the projection matrix
-        glMatrixMode( GL_PROJECTION );
-        glLoadIdentity();
-        gluPerspective( 65.0f, (GLfloat)width / (GLfloat)height, 1.0f,
-            50.0f );
-
-        // Select and setup the modelview matrix
-        glMatrixMode( GL_MODELVIEW );
-        glLoadIdentity();
-        gluLookAt( 0.0f,  3.0f, -20.0f,    // Eye-position
-                   0.0f, -4.0f, -11.0f,    // View-point
-                   0.0f,  1.0f,   0.0f );  // Up-vector
-
-        // Draw a textured quad
-        glRotatef( 0.05f * (GLfloat)x + (GLfloat)time * 5.0f, 0.0f, 1.0f, 0.0f );
-        glBegin( GL_QUADS );
-          glTexCoord2f( -20.0f,  20.0f );
-          glVertex3f( -50.0f, 0.0f, -50.0f );
-          glTexCoord2f(  20.0f,  20.0f );
-          glVertex3f(  50.0f, 0.0f, -50.0f );
-          glTexCoord2f(  20.0f, -20.0f );
-          glVertex3f(  50.0f, 0.0f,  50.0f );
-          glTexCoord2f( -20.0f, -20.0f );
-          glVertex3f( -50.0f, 0.0f,  50.0f );
-        glEnd();
-
-        // Swap buffers
-        glfwSwapBuffers();
-
-        // Check if the ESC key was pressed or the window was closed
-        running = !glfwGetKey( GLFW_KEY_ESC ) &&
-                  glfwGetWindowParam( GLFW_OPENED );
-    }
-
-    // Close OpenGL window and terminate GLFW
-    glfwTerminate();
-
-    exit( EXIT_SUCCESS );
-}
-
diff --git a/examples/mipmaps.tga b/examples/mipmaps.tga
deleted file mode 100644
index 55f913b0..00000000
Binary files a/examples/mipmaps.tga and /dev/null differ
diff --git a/examples/splitview.c b/examples/splitview.c
index 1611ad90..d05b078c 100644
--- a/examples/splitview.c
+++ b/examples/splitview.c
@@ -50,48 +50,49 @@ static int do_redraw = 1;
 #define TORUS_MAJOR_RES 32
 #define TORUS_MINOR_RES 32
 
-static void drawTorus( void )
+static void drawTorus(void)
 {
     static GLuint torus_list = 0;
     int    i, j, k;
     double s, t, x, y, z, nx, ny, nz, scale, twopi;
 
-    if( !torus_list )
+    if (!torus_list)
     {
         // Start recording displaylist
-        torus_list = glGenLists( 1 );
-        glNewList( torus_list, GL_COMPILE_AND_EXECUTE );
+        torus_list = glGenLists(1);
+        glNewList(torus_list, GL_COMPILE_AND_EXECUTE);
 
         // Draw torus
         twopi = 2.0 * M_PI;
-        for( i = 0; i < TORUS_MINOR_RES; i++ )
+        for (i = 0;  i < TORUS_MINOR_RES;  i++)
         {
-            glBegin( GL_QUAD_STRIP );
-            for( j = 0; j <= TORUS_MAJOR_RES; j++ )
+            glBegin(GL_QUAD_STRIP);
+            for (j = 0;  j <= TORUS_MAJOR_RES;  j++)
             {
-                for( k = 1; k >= 0; k-- )
+                for (k = 1;  k >= 0;  k--)
                 {
                     s = (i + k) % TORUS_MINOR_RES + 0.5;
                     t = j % TORUS_MAJOR_RES;
 
                     // Calculate point on surface
-                    x = (TORUS_MAJOR+TORUS_MINOR*cos(s*twopi/TORUS_MINOR_RES))*cos(t*twopi/TORUS_MAJOR_RES);
+                    x = (TORUS_MAJOR + TORUS_MINOR * cos(s * twopi / TORUS_MINOR_RES)) * cos(t * twopi / TORUS_MAJOR_RES);
                     y = TORUS_MINOR * sin(s * twopi / TORUS_MINOR_RES);
-                    z = (TORUS_MAJOR+TORUS_MINOR*cos(s*twopi/TORUS_MINOR_RES))*sin(t*twopi/TORUS_MAJOR_RES);
+                    z = (TORUS_MAJOR + TORUS_MINOR * cos(s * twopi / TORUS_MINOR_RES)) * sin(t * twopi / TORUS_MAJOR_RES);
 
                     // Calculate surface normal
-                    nx = x - TORUS_MAJOR*cos(t*twopi/TORUS_MAJOR_RES);
+                    nx = x - TORUS_MAJOR * cos(t * twopi / TORUS_MAJOR_RES);
                     ny = y;
-                    nz = z - TORUS_MAJOR*sin(t*twopi/TORUS_MAJOR_RES);
-                    scale = 1.0 / sqrt( nx*nx + ny*ny + nz*nz );
+                    nz = z - TORUS_MAJOR * sin(t * twopi / TORUS_MAJOR_RES);
+                    scale = 1.0 / sqrt(nx*nx + ny*ny + nz*nz);
                     nx *= scale;
                     ny *= scale;
                     nz *= scale;
 
-                    glNormal3f( (float)nx, (float)ny, (float)nz );
-                    glVertex3f( (float)x, (float)y, (float)z );
+                    glNormal3f((float) nx, (float) ny, (float) nz);
+                    glVertex3f((float) x, (float) y, (float) z);
                 }
             }
+
             glEnd();
         }
 
@@ -101,7 +102,7 @@ static void drawTorus( void )
     else
     {
         // Playback displaylist
-        glCallList( torus_list );
+        glCallList(torus_list);
     }
 }
 
@@ -110,7 +111,7 @@ static void drawTorus( void )
 // Draw the scene (a rotating torus)
 //========================================================================
 
-static void drawScene( void )
+static void drawScene(void)
 {
     const GLfloat model_diffuse[4]  = {1.0f, 0.8f, 0.8f, 1.0f};
     const GLfloat model_specular[4] = {0.6f, 0.6f, 0.6f, 1.0f};
@@ -119,17 +120,17 @@ static void drawScene( void )
     glPushMatrix();
 
     // Rotate the object
-    glRotatef( (GLfloat)rot_x*0.5f, 1.0f, 0.0f, 0.0f );
-    glRotatef( (GLfloat)rot_y*0.5f, 0.0f, 1.0f, 0.0f );
-    glRotatef( (GLfloat)rot_z*0.5f, 0.0f, 0.0f, 1.0f );
+    glRotatef((GLfloat) rot_x * 0.5f, 1.0f, 0.0f, 0.0f);
+    glRotatef((GLfloat) rot_y * 0.5f, 0.0f, 1.0f, 0.0f);
+    glRotatef((GLfloat) rot_z * 0.5f, 0.0f, 0.0f, 1.0f);
 
     // Set model color (used for orthogonal views, lighting disabled)
-    glColor4fv( model_diffuse );
+    glColor4fv(model_diffuse);
 
     // Set model material (used for perspective view, lighting enabled)
-    glMaterialfv( GL_FRONT, GL_DIFFUSE, model_diffuse );
-    glMaterialfv( GL_FRONT, GL_SPECULAR, model_specular );
-    glMaterialf(  GL_FRONT, GL_SHININESS, model_shininess );
+    glMaterialfv(GL_FRONT, GL_DIFFUSE, model_diffuse);
+    glMaterialfv(GL_FRONT, GL_SPECULAR, model_specular);
+    glMaterialf(GL_FRONT, GL_SHININESS, model_shininess);
 
     // Draw torus
     drawTorus();
@@ -142,55 +143,55 @@ static void drawScene( void )
 // Draw a 2D grid (used for orthogonal views)
 //========================================================================
 
-static void drawGrid( float scale, int steps )
+static void drawGrid(float scale, int steps)
 {
-    int   i;
+    int i;
     float x, y;
 
     glPushMatrix();
 
     // Set background to some dark bluish grey
-    glClearColor( 0.05f, 0.05f, 0.2f, 0.0f);
-    glClear( GL_COLOR_BUFFER_BIT );
+    glClearColor(0.05f, 0.05f, 0.2f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
 
     // Setup modelview matrix (flat XY view)
     glLoadIdentity();
-    gluLookAt( 0.0, 0.0, 1.0,
-               0.0, 0.0, 0.0,
-               0.0, 1.0, 0.0 );
+    gluLookAt(0.0, 0.0, 1.0,
+              0.0, 0.0, 0.0,
+              0.0, 1.0, 0.0);
 
     // We don't want to update the Z-buffer
-    glDepthMask( GL_FALSE );
+    glDepthMask(GL_FALSE);
 
     // Set grid color
-    glColor3f( 0.0f, 0.5f, 0.5f );
+    glColor3f(0.0f, 0.5f, 0.5f);
 
-    glBegin( GL_LINES );
+    glBegin(GL_LINES);
 
     // Horizontal lines
-    x = scale * 0.5f * (float)(steps-1);
-    y = -scale * 0.5f * (float)(steps-1);
-    for( i = 0; i < steps; i ++ )
+    x = scale * 0.5f * (float) (steps - 1);
+    y = -scale * 0.5f * (float) (steps - 1);
+    for (i = 0;  i < steps;  i++)
     {
-        glVertex3f( -x, y, 0.0f );
-        glVertex3f( x, y, 0.0f );
+        glVertex3f(-x, y, 0.0f);
+        glVertex3f(x, y, 0.0f);
         y += scale;
     }
 
     // Vertical lines
-    x = -scale * 0.5f * (float)(steps-1);
-    y = scale * 0.5f * (float)(steps-1);
-    for( i = 0; i < steps; i ++ )
+    x = -scale * 0.5f * (float) (steps - 1);
+    y = scale * 0.5f * (float) (steps - 1);
+    for (i = 0;  i < steps;  i++)
     {
-        glVertex3f( x, -y, 0.0f );
-        glVertex3f( x, y, 0.0f );
+        glVertex3f(x, -y, 0.0f);
+        glVertex3f(x, y, 0.0f);
         x += scale;
     }
 
     glEnd();
 
     // Enable Z-buffer writing again
-    glDepthMask( GL_TRUE );
+    glDepthMask(GL_TRUE);
 
     glPopMatrix();
 }
@@ -200,7 +201,7 @@ static void drawGrid( float scale, int steps )
 // Draw all views
 //========================================================================
 
-static void drawAllViews( void )
+static void drawAllViews(void)
 {
     const GLfloat light_position[4] = {0.0f, 8.0f, 8.0f, 1.0f};
     const GLfloat light_diffuse[4]  = {1.0f, 1.0f, 1.0f, 1.0f};
@@ -209,145 +210,142 @@ static void drawAllViews( void )
     double aspect;
 
     // Calculate aspect of window
-    if( height > 0 )
-    {
-        aspect = (double)width / (double)height;
-    }
+    if (height > 0)
+        aspect = (double) width / (double) height;
     else
-    {
         aspect = 1.0;
-    }
 
     // Clear screen
-    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f);
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     // Enable scissor test
-    glEnable( GL_SCISSOR_TEST );
+    glEnable(GL_SCISSOR_TEST);
 
     // Enable depth test
-    glEnable( GL_DEPTH_TEST );
-    glDepthFunc( GL_LEQUAL );
-
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LEQUAL);
 
     // ** ORTHOGONAL VIEWS **
 
     // For orthogonal views, use wireframe rendering
-    glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
     // Enable line anti-aliasing
-    glEnable( GL_LINE_SMOOTH );
-    glEnable( GL_BLEND );
-    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+    glEnable(GL_LINE_SMOOTH);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     // Setup orthogonal projection matrix
-    glMatrixMode( GL_PROJECTION );
+    glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
-    glOrtho( -3.0*aspect, 3.0*aspect, -3.0, 3.0, 1.0, 50.0 );
+    glOrtho(-3.0 * aspect, 3.0 * aspect, -3.0, 3.0, 1.0, 50.0);
 
     // Upper left view (TOP VIEW)
-    glViewport( 0, height/2, width/2, height/2 );
-    glScissor( 0, height/2, width/2, height/2 );
-    glMatrixMode( GL_MODELVIEW );
+    glViewport(0, height / 2, width / 2, height / 2);
+    glScissor(0, height / 2, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
-    gluLookAt( 0.0f, 10.0f, 1e-3f,   // Eye-position (above)
-               0.0f, 0.0f, 0.0f,     // View-point
-               0.0f, 1.0f, 0.0f );   // Up-vector
-    drawGrid( 0.5, 12 );
+    gluLookAt(0.0f, 10.0f, 1e-3f,   // Eye-position (above)
+              0.0f, 0.0f, 0.0f,     // View-point
+              0.0f, 1.0f, 0.0f);   // Up-vector
+    drawGrid(0.5, 12);
     drawScene();
 
     // Lower left view (FRONT VIEW)
-    glViewport( 0, 0, width/2, height/2 );
-    glScissor( 0, 0, width/2, height/2 );
-    glMatrixMode( GL_MODELVIEW );
+    glViewport(0, 0, width / 2, height / 2);
+    glScissor(0, 0, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
-    gluLookAt( 0.0f, 0.0f, 10.0f,    // Eye-position (in front of)
-               0.0f, 0.0f, 0.0f,     // View-point
-               0.0f, 1.0f, 0.0f );   // Up-vector
-    drawGrid( 0.5, 12 );
+    gluLookAt(0.0f, 0.0f, 10.0f,    // Eye-position (in front of)
+              0.0f, 0.0f, 0.0f,     // View-point
+              0.0f, 1.0f, 0.0f);   // Up-vector
+    drawGrid(0.5, 12);
     drawScene();
 
     // Lower right view (SIDE VIEW)
-    glViewport( width/2, 0, width/2, height/2 );
-    glScissor( width/2, 0, width/2, height/2 );
-    glMatrixMode( GL_MODELVIEW );
+    glViewport(width / 2, 0, width / 2, height / 2);
+    glScissor(width / 2, 0, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
-    gluLookAt( 10.0f, 0.0f, 0.0f,    // Eye-position (to the right)
-               0.0f, 0.0f, 0.0f,     // View-point
-               0.0f, 1.0f, 0.0f );   // Up-vector
-    drawGrid( 0.5, 12 );
+    gluLookAt(10.0f, 0.0f, 0.0f,    // Eye-position (to the right)
+              0.0f, 0.0f, 0.0f,     // View-point
+              0.0f, 1.0f, 0.0f);   // Up-vector
+    drawGrid(0.5, 12);
     drawScene();
 
     // Disable line anti-aliasing
-    glDisable( GL_LINE_SMOOTH );
-    glDisable( GL_BLEND );
-
+    glDisable(GL_LINE_SMOOTH);
+    glDisable(GL_BLEND);
 
     // ** PERSPECTIVE VIEW **
 
     // For perspective view, use solid rendering
-    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
     // Enable face culling (faster rendering)
-    glEnable( GL_CULL_FACE );
-    glCullFace( GL_BACK );
-    glFrontFace( GL_CW );
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+    glFrontFace(GL_CW);
 
     // Setup perspective projection matrix
-    glMatrixMode( GL_PROJECTION );
+    glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
-    gluPerspective( 65.0f, aspect, 1.0f, 50.0f );
+    gluPerspective(65.0f, aspect, 1.0f, 50.0f);
 
     // Upper right view (PERSPECTIVE VIEW)
-    glViewport( width/2, height/2, width/2, height/2 );
-    glScissor( width/2, height/2, width/2, height/2 );
-    glMatrixMode( GL_MODELVIEW );
+    glViewport(width / 2, height / 2, width / 2, height / 2);
+    glScissor(width / 2, height / 2, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
-    gluLookAt( 3.0f, 1.5f, 3.0f,     // Eye-position
-               0.0f, 0.0f, 0.0f,     // View-point
-               0.0f, 1.0f, 0.0f );   // Up-vector
+    gluLookAt(3.0f, 1.5f, 3.0f,     // Eye-position
+              0.0f, 0.0f, 0.0f,     // View-point
+              0.0f, 1.0f, 0.0f);   // Up-vector
 
     // Configure and enable light source 1
-    glLightfv( GL_LIGHT1, GL_POSITION, light_position );
-    glLightfv( GL_LIGHT1, GL_AMBIENT, light_ambient );
-    glLightfv( GL_LIGHT1, GL_DIFFUSE, light_diffuse );
-    glLightfv( GL_LIGHT1, GL_SPECULAR, light_specular );
-    glEnable( GL_LIGHT1 );
-    glEnable( GL_LIGHTING );
+    glLightfv(GL_LIGHT1, GL_POSITION, light_position);
+    glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
+    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
+    glEnable(GL_LIGHT1);
+    glEnable(GL_LIGHTING);
 
     // Draw scene
     drawScene();
 
     // Disable lighting
-    glDisable( GL_LIGHTING );
+    glDisable(GL_LIGHTING);
 
     // Disable face culling
-    glDisable( GL_CULL_FACE );
+    glDisable(GL_CULL_FACE);
 
     // Disable depth test
-    glDisable( GL_DEPTH_TEST );
+    glDisable(GL_DEPTH_TEST);
 
     // Disable scissor test
-    glDisable( GL_SCISSOR_TEST );
-
+    glDisable(GL_SCISSOR_TEST);
 
     // Draw a border around the active view
-    if( active_view > 0 && active_view != 2 )
+    if (active_view > 0 && active_view != 2)
     {
-        glViewport( 0, 0, width, height );
-        glMatrixMode( GL_PROJECTION );
+        glViewport(0, 0, width, height);
+
+        glMatrixMode(GL_PROJECTION);
         glLoadIdentity();
-        glOrtho( 0.0, 2.0, 0.0, 2.0, 0.0, 1.0 );
-        glMatrixMode( GL_MODELVIEW );
+        glOrtho(0.0, 2.0, 0.0, 2.0, 0.0, 1.0);
+
+        glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
-        glColor3f( 1.0f, 1.0f, 0.6f );
-        glTranslatef( (GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f );
-        glBegin( GL_LINE_STRIP );
-          glVertex2i( 0, 0 );
-          glVertex2i( 1, 0 );
-          glVertex2i( 1, 1 );
-          glVertex2i( 0, 1 );
-          glVertex2i( 0, 0 );
+        glTranslatef((GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f);
+
+        glColor3f(1.0f, 1.0f, 0.6f);
+
+        glBegin(GL_LINE_STRIP);
+        glVertex2i(0, 0);
+        glVertex2i(1, 0);
+        glVertex2i(1, 1);
+        glVertex2i(0, 1);
+        glVertex2i(0, 0);
         glEnd();
     }
 }
@@ -357,7 +355,7 @@ static void drawAllViews( void )
 // Window size callback function
 //========================================================================
 
-static void windowSizeFun( GLFWwindow window, int w, int h )
+static void windowSizeFun(GLFWwindow window, int w, int h)
 {
     width  = w;
     height = h > 0 ? h : 1;
@@ -369,7 +367,7 @@ static void windowSizeFun( GLFWwindow window, int w, int h )
 // Window refresh callback function
 //========================================================================
 
-static void windowRefreshFun( GLFWwindow window )
+static void windowRefreshFun(GLFWwindow window)
 {
     do_redraw = 1;
 }
@@ -379,10 +377,10 @@ static void windowRefreshFun( GLFWwindow window )
 // Mouse position callback function
 //========================================================================
 
-static void mousePosFun( GLFWwindow window, int x, int y )
+static void mousePosFun(GLFWwindow window, int x, int y)
 {
     // Depending on which view was selected, rotate around different axes
-    switch( active_view )
+    switch (active_view)
     {
         case 1:
             rot_x += y - ypos;
@@ -414,25 +412,18 @@ static void mousePosFun( GLFWwindow window, int x, int y )
 // Mouse button callback function
 //========================================================================
 
-static void mouseButtonFun( GLFWwindow window, int button, int action )
+static void mouseButtonFun(GLFWwindow window, int button, int action)
 {
-    // Button clicked?
-    if( ( button == GLFW_MOUSE_BUTTON_LEFT ) && action == GLFW_PRESS )
+    if ((button == GLFW_MOUSE_BUTTON_LEFT) && action == GLFW_PRESS)
     {
         // Detect which of the four views was clicked
         active_view = 1;
-        if( xpos >= width/2 )
-        {
+        if (xpos >= width / 2)
             active_view += 1;
-        }
-        if( ypos >= height/2 )
-        {
+        if (ypos >= height / 2)
             active_view += 2;
-        }
     }
-
-    // Button released?
-    else if( button == GLFW_MOUSE_BUTTON_LEFT )
+    else if (button == GLFW_MOUSE_BUTTON_LEFT)
     {
         // Deselect any previously selected view
         active_view = 0;
@@ -443,51 +434,50 @@ static void mouseButtonFun( GLFWwindow window, int button, int action )
 
 
 //========================================================================
-// main()
+// main
 //========================================================================
 
-int main( void )
+int main(void)
 {
     GLFWwindow window;
 
     // Initialise GLFW
-    if( !glfwInit() )
+    if (!glfwInit())
     {
-        fprintf( stderr, "Failed to initialize GLFW\n" );
-        exit( EXIT_FAILURE );
+        fprintf(stderr, "Failed to initialize GLFW\n");
+        exit(EXIT_FAILURE);
     }
 
     glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
 
     // Open OpenGL window
-    window = glfwOpenWindow( 500, 500, GLFW_WINDOWED, "Split view demo", NULL );
+    window = glfwOpenWindow(500, 500, GLFW_WINDOWED, "Split view demo", NULL);
     if (!window)
     {
-        fprintf( stderr, "Failed to open GLFW window\n" );
-        glfwTerminate();
-        exit( EXIT_FAILURE );
+        fprintf(stderr, "Failed to open GLFW window\n");
+        exit(EXIT_FAILURE);
     }
 
     // Enable vsync
-    glfwSwapInterval( 1 );
+    glfwSwapInterval(1);
 
     // Enable sticky keys
-    glfwEnable( window, GLFW_STICKY_KEYS );
+    glfwEnable(window, GLFW_STICKY_KEYS);
 
     // Enable mouse cursor (only needed for fullscreen mode)
-    glfwEnable( window, GLFW_MOUSE_CURSOR );
+    glfwEnable(window, GLFW_MOUSE_CURSOR);
 
     // Set callback functions
-    glfwSetWindowSizeCallback( window, windowSizeFun );
-    glfwSetWindowRefreshCallback( window, windowRefreshFun );
-    glfwSetMousePosCallback( window, mousePosFun );
-    glfwSetMouseButtonCallback( window, mouseButtonFun );
+    glfwSetWindowSizeCallback(windowSizeFun);
+    glfwSetWindowRefreshCallback(windowRefreshFun);
+    glfwSetMousePosCallback(mousePosFun);
+    glfwSetMouseButtonCallback(mouseButtonFun);
 
     // Main loop
     do
     {
         // Only redraw if we need to
-        if( do_redraw )
+        if (do_redraw)
         {
             // Draw all views
             drawAllViews();
@@ -502,12 +492,12 @@ int main( void )
         glfwWaitEvents();
 
     } // Check if the ESC key was pressed or the window was closed
-    while( glfwIsWindow(window) &&
-           glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS );
+    while (glfwIsWindow(window) &&
+           glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS);
 
     // Close OpenGL window and terminate GLFW
     glfwTerminate();
 
-    exit( EXIT_SUCCESS );
+    exit(EXIT_SUCCESS);
 }
 
diff --git a/examples/triangle.c b/examples/triangle.c
index 5e1e2423..31438813 100644
--- a/examples/triangle.c
+++ b/examples/triangle.c
@@ -6,77 +6,75 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include <GL/glfw3.h>
 
-
-int main( void )
+int main(void)
 {
     int width, height, x;
-    double t;
     GLFWwindow window;
 
     // Initialise GLFW
-    if( !glfwInit() )
+    if (!glfwInit())
     {
-        fprintf( stderr, "Failed to initialize GLFW\n" );
-        exit( EXIT_FAILURE );
+        fprintf(stderr, "Failed to initialize GLFW\n");
+        exit(EXIT_FAILURE);
     }
 
     // Open a window and create its OpenGL context
-    window = glfwOpenWindow( 640, 480, GLFW_WINDOWED, "Spinning Triangle", NULL );
+    window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Spinning Triangle", NULL);
     if (!window)
     {
-        fprintf( stderr, "Failed to open GLFW window\n" );
-
-        glfwTerminate();
-        exit( EXIT_FAILURE );
+        fprintf(stderr, "Failed to open GLFW window\n");
+        exit(EXIT_FAILURE);
     }
 
     // Ensure we can capture the escape key being pressed below
-    glfwEnable( window, GLFW_STICKY_KEYS );
+    glfwEnable(window, GLFW_STICKY_KEYS);
 
     // Enable vertical sync (on cards that support it)
-    glfwSwapInterval( 1 );
+    glfwSwapInterval(1);
 
     do
     {
-        t = glfwGetTime();
-        glfwGetMousePos( window, &x, NULL );
+        double t = glfwGetTime();
+        glfwGetMousePos(window, &x, NULL);
 
         // Get window size (may be different than the requested size)
-        glfwGetWindowSize( window, &width, &height );
+        glfwGetWindowSize(window, &width, &height);
 
         // Special case: avoid division by zero below
         height = height > 0 ? height : 1;
 
-        glViewport( 0, 0, width, height );
+        glViewport(0, 0, width, height);
 
         // Clear color buffer to black
-        glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
-        glClear( GL_COLOR_BUFFER_BIT );
+        glClearColor(0.f, 0.f, 0.f, 0.f);
+        glClear(GL_COLOR_BUFFER_BIT);
 
         // Select and setup the projection matrix
-        glMatrixMode( GL_PROJECTION );
+        glMatrixMode(GL_PROJECTION);
         glLoadIdentity();
-        gluPerspective( 65.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f );
+        gluPerspective(65.f, (GLfloat) width / (GLfloat) height, 1.f, 100.f);
 
         // Select and setup the modelview matrix
         glMatrixMode( GL_MODELVIEW );
         glLoadIdentity();
-        gluLookAt( 0.0f, 1.0f, 0.0f,    // Eye-position
-                   0.0f, 20.0f, 0.0f,   // View-point
-                   0.0f, 0.0f, 1.0f );  // Up-vector
+        gluLookAt(0.f, 1.f, 0.f,    // Eye-position
+                  0.f, 20.f, 0.f,   // View-point
+                  0.f, 0.f, 1.f);   // Up-vector
 
         // Draw a rotating colorful triangle
-        glTranslatef( 0.0f, 14.0f, 0.0f );
-        glRotatef( 0.3f*(GLfloat)x + (GLfloat)t*100.0f, 0.0f, 0.0f, 1.0f );
-        glBegin( GL_TRIANGLES );
-          glColor3f( 1.0f, 0.0f, 0.0f );
-          glVertex3f( -5.0f, 0.0f, -4.0f );
-          glColor3f( 0.0f, 1.0f, 0.0f );
-          glVertex3f( 5.0f, 0.0f, -4.0f );
-          glColor3f( 0.0f, 0.0f, 1.0f );
-          glVertex3f( 0.0f, 0.0f, 6.0f );
+        glTranslatef(0.f, 14.f, 0.f);
+        glRotatef(0.3f * (GLfloat) x + (GLfloat) t * 100.f, 0.f, 0.f, 1.f);
+
+        glBegin(GL_TRIANGLES);
+        glColor3f(1.f, 0.f, 0.f);
+        glVertex3f(-5.f, 0.f, -4.f);
+        glColor3f(0.f, 1.f, 0.f);
+        glVertex3f(5.f, 0.f, -4.f);
+        glColor3f(0.f, 0.f, 1.f);
+        glVertex3f(0.f, 0.f, 6.f);
         glEnd();
 
         // Swap buffers
@@ -84,12 +82,12 @@ int main( void )
         glfwPollEvents();
 
     } // Check if the ESC key was pressed or the window was closed
-    while( glfwIsWindow(window) &&
-           glfwGetKey( window, GLFW_KEY_ESC ) != GLFW_PRESS );
+    while (glfwIsWindow(window) &&
+           glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS);
 
     // Close OpenGL window and terminate GLFW
     glfwTerminate();
 
-    exit( EXIT_SUCCESS );
+    exit(EXIT_SUCCESS);
 }
 
diff --git a/examples/wave.c b/examples/wave.c
index 2c81abc8..49bf1a68 100644
--- a/examples/wave.c
+++ b/examples/wave.c
@@ -5,6 +5,7 @@
  * Modified for GLFW by Sylvain Hellegouarch - sh@programmationworld.com
  * Modified for variable frame rate by Marcus Geelnard
  * 2003-Jan-31: Minor cleanups and speedups / MG
+ * 2010-10-24: Formatting and cleanup - Camilla Berglund
  *****************************************************************************/
 
 #include <stdio.h>
@@ -16,33 +17,32 @@
  #define M_PI 3.1415926535897932384626433832795
 #endif
 
-/* Maximum delta T to allow for differential calculations */
+// Maximum delta T to allow for differential calculations
 #define MAX_DELTA_T 0.01
 
-/* Animation speed (10.0 looks good) */
+// Animation speed (10.0 looks good)
 #define ANIMATION_SPEED 10.0
 
+GLfloat alpha = 210.f, beta = -70.f;
+GLfloat zoom = 2.f;
 
-GLfloat alpha = 210.0f, beta = -70.0f;
-GLfloat zoom = 2.0f;
-
-int running = 1;
+GLboolean running = GL_TRUE;
 
 struct Vertex
 {
-  GLfloat x,y,z;
-  GLfloat r,g,b;
+    GLfloat x, y, z;
+    GLfloat r, g, b;
 };
 
 #define GRIDW 50
 #define GRIDH 50
 #define VERTEXNUM (GRIDW*GRIDH)
 
-#define QUADW (GRIDW-1)
-#define QUADH (GRIDH-1)
+#define QUADW (GRIDW - 1)
+#define QUADH (GRIDH - 1)
 #define QUADNUM (QUADW*QUADH)
 
-GLuint quad[4*QUADNUM];
+GLuint quad[4 * QUADNUM];
 struct Vertex vertex[VERTEXNUM];
 
 /* The grid will look like this:
@@ -56,47 +56,46 @@ struct Vertex vertex[VERTEXNUM];
  *      0   1   2
  */
 
-void initVertices( void )
+//========================================================================
+// Initialize grid geometry
+//========================================================================
+
+void init_vertices(void)
 {
-  int x,y,p;
+    int x, y, p;
 
-  /* place the vertices in a grid */
-  for(y=0;y<GRIDH;y++)
-    for(x=0;x<GRIDW;x++)
+    // Place the vertices in a grid
+    for (y = 0;  y < GRIDH;  y++)
     {
-      p = y*GRIDW + x;
+        for (x = 0;  x < GRIDW;  x++)
+        {
+            p = y * GRIDW + x;
 
-      //vertex[p].x = (-GRIDW/2)+x+sin(2.0*M_PI*(double)y/(double)GRIDH);
-      //vertex[p].y = (-GRIDH/2)+y+cos(2.0*M_PI*(double)x/(double)GRIDW);
-      vertex[p].x = (GLfloat)(x-GRIDW/2)/(GLfloat)(GRIDW/2);
-      vertex[p].y = (GLfloat)(y-GRIDH/2)/(GLfloat)(GRIDH/2);
-      vertex[p].z = 0;//sin(d*M_PI);
-      //vertex[p].r = (GLfloat)x/(GLfloat)GRIDW;
-      //vertex[p].g = (GLfloat)y/(GLfloat)GRIDH;
-      //vertex[p].b = 1.0-((GLfloat)x/(GLfloat)GRIDW+(GLfloat)y/(GLfloat)GRIDH)/2.0;
-      if((x%4<2)^(y%4<2))
-      {
-        vertex[p].r = 0.0;
-      }
-      else
-      {
-        vertex[p].r=1.0;
-      }
+            vertex[p].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2);
+            vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2);
+            vertex[p].z = 0;
 
-      vertex[p].g = (GLfloat)y/(GLfloat)GRIDH;
-      vertex[p].b = 1.f-((GLfloat)x/(GLfloat)GRIDW+(GLfloat)y/(GLfloat)GRIDH)/2.f;
+            if ((x % 4 < 2) ^ (y % 4 < 2))
+                vertex[p].r = 0.0;
+            else
+                vertex[p].r = 1.0;
+
+            vertex[p].g = (GLfloat) y / (GLfloat) GRIDH;
+            vertex[p].b = 1.f - ((GLfloat) x / (GLfloat) GRIDW + (GLfloat) y / (GLfloat) GRIDH) / 2.f;
+        }
     }
 
-  for(y=0;y<QUADH;y++)
-    for(x=0;x<QUADW;x++)
+    for (y = 0;  y < QUADH;  y++)
     {
-      p = 4*(y*QUADW + x);
+        for (x = 0;  x < QUADW;  x++)
+        {
+            p = 4 * (y * QUADW + x);
 
-      /* first quad */
-      quad[p+0] = y    *GRIDW+x;    /* some point */
-      quad[p+1] = y    *GRIDW+x+1;  /* neighbor at the right side */
-      quad[p+2] = (y+1)*GRIDW+x+1;  /* upper right neighbor */
-      quad[p+3] = (y+1)*GRIDW+x;    /* upper neighbor */
+            quad[p + 0] = y       * GRIDW + x;     // Some point
+            quad[p + 1] = y       * GRIDW + x + 1; // Neighbor at the right side
+            quad[p + 2] = (y + 1) * GRIDW + x + 1; // Upper right neighbor
+            quad[p + 3] = (y + 1) * GRIDW + x;     // Upper neighbor
+        }
     }
 }
 
@@ -105,298 +104,287 @@ double p[GRIDW][GRIDH];
 double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH];
 double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH];
 
+//========================================================================
+// Initialize grid
+//========================================================================
 
-
-void initSurface( void )
+void init_grid(void)
 {
-  int    x, y;
-  double dx, dy, d;
+    int x, y;
+    double dx, dy, d;
 
-  for(y = 0; y<GRIDH; y++)
-  {
-    for(x = 0; x<GRIDW; x++)
+    for (y = 0; y < GRIDH;  y++)
     {
-      dx = (double)(x-GRIDW/2);
-      dy = (double)(y-GRIDH/2);
-      d = sqrt( dx*dx + dy*dy );
-      if(d < 0.1 * (double)(GRIDW/2))
-      {
-        d = d * 10.0;
-        p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0;
-      }
-      else
-      {
-        p[x][y] = 0.0;
-      }
-      vx[x][y] = 0.0;
-      vy[x][y] = 0.0;
+        for (x = 0; x < GRIDW;  x++)
+        {
+            dx = (double) (x - GRIDW / 2);
+            dy = (double) (y - GRIDH / 2);
+            d = sqrt(dx * dx + dy * dy);
+            if (d < 0.1 * (double) (GRIDW / 2))
+            {
+                d = d * 10.0;
+                p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0;
+            }
+            else
+                p[x][y] = 0.0;
+
+            vx[x][y] = 0.0;
+            vy[x][y] = 0.0;
+        }
     }
-  }
 }
 
 
-/* Draw view */
-void draw_screen( void )
+//========================================================================
+// Draw scene
+//========================================================================
+
+void draw_scene(void)
 {
-  /* Clear the color and depth buffers. */
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    // Clear the color and depth buffers
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  /* We don't want to modify the projection matrix. */
-  glMatrixMode(GL_MODELVIEW);
-  glLoadIdentity();
+    // We don't want to modify the projection matrix
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
 
-  /* Move back. */
-  glTranslatef(0.0, 0.0, -zoom);
-  /* Rotate the view */
-  glRotatef(beta, 1.0, 0.0, 0.0);
-  glRotatef(alpha, 0.0, 0.0, 1.0);
+    // Move back
+    glTranslatef(0.0, 0.0, -zoom);
+    // Rotate the view
+    glRotatef(beta, 1.0, 0.0, 0.0);
+    glRotatef(alpha, 0.0, 0.0, 1.0);
 
-  //glDrawArrays(GL_POINTS,0,VERTEXNUM); /* Points only */
-  glDrawElements(GL_QUADS, 4*QUADNUM, GL_UNSIGNED_INT, quad);
-  //glDrawElements(GL_LINES, QUADNUM, GL_UNSIGNED_INT, quad);
+    glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad);
 
-  glfwSwapBuffers();
+    glfwSwapBuffers();
 }
 
 
-/* Initialize OpenGL */
-void setup_opengl( void )
+//========================================================================
+// Initialize Miscellaneous OpenGL state
+//========================================================================
+
+void init_opengl(void)
 {
-  /* Our shading model--Gouraud (smooth). */
-  glShadeModel(GL_SMOOTH);
+    // Use Gouraud (smooth) shading
+    glShadeModel(GL_SMOOTH);
 
-  /* Culling. */
-  //glCullFace(GL_BACK);
-  //glFrontFace(GL_CCW);
-  //glEnable(GL_CULL_FACE);
+    // Switch on the z-buffer
+    glEnable(GL_DEPTH_TEST);
 
-  /* Switch on the z-buffer. */
-  glEnable(GL_DEPTH_TEST);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), vertex);
+    glColorPointer(3, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r); // Pointer to the first color
 
-  glEnableClientState(GL_VERTEX_ARRAY);
-  glEnableClientState(GL_COLOR_ARRAY);
-  glVertexPointer(3/*3 components per vertex (x,y,z)*/, GL_FLOAT, sizeof(struct Vertex), vertex);
-  glColorPointer(3/*3 components per vertex (r,g,b)*/, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r);  //Pointer to the first color
-  glPointSize(2.0);
+    glPointSize(2.0);
 
-  /* Background color is black. */
-  glClearColor(0, 0, 0, 0);
+    // Background color is black
+    glClearColor(0, 0, 0, 0);
 }
 
 
-/* Modify the height of each vertex according to the pressure. */
-void adjustGrid( void )
-{
-  int pos;
-  int x, y;
+//========================================================================
+// Modify the height of each vertex according to the pressure
+//========================================================================
 
-  for(y = 0; y<GRIDH; y++)
-  {
-    for(x = 0; x<GRIDW; x++)
+void adjust_grid(void)
+{
+    int pos;
+    int x, y;
+
+    for (y = 0; y < GRIDH;  y++)
     {
-      pos = y*GRIDW + x;
-      vertex[pos].z = (float) (p[x][y]*(1.0/50.0));
+        for (x = 0;  x < GRIDW;  x++)
+        {
+            pos = y * GRIDW + x;
+            vertex[pos].z = (float) (p[x][y] * (1.0 / 50.0));
+        }
     }
-  }
 }
 
 
-/* Calculate wave propagation */
-void calc( void )
+//========================================================================
+// Calculate wave propagation
+//========================================================================
+
+void calc_grid(void)
 {
-  int    x, y, x2, y2;
-  double time_step = dt * ANIMATION_SPEED;
+    int x, y, x2, y2;
+    double time_step = dt * ANIMATION_SPEED;
 
-  /* compute accelerations */
-  for(x = 0; x < GRIDW; x++)
-  {
-    x2 = (x + 1) % GRIDW;
-    for(y = 0; y < GRIDH; y++)
+    // Compute accelerations
+    for (x = 0;  x < GRIDW;  x++)
     {
-      ax[x][y] = p[x][y] - p[x2][y];
+        x2 = (x + 1) % GRIDW;
+        for(y = 0; y < GRIDH; y++)
+            ax[x][y] = p[x][y] - p[x2][y];
     }
-  }
 
-  for(y = 0; y < GRIDH;y++)
-  {
-    y2 = (y + 1) % GRIDH;
-    for(x = 0; x < GRIDW; x++)
+    for (y = 0;  y < GRIDH;  y++)
     {
-      ay[x][y] = p[x][y] - p[x][y2];
+        y2 = (y + 1) % GRIDH;
+        for(x = 0; x < GRIDW; x++)
+            ay[x][y] = p[x][y] - p[x][y2];
     }
-  }
 
-  /* compute speeds */
-  for(x = 0; x < GRIDW; x++)
-  {
-    for(y = 0; y < GRIDH; y++)
+    // Compute speeds
+    for (x = 0;  x < GRIDW;  x++)
     {
-      vx[x][y] = vx[x][y] + ax[x][y] * time_step;
-      vy[x][y] = vy[x][y] + ay[x][y] * time_step;
+        for (y = 0;  y < GRIDH;  y++)
+        {
+            vx[x][y] = vx[x][y] + ax[x][y] * time_step;
+            vy[x][y] = vy[x][y] + ay[x][y] * time_step;
+        }
     }
-  }
 
-  /* compute pressure */
-  for(x = 1; x < GRIDW; x++)
-  {
-    x2 = x - 1;
-    for(y = 1; y < GRIDH; y++)
+    // Compute pressure
+    for (x = 1;  x < GRIDW;  x++)
     {
-      y2 = y - 1;
-      p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step;
+        x2 = x - 1;
+        for (y = 1;  y < GRIDH;  y++)
+        {
+            y2 = y - 1;
+            p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step;
+        }
     }
-  }
 }
 
 
-/* Handle key strokes */
-void handle_key_down(GLFWwindow window, int key, int action)
+//========================================================================
+// Handle key strokes
+//========================================================================
+
+void key_callback(GLFWwindow window, int key, int action)
 {
-  if( action != GLFW_PRESS )
-  {
-    return;
-  }
+    if (action != GLFW_PRESS)
+        return;
 
-  switch(key) {
-    case GLFW_KEY_ESC:
-      running = 0;
-      break;
-    case GLFW_KEY_SPACE:
-      initSurface();
-      break;
-    case GLFW_KEY_LEFT:
-      alpha+=5;
-      break;
-    case GLFW_KEY_RIGHT:
-      alpha-=5;
-      break;
-    case GLFW_KEY_UP:
-      beta-=5;
-      break;
-    case GLFW_KEY_DOWN:
-      beta+=5;
-      break;
-    case GLFW_KEY_PAGEUP:
-      if(zoom>1) zoom-=1;
-      break;
-    case GLFW_KEY_PAGEDOWN:
-      zoom+=1;
-      break;
-    default:
-      break;
-  }
+    switch (key)
+    {
+        case GLFW_KEY_ESC:
+            running = 0;
+            break;
+        case GLFW_KEY_SPACE:
+            init_grid();
+            break;
+        case GLFW_KEY_LEFT:
+            alpha += 5;
+            break;
+        case GLFW_KEY_RIGHT:
+            alpha -= 5;
+            break;
+        case GLFW_KEY_UP:
+            beta -= 5;
+            break;
+        case GLFW_KEY_DOWN:
+            beta += 5;
+            break;
+        case GLFW_KEY_PAGEUP:
+            if (zoom > 1)
+                zoom -= 1;
+            break;
+        case GLFW_KEY_PAGEDOWN:
+            zoom += 1;
+            break;
+        default:
+            break;
+    }
 }
 
 
-/* Callback function for window resize events */
-void handle_resize( GLFWwindow window, int width, int height )
+//========================================================================
+// Callback function for window resize events
+//========================================================================
+
+void window_resize_callback(GLFWwindow window, int width, int height)
 {
-  float ratio = 1.0f;
+    float ratio = 1.f;
 
-  if( height > 0 )
-  {
-      ratio = (float) width / (float) height;
-  }
+    if (height > 0)
+        ratio = (float) width / (float) height;
 
-  /* Setup viewport (Place where the stuff will appear in the main window). */
-  glViewport(0, 0, width, height);
+    // Setup viewport
+    glViewport(0, 0, width, height);
 
-  /*
-   * Change to the projection matrix and set
-   * our viewing volume.
-   */
-  glMatrixMode(GL_PROJECTION);
-  glLoadIdentity();
-  gluPerspective(60.0, ratio, 1.0, 1024.0);
+    // Change to the projection matrix and set our viewing volume
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(60.0, ratio, 1.0, 1024.0);
 }
 
 
-/* Program entry point */
+//========================================================================
+// main
+//========================================================================
+
 int main(int argc, char* argv[])
 {
-  /* Dimensions of our window. */
-  int width, height;
-  /* Style of our window. */
-  int mode;
-  /* Frame time */
-  double t, t_old, dt_total;
-  GLFWwindow window;
+    GLFWwindow window;
+    double t, dt_total, t_old;
 
-  /* Initialize GLFW */
-  if(glfwInit() == GL_FALSE)
-  {
-    fprintf(stderr, "GLFW initialization failed\n");
-    exit(-1);
-  }
-
-  /* Desired window properties */
-  width  = 640;
-  height = 480;
-  mode   = GLFW_WINDOWED;
-
-  glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
-
-  /* Open window */
-  window = glfwOpenWindow(width, height, mode, "Wave Simulation", NULL);
-  if (!window)
-  {
-    fprintf(stderr, "Could not open window\n");
-    glfwTerminate();
-    exit(-1);
-  }
-
-  glfwSwapInterval( 1 );
-
-  /* Keyboard handler */
-  glfwSetKeyCallback( window, handle_key_down );
-  glfwEnable( window, GLFW_KEY_REPEAT );
-
-  /* Window resize handler */
-  glfwSetWindowSizeCallback( window, handle_resize );
-
-  /* Initialize OpenGL */
-  setup_opengl();
-
-  /* Initialize simulation */
-  initVertices();
-  initSurface();
-  adjustGrid();
-
-  /* Initialize timer */
-  t_old = glfwGetTime() - 0.01;
-
-  /* Main loop */
-  while(running)
-  {
-    /* Timing */
-    t = glfwGetTime();
-    dt_total = t - t_old;
-    t_old = t;
-
-    /* Safety - iterate if dt_total is too large */
-    while( dt_total > 0.0f )
+    if (!glfwInit())
     {
-        /* Select iteration time step */
-        dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
-        dt_total -= dt;
-
-        /* Calculate wave propagation */
-        calc();
+        fprintf(stderr, "GLFW initialization failed\n");
+        exit(EXIT_FAILURE);
     }
 
-    /* Compute height of each vertex */
-    adjustGrid();
+    window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL);
+    if (!window)
+    {
+        fprintf(stderr, "Could not open window\n");
+        exit(EXIT_FAILURE);
+    }
 
-    /* Draw wave grid to OpenGL display */
-    draw_screen();
+    glfwSwapInterval(1);
 
-    glfwPollEvents();
+    // Keyboard handler
+    glfwSetKeyCallback(key_callback);
+    glfwEnable(window, GLFW_KEY_REPEAT);
 
-    /* Still running? */
-    running = running && glfwIsWindow( window );
-  }
+    // Window resize handler
+    glfwSetWindowSizeCallback(window_resize_callback);
 
-  glfwTerminate();
+    // Initialize OpenGL
+    init_opengl();
 
-  return 0;
+    // Initialize simulation
+    init_vertices();
+    init_grid();
+    adjust_grid();
+
+    // Initialize timer
+    t_old = glfwGetTime() - 0.01;
+
+    while (running)
+    {
+        t = glfwGetTime();
+        dt_total = t - t_old;
+        t_old = t;
+
+        // Safety - iterate if dt_total is too large
+        while (dt_total > 0.f)
+        {
+            // Select iteration time step
+            dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
+            dt_total -= dt;
+
+            // Calculate wave propagation
+            calc_grid();
+        }
+
+        // Compute height of each vertex
+        adjust_grid();
+
+        // Draw wave grid to OpenGL display
+        draw_scene();
+
+        glfwPollEvents();
+
+        // Still running?
+        running = running && glfwIsWindow(window);
+    }
+
+    exit(EXIT_SUCCESS);
 }
+
diff --git a/include/GL/glfw3.h b/include/GL/glfw3.h
index 08e0d006..e2316413 100644
--- a/include/GL/glfw3.h
+++ b/include/GL/glfw3.h
@@ -442,11 +442,11 @@ GLFWAPI void glfwRestoreWindow(GLFWwindow window);
 GLFWAPI int  glfwGetWindowParam(GLFWwindow window, int param);
 GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer);
 GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window);
-GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun);
-GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun);
-GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun);
-GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun);
-GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun);
+GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun);
+GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun);
+GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun);
+GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun);
+GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun);
 
 /* Event handling */
 GLFWAPI void glfwPollEvents(void);
@@ -458,11 +458,11 @@ GLFWAPI int  glfwGetMouseButton(GLFWwindow window, int button);
 GLFWAPI void glfwGetMousePos(GLFWwindow window, int* xpos, int* ypos);
 GLFWAPI void glfwSetMousePos(GLFWwindow window, int xpos, int ypos);
 GLFWAPI void glfwGetScrollOffset(GLFWwindow window, int* x, int* y);
-GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun);
-GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun);
-GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun);
-GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun);
-GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun);
+GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun);
+GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun);
+GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun);
+GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun);
+GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun);
 
 /* Joystick input */
 GLFWAPI int glfwGetJoystickParam(int joy, int param);
diff --git a/src/cocoa/CMakeLists.txt b/src/cocoa/CMakeLists.txt
index d8758ab6..8124c00b 100644
--- a/src/cocoa/CMakeLists.txt
+++ b/src/cocoa/CMakeLists.txt
@@ -1,42 +1,37 @@
 
-configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake 
-    ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake 
+               ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} 
                     ${GLFW_SOURCE_DIR}/src
                     ${GLFW_BINARY_DIR}/src
                     ${GLFW_INCLUDE_DIR})
 
-set(cocoa_SOURCES
-    cocoa_enable.m
-    cocoa_fullscreen.m
-    cocoa_gamma.m
-    cocoa_glext.m
-    cocoa_init.m
-    cocoa_joystick.m
-    cocoa_time.m
-    cocoa_window.m)
+set(cocoa_SOURCES cocoa_enable.m
+                  cocoa_fullscreen.m
+                  cocoa_gamma.m
+                  cocoa_glext.m
+                  cocoa_init.m
+                  cocoa_joystick.m
+                  cocoa_time.m
+                  cocoa_window.m)
 
 # For some reason, CMake doesn't know about .m
 set_source_files_properties(${cocoa_SOURCES} PROPERTIES LANGUAGE C)
 
-set(libglfw_SOURCES
-    ${common_SOURCES}
-    ${cocoa_SOURCES})
+set(libglfw_SOURCES ${common_SOURCES} ${cocoa_SOURCES})
 
 add_library(libglfwStatic STATIC ${libglfw_SOURCES})
 add_library(libglfwShared SHARED ${libglfw_SOURCES}) 
 target_link_libraries(libglfwShared  ${GLFW_LIBRARIES})
 set_target_properties(libglfwStatic libglfwShared PROPERTIES 
-    CLEAN_DIRECT_OUTPUT 1
-    OUTPUT_NAME glfw
-)
+                      CLEAN_DIRECT_OUTPUT 1
+                      OUTPUT_NAME glfw)
 
 # Append -fno-common to the compile flags to work around a bug in the Apple GCC
 get_target_property(CFLAGS libglfwShared COMPILE_FLAGS)
 if(NOT CFLAGS)
-  set(CFLAGS "")
+    set(CFLAGS "")
 endif(NOT CFLAGS)
 set_target_properties(libglfwShared PROPERTIES COMPILE_FLAGS "${CFLAGS} -fno-common")
 
diff --git a/src/cocoa/cocoa_window.m b/src/cocoa/cocoa_window.m
index eeb1a13a..2b389e4d 100644
--- a/src/cocoa/cocoa_window.m
+++ b/src/cocoa/cocoa_window.m
@@ -70,8 +70,8 @@
     window->width = contentRect.size.width;
     window->height = contentRect.size.height;
 
-    if (window->windowSizeCallback)
-        window->windowSizeCallback(window, window->width, window->height);
+    if (_glfwLibrary.windowSizeCallback)
+        _glfwLibrary.windowSizeCallback(window, window->width, window->height);
 }
 
 - (void)windowDidMove:(NSNotification *)notification
@@ -95,16 +95,16 @@
 {
     window->iconified = GL_TRUE;
 
-    if (window->windowIconifyCallback)
-        window->windowIconifyCallback(window, window->iconified);
+    if (_glfwLibrary.windowIconifyCallback)
+        _glfwLibrary.windowIconifyCallback(window, window->iconified);
 }
 
 - (void)windowDidDeminiaturize:(NSNotification *)notification
 {
     window->iconified = GL_FALSE;
 
-    if (window->windowIconifyCallback)
-        window->windowIconifyCallback(window, window->iconified);
+    if (_glfwLibrary.windowIconifyCallback)
+        _glfwLibrary.windowIconifyCallback(window, window->iconified);
 }
 
 - (void)windowDidBecomeKey:(NSNotification *)notification
@@ -362,8 +362,8 @@ static int convertMacKeyCode(unsigned int macKeyCode)
         window->mousePosY = [[window->NS.window contentView] bounds].size.height - p.y;
     }
 
-    if (window->mousePosCallback)
-        window->mousePosCallback(window, window->mousePosX, window->mousePosY);
+    if (_glfwLibrary.mousePosCallback)
+        _glfwLibrary.mousePosCallback(window, window->mousePosX, window->mousePosY);
 }
 
 - (void)rightMouseDown:(NSEvent *)event
diff --git a/src/enable.c b/src/enable.c
index 7a8534a1..60789290 100644
--- a/src/enable.c
+++ b/src/enable.c
@@ -54,11 +54,11 @@ static void enableMouseCursor(_GLFWwindow* window)
         window->mousePosX = centerPosX;
         window->mousePosY = centerPosY;
 
-        if (window->mousePosCallback)
+        if (_glfwLibrary.mousePosCallback)
         {
-            window->mousePosCallback(window,
-                                     window->mousePosX,
-                                     window->mousePosY);
+            _glfwLibrary.mousePosCallback(window,
+                                          window->mousePosX,
+                                          window->mousePosY);
         }
     }
 
diff --git a/src/gamma.c b/src/gamma.c
index ff97d600..b2416a98 100644
--- a/src/gamma.c
+++ b/src/gamma.c
@@ -82,7 +82,7 @@ GLFWAPI void glfwSetGammaFormula(float gamma, float blacklevel, float gain)
 
 
 //========================================================================
-// Return the currently set gamma ramp
+// Return the cached currently set gamma ramp
 //========================================================================
 
 GLFWAPI void glfwGetGammaRamp(GLFWgammaramp* ramp)
diff --git a/src/input.c b/src/input.c
index c5ad0c7b..8a61fbef 100644
--- a/src/input.c
+++ b/src/input.c
@@ -171,7 +171,7 @@ GLFWAPI void glfwGetScrollOffset(GLFWwindow window, int* x, int* y)
 // Set callback function for keyboard input
 //========================================================================
 
-GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun)
+GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -179,7 +179,7 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun)
         return;
     }
 
-    window->keyCallback = cbfun;
+    _glfwLibrary.keyCallback = cbfun;
 }
 
 
@@ -187,7 +187,7 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun)
 // Set callback function for character input
 //========================================================================
 
-GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun)
+GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -195,7 +195,7 @@ GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun)
         return;
     }
 
-    window->charCallback = cbfun;
+    _glfwLibrary.charCallback = cbfun;
 }
 
 
@@ -203,7 +203,7 @@ GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun)
 // Set callback function for mouse clicks
 //========================================================================
 
-GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun)
+GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -211,7 +211,7 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cb
         return;
     }
 
-    window->mouseButtonCallback = cbfun;
+    _glfwLibrary.mouseButtonCallback = cbfun;
 }
 
 
@@ -219,7 +219,7 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cb
 // Set callback function for mouse moves
 //========================================================================
 
-GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun)
+GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -228,12 +228,17 @@ GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun)
     }
 
     // Set callback function
-    window->mousePosCallback = cbfun;
+    _glfwLibrary.mousePosCallback = cbfun;
 
     // Call the callback function to let the application know the current
     // mouse position
     if (cbfun)
-        cbfun(window, window->mousePosX, window->mousePosY);
+    {
+        _GLFWwindow* window;
+
+        for (window = _glfwLibrary.windowListHead;  window;  window = window->next)
+            cbfun(window, window->mousePosX, window->mousePosY);
+    }
 }
 
 
@@ -241,7 +246,7 @@ GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun)
 // Set callback function for scroll events
 //========================================================================
 
-GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun)
+GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -250,11 +255,6 @@ GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun)
     }
 
     // Set callback function
-    window->scrollCallback = cbfun;
-
-    // Call the callback function to let the application know the current
-    // scroll offset
-    if (cbfun)
-        cbfun(window, window->scrollX, window->scrollY);
+    _glfwLibrary.scrollCallback = cbfun;
 }
 
diff --git a/src/internal.h b/src/internal.h
index a44ab51a..b064ebb5 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -152,18 +152,6 @@ struct _GLFWwindow
 {
     struct _GLFWwindow* next;
 
-    // User callback functions
-    GLFWwindowsizefun    windowSizeCallback;
-    GLFWwindowclosefun   windowCloseCallback;
-    GLFWwindowrefreshfun windowRefreshCallback;
-    GLFWwindowfocusfun   windowFocusCallback;
-    GLFWwindowiconifyfun windowIconifyCallback;
-    GLFWmousebuttonfun   mouseButtonCallback;
-    GLFWmouseposfun      mousePosCallback;
-    GLFWscrollfun        scrollCallback;
-    GLFWkeyfun           keyCallback;
-    GLFWcharfun          charCallback;
-
     // Window settings and state
     GLboolean iconified;       // GL_TRUE if this window is iconified
     GLboolean closeRequested;  // GL_TRUE if this window should be closed
@@ -223,6 +211,17 @@ struct _GLFWlibrary
     _GLFWwindow*  activeWindow;
     _GLFWwindow*  cursorLockWindow;
 
+    GLFWwindowsizefun    windowSizeCallback;
+    GLFWwindowclosefun   windowCloseCallback;
+    GLFWwindowrefreshfun windowRefreshCallback;
+    GLFWwindowfocusfun   windowFocusCallback;
+    GLFWwindowiconifyfun windowIconifyCallback;
+    GLFWmousebuttonfun   mouseButtonCallback;
+    GLFWmouseposfun      mousePosCallback;
+    GLFWscrollfun        scrollCallback;
+    GLFWkeyfun           keyCallback;
+    GLFWcharfun          charCallback;
+
     GLFWgammaramp currentRamp;
     GLFWgammaramp originalRamp;
     int           originalRampSize;
diff --git a/src/win32/CMakeLists.txt b/src/win32/CMakeLists.txt
index f7df1ff7..4886d7ba 100644
--- a/src/win32/CMakeLists.txt
+++ b/src/win32/CMakeLists.txt
@@ -1,8 +1,8 @@
 
 if(CYGWIN)
-    configure_file(
-	${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake 
-	${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
+
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake 
+	           ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
 
 # These lines are intended to remove the --export-all-symbols
 # flag added in the Modules/Platform/CYGWIN.cmake file of the
@@ -19,36 +19,36 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
                     ${GLFW_BINARY_DIR}/src
                     ${GLFW_INCLUDE_DIR})
 
-set(libglfw_SOURCES
-    ${common_SOURCES}
-    win32_enable.c 
-    win32_fullscreen.c
-    win32_gamma.c
-    win32_glext.c
-    win32_init.c 
-    win32_joystick.c
-    win32_time.c 
-    win32_window.c
-    win32_dllmain.c)
+set(libglfw_SOURCES ${common_SOURCES}
+                    win32_enable.c 
+                    win32_fullscreen.c
+                    win32_gamma.c
+                    win32_glext.c
+                    win32_init.c 
+                    win32_joystick.c
+                    win32_time.c 
+                    win32_window.c
+                    win32_dllmain.c)
 
 add_library(libglfwStatic STATIC ${libglfw_SOURCES})
 add_library(libglfwShared SHARED ${libglfw_SOURCES}) 
 
 target_link_libraries(libglfwShared ${OPENGL_gl_LIBRARY})
 set_target_properties(libglfwShared PROPERTIES 
-    DEFINE_SYMBOL GLFW_BUILD_DLL
-    PREFIX ""
-    IMPORT_PREFIX ""
-    IMPORT_SUFFIX "dll.lib")
+                      DEFINE_SYMBOL GLFW_BUILD_DLL
+                      PREFIX ""
+                      IMPORT_PREFIX ""
+                      IMPORT_SUFFIX "dll.lib")
 
 set_target_properties(libglfwStatic libglfwShared PROPERTIES 
-    CLEAN_DIRECT_OUTPUT 1
-    OUTPUT_NAME glfw)
+                      CLEAN_DIRECT_OUTPUT 1
+                      OUTPUT_NAME glfw)
 
 if(CYGWIN)
     # Build for the regular Win32 environment (not Cygwin)
-    set_target_properties(libglfwStatic libglfwShared PROPERTIES COMPILE_FLAGS "-mwin32 -mno-cygwin")
-    set_target_properties(libglfwStatic libglfwShared PROPERTIES LINK_FLAGS "-mwin32 -mno-cygwin")
+    set_target_properties(libglfwStatic libglfwShared PROPERTIES
+                          COMPILE_FLAGS "-mwin32 -mno-cygwin"
+                          LINK_FLAGS "-mwin32 -mno-cygwin")
 endif(CYGWIN)
 
 install(TARGETS libglfwStatic libglfwShared DESTINATION lib)
diff --git a/src/win32/platform.h b/src/win32/platform.h
index fb9107b8..3ce580f2 100644
--- a/src/win32/platform.h
+++ b/src/win32/platform.h
@@ -270,7 +270,6 @@ typedef struct _GLFWlibraryWin32
     ATOM      classAtom;       // Window class atom
     HHOOK     keyboardHook;    // Keyboard hook handle
     DWORD     foregroundLockTimeout;
-    HDC       desktopDC;
 
     // Default monitor
     struct {
diff --git a/src/win32/win32_gamma.c b/src/win32/win32_gamma.c
index 71d2645f..fc01cc44 100644
--- a/src/win32/win32_gamma.c
+++ b/src/win32/win32_gamma.c
@@ -1,11 +1,10 @@
 //========================================================================
 // GLFW - An OpenGL framework
 // Platform:    Win32/WGL
-// API version: 2.7
+// API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -33,35 +32,26 @@
 #include <limits.h>
 
 
-//************************************************************************
-//****                  GLFW internal functions                       ****
-//************************************************************************
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
 
 //========================================================================
-// Save the gamma ramp to our internal copy
+// Retrieve the currently set gamma ramp
 //========================================================================
 
-void _glfwPlatformSaveGammaRamp(int ramp)
+void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
 {
-    if (!_glfwLibrary.gammaSize)
-    {
-        return;
-    }
-    _glfw_GetDeviceGammaRamp(_glfwLibrary.Win32.desktopDC,
-                             _glfwLibrary.gammaRamp[ramp]);
+    _glfw_GetDeviceGammaRamp(GetDC(GetDesktopWindow()), (WORD*) ramp);
 }
 
 
 //========================================================================
-// Restore the gamma ramp to our internal copy of the gamma ramp
+// Push the specified gamma ramp to the monitor
 //========================================================================
 
-void _glfwPlatformRestoreGammaRamp(int ramp)
+void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp)
 {
-    if (!_glfwLibrary.gammaSize)
-    {
-        return;
-    }
-    _glfw_SetDeviceGammaRamp(_glfwLibrary.Win32.desktopDC,
-                             _glfwLibrary.gammaRamp[ramp]);
+    _glfw_SetDeviceGammaRamp(GetDC(GetDesktopWindow()), (WORD*) ramp);
 }
+
diff --git a/src/win32/win32_init.c b/src/win32/win32_init.c
index 54939cc3..4c8bfb22 100644
--- a/src/win32/win32_init.c
+++ b/src/win32/win32_init.c
@@ -160,18 +160,9 @@ int _glfwPlatformInit(void)
 
     _glfwLibrary.Win32.instance = GetModuleHandle(NULL);
 
-    // Initialise the internal gamma ramp
-    _glfwLibrary.gammaSize = 256;
-    _glfwLibrary.gammaRamp[GLFW_GAMMA_ORIG] =
-        malloc(256 * sizeof(unsigned short) * 3);
-    _glfwLibrary.gammaRamp[GLFW_GAMMA_CURR] =
-        malloc(256 * sizeof(unsigned short) * 3);
-
-    // Get the desktop DC
-    _glfwLibrary.Win32.desktopDC = GetDC(GetDesktopWindow());
-
     // Save the original gamma ramp
-    _glfwPlatformSaveGammaRamp(GLFW_GAMMA_ORIG);
+    _glfwLibrary.originalRampSize = 256;
+    _glfwPlatformGetGammaRamp(&_glfwLibrary.originalRamp);
 
     _glfwInitTimer();
 
@@ -186,11 +177,7 @@ int _glfwPlatformInit(void)
 int _glfwPlatformTerminate(void)
 {
     // Restore the original gamma ramp
-    _glfwPlatformRestoreGammaRamp(GLFW_GAMMA_ORIG);
-
-    // Free the gamma ramps
-    free(_glfwLibrary.gammaRamp[GLFW_GAMMA_ORIG]);
-    free(_glfwLibrary.gammaRamp[GLFW_GAMMA_CURR]);
+    _glfwPlatformSetGammaRamp(&_glfwLibrary.originalRamp);
 
     if (_glfwLibrary.Win32.classAtom)
     {
diff --git a/src/win32/win32_window.c b/src/win32/win32_window.c
index 059faa4b..07ae49d1 100644
--- a/src/win32/win32_window.c
+++ b/src/win32/win32_window.c
@@ -713,8 +713,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
             {
                 window->iconified = iconified;
 
-                if (window->windowIconifyCallback)
-                    window->windowIconifyCallback(window, window->iconified);
+                if (_glfwLibrary.windowIconifyCallback)
+                    _glfwLibrary.windowIconifyCallback(window, window->iconified);
             }
 
             return 0;
@@ -756,7 +756,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
         {
             _glfwInputKey(window, translateKey(wParam, lParam), GLFW_PRESS);
 
-            if (window->charCallback)
+            if (_glfwLibrary.charCallback)
                 translateChar(window, (DWORD) wParam, (DWORD) lParam);
 
             return 0;
@@ -879,11 +879,11 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
                 window->Win32.oldMouseY = newMouseY;
                 window->Win32.mouseMoved = GL_TRUE;
 
-                if (window->mousePosCallback)
+                if (_glfwLibrary.mousePosCallback)
                 {
-                    window->mousePosCallback(window,
-                                             window->mousePosX,
-                                             window->mousePosY);
+                    _glfwLibrary.mousePosCallback(window,
+                                                  window->mousePosX,
+                                                  window->mousePosY);
                 }
             }
 
@@ -917,8 +917,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
                     ClipCursor(&ClipWindowRect);
             }
 
-            if (window->windowSizeCallback)
-                window->windowSizeCallback(window, window->width, window->height);
+            if (_glfwLibrary.windowSizeCallback)
+                _glfwLibrary.windowSizeCallback(window, window->width, window->height);
 
             return 0;
         }
@@ -941,8 +941,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
         // Was the window contents damaged?
         case WM_PAINT:
         {
-            if (window->windowRefreshCallback)
-                window->windowRefreshCallback(window);
+            if (_glfwLibrary.windowRefreshCallback)
+                _glfwLibrary.windowRefreshCallback(window);
 
             break;
         }
diff --git a/src/window.c b/src/window.c
index 14b0c4dc..8b4a7903 100644
--- a/src/window.c
+++ b/src/window.c
@@ -55,8 +55,8 @@ static void closeFlaggedWindows(void)
 
     for (window = _glfwLibrary.windowListHead;  window; )
     {
-        if (window->closeRequested && window->windowCloseCallback)
-            window->closeRequested = window->windowCloseCallback(window);
+        if (window->closeRequested && _glfwLibrary.windowCloseCallback)
+            window->closeRequested = _glfwLibrary.windowCloseCallback(window);
 
         if (window->closeRequested)
         {
@@ -144,8 +144,8 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
     }
 
     // Call user callback function
-    if (window->keyCallback && (window->keyRepeat || !keyrepeat))
-        window->keyCallback(window, key, action);
+    if (_glfwLibrary.keyCallback && (window->keyRepeat || !keyrepeat))
+        _glfwLibrary.keyCallback(window, key, action);
 }
 
 
@@ -159,8 +159,8 @@ void _glfwInputChar(_GLFWwindow* window, int character)
     if (!((character >= 32 && character <= 126) || character >= 160))
         return;
 
-    if (window->charCallback)
-        window->charCallback(window, character);
+    if (_glfwLibrary.charCallback)
+        _glfwLibrary.charCallback(window, character);
 }
 
 
@@ -173,8 +173,8 @@ void _glfwInputScroll(_GLFWwindow* window, int x, int y)
     window->scrollX += x;
     window->scrollY += y;
 
-    if (window->scrollCallback)
-        window->scrollCallback(window, x, y);
+    if (_glfwLibrary.scrollCallback)
+        _glfwLibrary.scrollCallback(window, x, y);
 }
 
 
@@ -193,8 +193,8 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
     else
         window->mouseButton[button] = (char) action;
 
-    if (window->mouseButtonCallback)
-        window->mouseButtonCallback(window, button, action);
+    if (_glfwLibrary.mouseButtonCallback)
+        _glfwLibrary.mouseButtonCallback(window, button, action);
 }
 
 
@@ -210,8 +210,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
         {
             _glfwLibrary.activeWindow = window;
 
-            if (window->windowFocusCallback)
-                window->windowFocusCallback(window, activated);
+            if (_glfwLibrary.windowFocusCallback)
+                _glfwLibrary.windowFocusCallback(window, activated);
         }
     }
     else
@@ -236,8 +236,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
 
             _glfwLibrary.activeWindow = NULL;
 
-            if (window->windowFocusCallback)
-                window->windowFocusCallback(window, activated);
+            if (_glfwLibrary.windowFocusCallback)
+                _glfwLibrary.windowFocusCallback(window, activated);
         }
     }
 }
@@ -1076,7 +1076,7 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window)
 // Set callback function for window size changes
 //========================================================================
 
-GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun)
+GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -1084,19 +1084,24 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfu
         return;
     }
 
-    window->windowSizeCallback = cbfun;
+    _glfwLibrary.windowSizeCallback = cbfun;
 
     // Call the callback function to let the application know the current
     // window size
     if (cbfun)
-        cbfun(window, window->width, window->height);
+    {
+        _GLFWwindow* window;
+
+        for (window = _glfwLibrary.windowListHead;  window;  window = window->next)
+            cbfun(window, window->width, window->height);
+    }
 }
 
 //========================================================================
 // Set callback function for window close events
 //========================================================================
 
-GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun)
+GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -1104,7 +1109,7 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cb
         return;
     }
 
-    window->windowCloseCallback = cbfun;
+    _glfwLibrary.windowCloseCallback = cbfun;
 }
 
 
@@ -1112,7 +1117,7 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cb
 // Set callback function for window refresh events
 //========================================================================
 
-GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun)
+GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -1120,7 +1125,7 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfu
         return;
     }
 
-    window->windowRefreshCallback = cbfun;
+    _glfwLibrary.windowRefreshCallback = cbfun;
 }
 
 
@@ -1128,7 +1133,7 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfu
 // Set callback function for window focus events
 //========================================================================
 
-GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun)
+GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -1136,7 +1141,7 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cb
         return;
     }
 
-    window->windowFocusCallback = cbfun;
+    _glfwLibrary.windowFocusCallback = cbfun;
 }
 
 
@@ -1144,7 +1149,7 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cb
 // Set callback function for window iconification events
 //========================================================================
 
-GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun)
+GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun)
 {
     if (!_glfwInitialized)
     {
@@ -1152,7 +1157,7 @@ GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfu
         return;
     }
 
-    window->windowIconifyCallback = cbfun;
+    _glfwLibrary.windowIconifyCallback = cbfun;
 }
 
 
diff --git a/src/x11/CMakeLists.txt b/src/x11/CMakeLists.txt
index a75adf7b..4fe09c49 100644
--- a/src/x11/CMakeLists.txt
+++ b/src/x11/CMakeLists.txt
@@ -1,32 +1,29 @@
 
-configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake 
-    ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake 
+               ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} 
                     ${GLFW_SOURCE_DIR}/src
                     ${GLFW_BINARY_DIR}/src
                     ${GLFW_INCLUDE_DIR})
 
-set(libglfw_SOURCES
-    ${common_SOURCES}
-    x11_enable.c 
-    x11_fullscreen.c
-    x11_gamma.c
-    x11_glext.c
-    x11_init.c 
-    x11_joystick.c
-    x11_keysym2unicode.c
-    x11_time.c 
-    x11_window.c)
+set(libglfw_SOURCES ${common_SOURCES}
+                    x11_enable.c 
+                    x11_fullscreen.c
+                    x11_gamma.c
+                    x11_glext.c
+                    x11_init.c 
+                    x11_joystick.c
+                    x11_keysym2unicode.c
+                    x11_time.c 
+                    x11_window.c)
 
 add_library(libglfwStatic STATIC ${libglfw_SOURCES})
 add_library(libglfwShared SHARED ${libglfw_SOURCES}) 
 target_link_libraries(libglfwShared  ${GLFW_LIBRARIES})
 set_target_properties(libglfwStatic libglfwShared PROPERTIES 
-    CLEAN_DIRECT_OUTPUT 1
-    OUTPUT_NAME glfw
-)
+                      CLEAN_DIRECT_OUTPUT 1
+                      OUTPUT_NAME glfw)
 
 install(TARGETS libglfwStatic libglfwShared DESTINATION lib)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc DESTINATION lib/pkgconfig)
diff --git a/src/x11/x11_gamma.c b/src/x11/x11_gamma.c
index f80fc917..d0a32277 100644
--- a/src/x11/x11_gamma.c
+++ b/src/x11/x11_gamma.c
@@ -33,12 +33,12 @@
 #include <string.h>
 
 
-//************************************************************************
-//****                  GLFW internal functions                       ****
-//************************************************************************
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
 
 //========================================================================
-// Save the original gamma ramp so that we can restore it later
+// Retrieve the currently set gamma ramp
 //========================================================================
 
 void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
@@ -55,6 +55,8 @@ void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
         XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfwLibrary.X11.display,
                                               rr->crtcs[0]);
 
+        // TODO: Handle case of original ramp size having a size other than 256
+
         memcpy(ramp->red, gamma->red, size);
         memcpy(ramp->green, gamma->green, size);
         memcpy(ramp->blue, gamma->blue, size);
@@ -78,7 +80,7 @@ void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
 
 
 //========================================================================
-// Make the specified gamma ramp current
+// Push the specified gamma ramp to the monitor
 //========================================================================
 
 void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp)
diff --git a/src/x11/x11_init.c b/src/x11/x11_init.c
index 4290be7c..8f310e72 100644
--- a/src/x11/x11_init.c
+++ b/src/x11/x11_init.c
@@ -176,7 +176,7 @@ static void initGammaRamp(void)
 #endif /*_GLFW_HAS_XF86VIDMODE*/
 
     if (!_glfwLibrary.originalRampSize)
-        fprintf(stderr, "Gamma ramp setting unsupported\n");
+        fprintf(stderr, "No supported gamma ramp API found\n");
 
     // Save the original gamma ramp
     _glfwPlatformGetGammaRamp(&_glfwLibrary.originalRamp);
@@ -310,14 +310,14 @@ const char* _glfwPlatformGetVersionString(void)
 #elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
         " glXGetProcAddressEXT"
 #elif defined(_GLFW_DLOPEN_LIBGL)
-        " dlopen(libGL)"
+        " dlsym(libGL)"
 #else
         " (no OpenGL extension support)"
 #endif
 #if defined(_GLFW_USE_LINUX_JOYSTICKS)
-        " Linux joystick API"
+        " Linux-joystick-API"
 #else
-        " (no joystick support)"
+        " no-joystick-support"
 #endif
         ;
 
diff --git a/src/x11/x11_window.c b/src/x11/x11_window.c
index e83c8cbc..4b67bb41 100644
--- a/src/x11/x11_window.c
+++ b/src/x11/x11_window.c
@@ -1197,11 +1197,11 @@ static void processSingleEvent(void)
                 window->X11.cursorPosY = event.xmotion.y;
                 window->X11.mouseMoved = GL_TRUE;
 
-                if (window->mousePosCallback)
+                if (_glfwLibrary.mousePosCallback)
                 {
-                    window->mousePosCallback(window,
-                                             window->mousePosX,
-                                             window->mousePosY);
+                    _glfwLibrary.mousePosCallback(window,
+                                                  window->mousePosX,
+                                                  window->mousePosY);
                 }
             }
             break;
@@ -1224,11 +1224,11 @@ static void processSingleEvent(void)
 
                 window->width = event.xconfigure.width;
                 window->height = event.xconfigure.height;
-                if (window->windowSizeCallback)
+                if (_glfwLibrary.windowSizeCallback)
                 {
-                    window->windowSizeCallback(window,
-                                               window->width,
-                                               window->height);
+                    _glfwLibrary.windowSizeCallback(window,
+                                                    window->width,
+                                                    window->height);
                 }
             }
 
@@ -1288,8 +1288,8 @@ static void processSingleEvent(void)
 
             window->iconified = GL_FALSE;
 
-            if (window->windowIconifyCallback)
-                window->windowIconifyCallback(window, window->iconified);
+            if (_glfwLibrary.windowIconifyCallback)
+                _glfwLibrary.windowIconifyCallback(window, window->iconified);
 
             break;
         }
@@ -1306,8 +1306,8 @@ static void processSingleEvent(void)
 
             window->iconified = GL_TRUE;
 
-            if (window->windowIconifyCallback)
-                window->windowIconifyCallback(window, window->iconified);
+            if (_glfwLibrary.windowIconifyCallback)
+                _glfwLibrary.windowIconifyCallback(window, window->iconified);
 
             break;
         }
@@ -1358,8 +1358,8 @@ static void processSingleEvent(void)
                 return;
             }
 
-            if (window->windowRefreshCallback)
-                window->windowRefreshCallback(window);
+            if (_glfwLibrary.windowRefreshCallback)
+                _glfwLibrary.windowRefreshCallback(window);
 
             break;
         }
diff --git a/tests/accuracy.c b/tests/accuracy.c
index 08fdabe0..c3bebaca 100644
--- a/tests/accuracy.c
+++ b/tests/accuracy.c
@@ -74,8 +74,8 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
-    glfwSetMousePosCallback(window, mouse_position_callback);
-    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetMousePosCallback(mouse_position_callback);
+    glfwSetWindowSizeCallback(window_size_callback);
     glfwSwapInterval(1);
 
     glClearColor(0, 0, 0, 0);
diff --git a/tests/events.c b/tests/events.c
index 8da2b983..e6fda25e 100644
--- a/tests/events.c
+++ b/tests/events.c
@@ -303,16 +303,16 @@ int main(void)
 
     glfwSwapInterval(1);
 
-    glfwSetWindowSizeCallback(window, window_size_callback);
-    glfwSetWindowCloseCallback(window, window_close_callback);
-    glfwSetWindowRefreshCallback(window, window_refresh_callback);
-    glfwSetWindowFocusCallback(window, window_focus_callback);
-    glfwSetWindowIconifyCallback(window, window_iconify_callback);
-    glfwSetMouseButtonCallback(window, mouse_button_callback);
-    glfwSetMousePosCallback(window, mouse_position_callback);
-    glfwSetScrollCallback(window, scroll_callback);
-    glfwSetKeyCallback(window, key_callback);
-    glfwSetCharCallback(window, char_callback);
+    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowRefreshCallback(window_refresh_callback);
+    glfwSetWindowFocusCallback(window_focus_callback);
+    glfwSetWindowIconifyCallback(window_iconify_callback);
+    glfwSetMouseButtonCallback(mouse_button_callback);
+    glfwSetMousePosCallback(mouse_position_callback);
+    glfwSetScrollCallback(scroll_callback);
+    glfwSetKeyCallback(key_callback);
+    glfwSetCharCallback(char_callback);
 
     printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled");
     printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled");
diff --git a/tests/fsaa.c b/tests/fsaa.c
index 4c834aea..e5a187a0 100644
--- a/tests/fsaa.c
+++ b/tests/fsaa.c
@@ -65,7 +65,7 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
-    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetWindowSizeCallback(window_size_callback);
     glfwSwapInterval(1);
 
     samples = glfwGetWindowParam(window, GLFW_FSAA_SAMPLES);
diff --git a/tests/fsfocus.c b/tests/fsfocus.c
index a1cefc7d..21631f25 100644
--- a/tests/fsfocus.c
+++ b/tests/fsfocus.c
@@ -93,9 +93,9 @@ int main(void)
     glfwSwapInterval(1);
     glfwEnable(window, GLFW_MOUSE_CURSOR);
 
-    glfwSetWindowFocusCallback(window, window_focus_callback);
-    glfwSetKeyCallback(window, window_key_callback);
-    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowFocusCallback(window_focus_callback);
+    glfwSetKeyCallback(window_key_callback);
+    glfwSetWindowCloseCallback(window_close_callback);
 
     while (running && glfwIsWindow(window) == GL_TRUE)
     {
diff --git a/tests/gamma.c b/tests/gamma.c
index e918a156..0d2ff09b 100644
--- a/tests/gamma.c
+++ b/tests/gamma.c
@@ -149,8 +149,8 @@ int main(int argc, char** argv)
            ggamma, ggain, gblacklevel);
 
     glfwSwapInterval(1);
-    glfwSetKeyCallback(window, key_callback);
-    glfwSetWindowSizeCallback(window, size_callback);
+    glfwSetKeyCallback(key_callback);
+    glfwSetWindowSizeCallback(size_callback);
 
     glEnable(GL_SCISSOR_TEST);
 
diff --git a/tests/iconify.c b/tests/iconify.c
index b870bf95..6868c9ad 100644
--- a/tests/iconify.c
+++ b/tests/iconify.c
@@ -119,8 +119,8 @@ int main(int argc, char** argv)
     }
 
     glfwSwapInterval(1);
-    glfwSetKeyCallback(window, key_callback);
-    glfwSetWindowSizeCallback(window, size_callback);
+    glfwSetKeyCallback(key_callback);
+    glfwSetWindowSizeCallback(size_callback);
 
     glEnable(GL_SCISSOR_TEST);
 
diff --git a/tests/peter.c b/tests/peter.c
index 95ab744f..e2671248 100644
--- a/tests/peter.c
+++ b/tests/peter.c
@@ -96,9 +96,9 @@ static GLboolean open_window(void)
     glfwGetMousePos(window_handle, &x, &y);
     printf("Mouse position: %i %i\n", x, y);
 
-    glfwSetWindowSizeCallback(window_handle, window_size_callback);
-    glfwSetMousePosCallback(window_handle, mouse_position_callback);
-    glfwSetKeyCallback(window_handle, key_callback);
+    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetMousePosCallback(mouse_position_callback);
+    glfwSetKeyCallback(key_callback);
     glfwSwapInterval(1);
 
     return GL_TRUE;
diff --git a/tests/reopen.c b/tests/reopen.c
index 6f464af2..76f914ae 100644
--- a/tests/reopen.c
+++ b/tests/reopen.c
@@ -91,9 +91,9 @@ static int open_window(int width, int height, int mode)
         return 0;
     }
 
-    glfwSetWindowSizeCallback(window_handle, window_size_callback);
-    glfwSetWindowCloseCallback(window_handle, window_close_callback);
-    glfwSetKeyCallback(window_handle, key_callback);
+    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetKeyCallback(key_callback);
     glfwSwapInterval(1);
 
     printf("Opening %s mode window took %0.3f seconds\n",
diff --git a/tests/sharing.c b/tests/sharing.c
index 588e5f0b..b1b335c9 100644
--- a/tests/sharing.c
+++ b/tests/sharing.c
@@ -49,7 +49,7 @@ static GLFWwindow open_window(const char* title, GLFWwindow share)
     if (!window)
         return NULL;
 
-    glfwSetKeyCallback(window, key_callback);
+    glfwSetKeyCallback(key_callback);
     glfwSwapInterval(1);
 
     return window;
diff --git a/tests/tearing.c b/tests/tearing.c
index cd493d53..6e43e88f 100644
--- a/tests/tearing.c
+++ b/tests/tearing.c
@@ -59,7 +59,7 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
-    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetWindowSizeCallback(window_size_callback);
     glfwSwapInterval(1);
 
     glClearColor(0.f, 0.f, 0.f, 0.f);