clang-format -i **/*.[ch]

From here on, we’ll use clang-format to automatically format the source.

This has worked well in i3, so we are introducing it for i3lock.

7 files changed, 190 insertions, 195 deletions

diff --git a/cursors.h b/cursors.h
index 45a6ff2..bfce895 100644
--- a/cursors.h
+++ b/cursors.h
@@ -1,8 +1,8 @@
 #ifndef _CURSORS_H
 #define _CURSORS_H
 
-#define CURS_NONE    0
-#define CURS_WIN     1
+#define CURS_NONE 0
+#define CURS_WIN 1
 #define CURS_DEFAULT 2
 
 #endif
diff --git a/i3lock.c b/i3lock.c
index 7f8218e..69a1377 100644
--- a/i3lock.c
+++ b/i3lock.c
@@ -84,7 +84,7 @@ bool ignore_empty_password = false;
 bool skip_repeated_empty_password = false;
 
 /* isutf, u8_dec © 2005 Jeff Bezanson, public domain */
-#define isutf(c) (((c) & 0xC0) != 0x80)
+#define isutf(c) (((c)&0xC0) != 0x80)
 
 /*
  * Decrements i to point to the previous unicode glyph
@@ -181,7 +181,7 @@ static void clear_password_memory(void) {
         vpassword[c] = c + (int)beep;
 }
 
-ev_timer* start_timer(ev_timer *timer_obj, ev_tstamp timeout, ev_callback_t callback) {
+ev_timer *start_timer(ev_timer *timer_obj, ev_tstamp timeout, ev_callback_t callback) {
     if (timer_obj) {
         ev_timer_stop(main_loop, timer_obj);
         ev_timer_set(timer_obj, timeout, 0.);
@@ -198,7 +198,7 @@ ev_timer* start_timer(ev_timer *timer_obj, ev_tstamp timeout, ev_callback_t call
     return timer_obj;
 }
 
-ev_timer* stop_timer(ev_timer *timer_obj) {
+ev_timer *stop_timer(ev_timer *timer_obj) {
     if (timer_obj) {
         ev_timer_stop(main_loop, timer_obj);
         free(timer_obj);
@@ -326,20 +326,20 @@ static void handle_key_press(xcb_key_press_event_t *event) {
 
     if (xkb_compose_state && xkb_compose_state_feed(xkb_compose_state, ksym) == XKB_COMPOSE_FEED_ACCEPTED) {
         switch (xkb_compose_state_get_status(xkb_compose_state)) {
-        case XKB_COMPOSE_NOTHING:
-            break;
-        case XKB_COMPOSE_COMPOSING:
-            return;
-        case XKB_COMPOSE_COMPOSED:
-            /* xkb_compose_state_get_utf8 doesn't include the terminating byte in the return value
+            case XKB_COMPOSE_NOTHING:
+                break;
+            case XKB_COMPOSE_COMPOSING:
+                return;
+            case XKB_COMPOSE_COMPOSED:
+                /* xkb_compose_state_get_utf8 doesn't include the terminating byte in the return value
              * as xkb_keysym_to_utf8 does. Adding one makes the variable n consistent. */
-            n = xkb_compose_state_get_utf8(xkb_compose_state, buffer, sizeof(buffer)) + 1;
-            ksym = xkb_compose_state_get_one_sym(xkb_compose_state);
-            composed = true;
-            break;
-        case XKB_COMPOSE_CANCELLED:
-            xkb_compose_state_reset(xkb_compose_state);
-            return;
+                n = xkb_compose_state_get_utf8(xkb_compose_state, buffer, sizeof(buffer)) + 1;
+                ksym = xkb_compose_state_get_one_sym(xkb_compose_state);
+                composed = true;
+                break;
+            case XKB_COMPOSE_CANCELLED:
+                xkb_compose_state_reset(xkb_compose_state);
+                return;
         }
     }
 
@@ -348,54 +348,54 @@ static void handle_key_press(xcb_key_press_event_t *event) {
     }
 
     switch (ksym) {
-    case XKB_KEY_Return:
-    case XKB_KEY_KP_Enter:
-    case XKB_KEY_XF86ScreenSaver:
-        if (pam_state == STATE_PAM_WRONG)
-            return;
-
-        if (skip_without_validation()) {
-            clear_input();
+        case XKB_KEY_Return:
+        case XKB_KEY_KP_Enter:
+        case XKB_KEY_XF86ScreenSaver:
+            if (pam_state == STATE_PAM_WRONG)
+                return;
+
+            if (skip_without_validation()) {
+                clear_input();
+                return;
+            }
+            password[input_position] = '\0';
+            unlock_state = STATE_KEY_PRESSED;
+            redraw_screen();
+            input_done();
+            skip_repeated_empty_password = true;
             return;
-        }
-        password[input_position] = '\0';
-        unlock_state = STATE_KEY_PRESSED;
-        redraw_screen();
-        input_done();
-        skip_repeated_empty_password = true;
-        return;
-    default:
-        skip_repeated_empty_password = false;
+        default:
+            skip_repeated_empty_password = false;
     }
 
     switch (ksym) {
-    case XKB_KEY_u:
-        if (ctrl) {
-            DEBUG("C-u pressed\n");
+        case XKB_KEY_u:
+            if (ctrl) {
+                DEBUG("C-u pressed\n");
+                clear_input();
+                return;
+            }
+            break;
+
+        case XKB_KEY_Escape:
             clear_input();
             return;
-        }
-        break;
 
-    case XKB_KEY_Escape:
-        clear_input();
-        return;
-
-    case XKB_KEY_BackSpace:
-        if (input_position == 0)
-            return;
+        case XKB_KEY_BackSpace:
+            if (input_position == 0)
+                return;
 
-        /* decrement input_position to point to the previous glyph */
-        u8_dec(password, &input_position);
-        password[input_position] = '\0';
+            /* decrement input_position to point to the previous glyph */
+            u8_dec(password, &input_position);
+            password[input_position] = '\0';
 
-        /* Hide the unlock indicator after a bit if the password buffer is
+            /* Hide the unlock indicator after a bit if the password buffer is
          * empty. */
-        START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb);
-        unlock_state = STATE_BACKSPACE_ACTIVE;
-        redraw_screen();
-        unlock_state = STATE_KEY_PRESSED;
-        return;
+            START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb);
+            unlock_state = STATE_BACKSPACE_ACTIVE;
+            redraw_screen();
+            unlock_state = STATE_KEY_PRESSED;
+            return;
     }
 
     if ((input_position + 8) >= sizeof(password))
@@ -416,8 +416,8 @@ static void handle_key_press(xcb_key_press_event_t *event) {
         return;
 
     /* store it in the password array as UTF-8 */
-    memcpy(password+input_position, buffer, n-1);
-    input_position += n-1;
+    memcpy(password + input_position, buffer, n - 1);
+    input_position += n - 1;
     DEBUG("current password = %.*s\n", input_position, password);
 
     unlock_state = STATE_KEY_ACTIVE;
@@ -440,9 +440,9 @@ static void handle_key_press(xcb_key_press_event_t *event) {
  *
  */
 static void handle_visibility_notify(xcb_connection_t *conn,
-    xcb_visibility_notify_event_t *event) {
+                                     xcb_visibility_notify_event_t *event) {
     if (event->state != XCB_VISIBILITY_UNOBSCURED) {
-        uint32_t values[] = { XCB_STACK_MODE_ABOVE };
+        uint32_t values[] = {XCB_STACK_MODE_ABOVE};
         xcb_configure_window(conn, event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
         xcb_flush(conn);
     }
@@ -467,7 +467,7 @@ static void process_xkb_event(xcb_generic_event_t *gevent) {
         xcb_xkb_new_keyboard_notify_event_t new_keyboard_notify;
         xcb_xkb_map_notify_event_t map_notify;
         xcb_xkb_state_notify_event_t state_notify;
-    } *event = (union xkb_event*)gevent;
+    } *event = (union xkb_event *)gevent;
 
     DEBUG("process_xkb_event for device %d\n", event->any.deviceID);
 
@@ -540,8 +540,7 @@ void handle_screen_resize(void) {
  *
  */
 static int conv_callback(int num_msg, const struct pam_message **msg,
-                         struct pam_response **resp, void *appdata_ptr)
-{
+                         struct pam_response **resp, void *appdata_ptr) {
     if (num_msg == 0)
         return 1;
 
@@ -597,7 +596,7 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
 
     while ((event = xcb_poll_for_event(conn)) != NULL) {
         if (event->response_type == 0) {
-            xcb_generic_error_t *error = (xcb_generic_error_t*)event;
+            xcb_generic_error_t *error = (xcb_generic_error_t *)event;
             if (debug_mode)
                 fprintf(stderr, "X11 Error received! sequence 0x%x, error_code = %d\n",
                         error->sequence, error->error_code);
@@ -610,7 +609,7 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
 
         switch (type) {
             case XCB_KEY_PRESS:
-                handle_key_press((xcb_key_press_event_t*)event);
+                handle_key_press((xcb_key_press_event_t *)event);
                 break;
 
             case XCB_KEY_RELEASE:
@@ -623,7 +622,7 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
                 break;
 
             case XCB_VISIBILITY_NOTIFY:
-                handle_visibility_notify(conn, (xcb_visibility_notify_event_t*)event);
+                handle_visibility_notify(conn, (xcb_visibility_notify_event_t *)event);
                 break;
 
             case XCB_MAP_NOTIFY:
@@ -670,18 +669,17 @@ static void raise_loop(xcb_window_t window) {
 
     /* We need to know about the window being obscured or getting destroyed. */
     xcb_change_window_attributes(conn, window, XCB_CW_EVENT_MASK,
-        (uint32_t[]){
-            XCB_EVENT_MASK_VISIBILITY_CHANGE |
-            XCB_EVENT_MASK_STRUCTURE_NOTIFY
-        });
+                                 (uint32_t[]){
+                                     XCB_EVENT_MASK_VISIBILITY_CHANGE |
+                                     XCB_EVENT_MASK_STRUCTURE_NOTIFY});
     xcb_flush(conn);
 
     DEBUG("Watching window 0x%08x\n", window);
     while ((event = xcb_wait_for_event(conn)) != NULL) {
         if (event->response_type == 0) {
-            xcb_generic_error_t *error = (xcb_generic_error_t*)event;
+            xcb_generic_error_t *error = (xcb_generic_error_t *)event;
             DEBUG("X11 Error received! sequence 0x%x, error_code = %d\n",
-                 error->sequence, error->error_code);
+                  error->sequence, error->error_code);
             free(event);
             continue;
         }
@@ -690,16 +688,16 @@ static void raise_loop(xcb_window_t window) {
         DEBUG("Read event of type %d\n", type);
         switch (type) {
             case XCB_VISIBILITY_NOTIFY:
-                handle_visibility_notify(conn, (xcb_visibility_notify_event_t*)event);
+                handle_visibility_notify(conn, (xcb_visibility_notify_event_t *)event);
                 break;
             case XCB_UNMAP_NOTIFY:
-                DEBUG("UnmapNotify for 0x%08x\n", (((xcb_unmap_notify_event_t*)event)->window));
-                if (((xcb_unmap_notify_event_t*)event)->window == window)
+                DEBUG("UnmapNotify for 0x%08x\n", (((xcb_unmap_notify_event_t *)event)->window));
+                if (((xcb_unmap_notify_event_t *)event)->window == window)
                     exit(EXIT_SUCCESS);
                 break;
             case XCB_DESTROY_NOTIFY:
-                DEBUG("DestroyNotify for 0x%08x\n", (((xcb_destroy_notify_event_t*)event)->window));
-                if (((xcb_destroy_notify_event_t*)event)->window == window)
+                DEBUG("DestroyNotify for 0x%08x\n", (((xcb_destroy_notify_event_t *)event)->window));
+                if (((xcb_destroy_notify_event_t *)event)->window == window)
                     exit(EXIT_SUCCESS);
                 break;
             default:
@@ -725,7 +723,7 @@ int main(int argc, char *argv[]) {
         {"beep", no_argument, NULL, 'b'},
         {"dpms", no_argument, NULL, 'd'},
         {"color", required_argument, NULL, 'c'},
-        {"pointer", required_argument, NULL , 'p'},
+        {"pointer", required_argument, NULL, 'p'},
         {"debug", no_argument, NULL, 0},
         {"help", no_argument, NULL, 'h'},
         {"no-unlock-indicator", no_argument, NULL, 'u'},
@@ -734,8 +732,7 @@ int main(int argc, char *argv[]) {
         {"ignore-empty-password", no_argument, NULL, 'e'},
         {"inactivity-timeout", required_argument, NULL, 'I'},
         {"show-failed-attempts", no_argument, NULL, 'f'},
-        {NULL, no_argument, NULL, 0}
-    };
+        {NULL, no_argument, NULL, 0}};
 
     if ((pw = getpwuid(getuid())) == NULL)
         err(EXIT_FAILURE, "getpwuid() failed");
@@ -745,68 +742,67 @@ int main(int argc, char *argv[]) {
     char *optstring = "hvnbdc:p:ui:teI:f";
     while ((o = getopt_long(argc, argv, optstring, longopts, &optind)) != -1) {
         switch (o) {
-        case 'v':
-            errx(EXIT_SUCCESS, "version " VERSION " © 2010-2012 Michael Stapelberg");
-        case 'n':
-            dont_fork = true;
-            break;
-        case 'b':
-            beep = true;
-            break;
-        case 'd':
-            dpms = true;
-            break;
-        case 'I': {
-            int time = 0;
-            if (sscanf(optarg, "%d", &time) != 1 || time < 0)
-                errx(EXIT_FAILURE, "invalid timeout, it must be a positive integer\n");
-            inactivity_timeout = time;
-            break;
-        }
-        case 'c': {
-            char *arg = optarg;
+            case 'v':
+                errx(EXIT_SUCCESS, "version " VERSION " © 2010-2012 Michael Stapelberg");
+            case 'n':
+                dont_fork = true;
+                break;
+            case 'b':
+                beep = true;
+                break;
+            case 'd':
+                dpms = true;
+                break;
+            case 'I': {
+                int time = 0;
+                if (sscanf(optarg, "%d", &time) != 1 || time < 0)
+                    errx(EXIT_FAILURE, "invalid timeout, it must be a positive integer\n");
+                inactivity_timeout = time;
+                break;
+            }
+            case 'c': {
+                char *arg = optarg;
 
-            /* Skip # if present */
-            if (arg[0] == '#')
-                arg++;
+                /* Skip # if present */
+                if (arg[0] == '#')
+                    arg++;
 
-            if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1)
-                errx(EXIT_FAILURE, "color is invalid, it must be given in 3-byte hexadecimal format: rrggbb\n");
+                if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1)
+                    errx(EXIT_FAILURE, "color is invalid, it must be given in 3-byte hexadecimal format: rrggbb\n");
 
-            break;
-        }
-        case 'u':
-            unlock_indicator = false;
-            break;
-        case 'i':
-            image_path = strdup(optarg);
-            break;
-        case 't':
-            tile = true;
-            break;
-        case 'p':
-            if (!strcmp(optarg, "win")) {
-                curs_choice = CURS_WIN;
-            } else if (!strcmp(optarg, "default")) {
-                curs_choice = CURS_DEFAULT;
-            } else {
-                errx(EXIT_FAILURE, "i3lock: Invalid pointer type given. Expected one of \"win\" or \"default\".\n");
+                break;
             }
-            break;
-        case 'e':
-            ignore_empty_password = true;
-            break;
-        case 0:
-            if (strcmp(longopts[optind].name, "debug") == 0)
-                debug_mode = true;
-            break;
-        case 'f':
-            show_failed_attempts = true;
-            break;
-        default:
-            errx(EXIT_FAILURE, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default]"
-            " [-i image.png] [-t] [-e] [-I] [-f]"
-            );
+            case 'u':
+                unlock_indicator = false;
+                break;
+            case 'i':
+                image_path = strdup(optarg);
+                break;
+            case 't':
+                tile = true;
+                break;
+            case 'p':
+                if (!strcmp(optarg, "win")) {
+                    curs_choice = CURS_WIN;
+                } else if (!strcmp(optarg, "default")) {
+                    curs_choice = CURS_DEFAULT;
+                } else {
+                    errx(EXIT_FAILURE, "i3lock: Invalid pointer type given. Expected one of \"win\" or \"default\".\n");
+                }
+                break;
+            case 'e':
+                ignore_empty_password = true;
+                break;
+            case 0:
+                if (strcmp(longopts[optind].name, "debug") == 0)
+                    debug_mode = true;
+                break;
+            case 'f':
+                show_failed_attempts = true;
+                break;
+            default:
+                errx(EXIT_FAILURE, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default]"
+                                   " [-i image.png] [-t] [-e] [-I] [-f]");
         }
     }
 
@@ -837,13 +833,13 @@ int main(int argc, char *argv[]) {
         errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
 
     if (xkb_x11_setup_xkb_extension(conn,
-            XKB_X11_MIN_MAJOR_XKB_VERSION,
-            XKB_X11_MIN_MINOR_XKB_VERSION,
-            0,
-            NULL,
-            NULL,
-            &xkb_base_event,
-            &xkb_base_error) != 1)
+                                    XKB_X11_MIN_MAJOR_XKB_VERSION,
+                                    XKB_X11_MIN_MINOR_XKB_VERSION,
+                                    0,
+                                    NULL,
+                                    NULL,
+                                    &xkb_base_event,
+                                    &xkb_base_error) != 1)
         errx(EXIT_FAILURE, "Could not setup XKB extension.");
 
     static const xcb_xkb_map_part_t required_map_parts =
@@ -910,7 +906,7 @@ int main(int argc, char *argv[]) {
     last_resolution[1] = screen->height_in_pixels;
 
     xcb_change_window_attributes(conn, screen->root, XCB_CW_EVENT_MASK,
-            (uint32_t[]){ XCB_EVENT_MASK_STRUCTURE_NOTIFY });
+                                 (uint32_t[]){XCB_EVENT_MASK_STRUCTURE_NOTIFY});
 
     if (image_path) {
         /* Create a pixmap to render on, fill it with the background color */
diff --git a/i3lock.h b/i3lock.h
index 3e336ad..57190e5 100644
--- a/i3lock.h
+++ b/i3lock.h
@@ -5,9 +5,10 @@
  * This is important because xautolock (for example) closes stdout/stderr by
  * default, so just printing something to stdout will lead to the data ending
  * up on the X11 socket (!). */
-#define DEBUG(fmt, ...) do { \
-    if (debug_mode) \
-        printf("[i3lock-debug] " fmt, ##__VA_ARGS__); \
-} while (0)
+#define DEBUG(fmt, ...)                                   \
+    do {                                                  \
+        if (debug_mode)                                   \
+            printf("[i3lock-debug] " fmt, ##__VA_ARGS__); \
+    } while (0)
 
 #endif
diff --git a/unlock_indicator.c b/unlock_indicator.c
index e543f96..f1cdfb4 100644
--- a/unlock_indicator.c
+++ b/unlock_indicator.c
@@ -151,10 +151,10 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
          * (currently verifying, wrong password, or default) */
         switch (pam_state) {
             case STATE_PAM_VERIFY:
-                cairo_set_source_rgba(ctx, 0, 114.0/255, 255.0/255, 0.75);
+                cairo_set_source_rgba(ctx, 0, 114.0 / 255, 255.0 / 255, 0.75);
                 break;
             case STATE_PAM_WRONG:
-                cairo_set_source_rgba(ctx, 250.0/255, 0, 0, 0.75);
+                cairo_set_source_rgba(ctx, 250.0 / 255, 0, 0, 0.75);
                 break;
             default:
                 cairo_set_source_rgba(ctx, 0, 0, 0, 0.75);
@@ -164,13 +164,13 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
 
         switch (pam_state) {
             case STATE_PAM_VERIFY:
-                cairo_set_source_rgb(ctx, 51.0/255, 0, 250.0/255);
+                cairo_set_source_rgb(ctx, 51.0 / 255, 0, 250.0 / 255);
                 break;
             case STATE_PAM_WRONG:
-                cairo_set_source_rgb(ctx, 125.0/255, 51.0/255, 0);
+                cairo_set_source_rgb(ctx, 125.0 / 255, 51.0 / 255, 0);
                 break;
             case STATE_PAM_IDLE:
-                cairo_set_source_rgb(ctx, 51.0/255, 125.0/255, 0);
+                cairo_set_source_rgb(ctx, 51.0 / 255, 125.0 / 255, 0);
                 break;
         }
         cairo_stroke(ctx);
@@ -203,7 +203,7 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
                 text = "wrong!";
                 break;
             default:
-                if (show_failed_attempts && failed_attempts > 0){
+                if (show_failed_attempts && failed_attempts > 0) {
                     if (failed_attempts > 999) {
                         text = "> 999";
                     } else {
@@ -244,10 +244,10 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
                       highlight_start + (M_PI / 3.0));
             if (unlock_state == STATE_KEY_ACTIVE) {
                 /* For normal keys, we use a lighter green. */
-                cairo_set_source_rgb(ctx, 51.0/255, 219.0/255, 0);
+                cairo_set_source_rgb(ctx, 51.0 / 255, 219.0 / 255, 0);
             } else {
                 /* For backspace, we use red. */
-                cairo_set_source_rgb(ctx, 219.0/255, 51.0/255, 0);
+                cairo_set_source_rgb(ctx, 219.0 / 255, 51.0 / 255, 0);
             }
             cairo_stroke(ctx);
 
@@ -304,7 +304,7 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
  */
 void redraw_screen(void) {
     xcb_pixmap_t bg_pixmap = draw_image(last_resolution);
-    xcb_change_window_attributes(conn, win, XCB_CW_BACK_PIXMAP, (uint32_t[1]){ bg_pixmap });
+    xcb_change_window_attributes(conn, win, XCB_CW_BACK_PIXMAP, (uint32_t[1]){bg_pixmap});
     /* XXX: Possible optimization: Only update the area in the middle of the
      * screen instead of the whole screen. */
     xcb_clear_area(conn, 0, win, 0, 0, last_resolution[0], last_resolution[1]);
@@ -320,6 +320,7 @@ void redraw_screen(void) {
 void clear_indicator(void) {
     if (input_position == 0) {
         unlock_state = STATE_STARTED;
-    } else unlock_state = STATE_KEY_PRESSED;
+    } else
+        unlock_state = STATE_KEY_PRESSED;
     redraw_screen();
 }
diff --git a/unlock_indicator.h b/unlock_indicator.h
index 0f57a86..d08fd0c 100644
--- a/unlock_indicator.h
+++ b/unlock_indicator.h
@@ -2,18 +2,18 @@
 #define _UNLOCK_INDICATOR_H
 
 typedef enum {
-    STATE_STARTED = 0,          /* default state */
-    STATE_KEY_PRESSED = 1,      /* key was pressed, show unlock indicator */
-    STATE_KEY_ACTIVE = 2,       /* a key was pressed recently, highlight part
+    STATE_STARTED = 0,         /* default state */
+    STATE_KEY_PRESSED = 1,     /* key was pressed, show unlock indicator */
+    STATE_KEY_ACTIVE = 2,      /* a key was pressed recently, highlight part
                                    of the unlock indicator. */
-    STATE_BACKSPACE_ACTIVE = 3  /* backspace was pressed recently, highlight
+    STATE_BACKSPACE_ACTIVE = 3 /* backspace was pressed recently, highlight
                                    part of the unlock indicator in red. */
 } unlock_state_t;
 
 typedef enum {
-    STATE_PAM_IDLE = 0,         /* no PAM interaction at the moment */
-    STATE_PAM_VERIFY = 1,       /* currently verifying the password via PAM */
-    STATE_PAM_WRONG = 2         /* the password was wrong */
+    STATE_PAM_IDLE = 0,   /* no PAM interaction at the moment */
+    STATE_PAM_VERIFY = 1, /* currently verifying the password via PAM */
+    STATE_PAM_WRONG = 2   /* the password was wrong */
 } pam_state_t;
 
 xcb_pixmap_t draw_image(uint32_t* resolution);
diff --git a/xcb.c b/xcb.c
index fc27d0b..6731137 100644
--- a/xcb.c
+++ b/xcb.c
@@ -28,25 +28,25 @@ xcb_screen_t *screen;
 #define curs_invisible_height 8
 
 static unsigned char curs_invisible_bits[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
 #define curs_windows_width 11
 #define curs_windows_height 19
 
 static unsigned char curs_windows_bits[] = {
- 0xfe, 0x07, 0xfc, 0x07, 0xfa, 0x07, 0xf6, 0x07, 0xee, 0x07, 0xde, 0x07,
- 0xbe, 0x07, 0x7e, 0x07, 0xfe, 0x06, 0xfe, 0x05, 0x3e, 0x00, 0xb6, 0x07,
- 0x6a, 0x07, 0x6c, 0x07, 0xde, 0x06, 0xdf, 0x06, 0xbf, 0x05, 0xbf, 0x05,
- 0x7f, 0x06 };
+    0xfe, 0x07, 0xfc, 0x07, 0xfa, 0x07, 0xf6, 0x07, 0xee, 0x07, 0xde, 0x07,
+    0xbe, 0x07, 0x7e, 0x07, 0xfe, 0x06, 0xfe, 0x05, 0x3e, 0x00, 0xb6, 0x07,
+    0x6a, 0x07, 0x6c, 0x07, 0xde, 0x06, 0xdf, 0x06, 0xbf, 0x05, 0xbf, 0x05,
+    0x7f, 0x06};
 
 #define mask_windows_width 11
 #define mask_windows_height 19
 
 static unsigned char mask_windows_bits[] = {
- 0x01, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3f, 0x00,
- 0x7f, 0x00, 0xff, 0x00, 0xff, 0x01, 0xff, 0x03, 0xff, 0x07, 0x7f, 0x00,
- 0xf7, 0x00, 0xf3, 0x00, 0xe1, 0x01, 0xe0, 0x01, 0xc0, 0x03, 0xc0, 0x03,
- 0x80, 0x01 };
+    0x01, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3f, 0x00,
+    0x7f, 0x00, 0xff, 0x00, 0xff, 0x01, 0xff, 0x03, 0xff, 0x07, 0x7f, 0x00,
+    0xf7, 0x00, 0xf3, 0x00, 0xe1, 0x01, 0xe0, 0x01, 0xc0, 0x03, 0xc0, 0x03,
+    0x80, 0x01};
 
 static uint32_t get_colorpixel(char *hex) {
     char strgroups[3][3] = {{hex[0], hex[1], '\0'},
@@ -67,7 +67,6 @@ xcb_visualtype_t *get_root_visual_type(xcb_screen_t *screen) {
     for (depth_iter = xcb_screen_allowed_depths_iterator(screen);
          depth_iter.rem;
          xcb_depth_next(&depth_iter)) {
-
         for (visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
              visual_iter.rem;
              xcb_visualtype_next(&visual_iter)) {
@@ -82,7 +81,7 @@ xcb_visualtype_t *get_root_visual_type(xcb_screen_t *screen) {
     return NULL;
 }
 
-xcb_pixmap_t create_bg_pixmap(xcb_connection_t *conn, xcb_screen_t *scr, u_int32_t* resolution, char *color) {
+xcb_pixmap_t create_bg_pixmap(xcb_connection_t *conn, xcb_screen_t *scr, u_int32_t *resolution, char *color) {
     xcb_pixmap_t bg_pixmap = xcb_generate_id(conn);
     xcb_create_pixmap(conn, scr->root_depth, bg_pixmap, scr->root,
                       resolution[0], resolution[1]);
@@ -90,9 +89,9 @@ xcb_pixmap_t create_bg_pixmap(xcb_connection_t *conn, xcb_screen_t *scr, u_int32
     /* Generate a Graphics Context and fill the pixmap with background color
      * (for images that are smaller than your screen) */
     xcb_gcontext_t gc = xcb_generate_id(conn);
-    uint32_t values[] = { get_colorpixel(color) };
+    uint32_t values[] = {get_colorpixel(color)};
     xcb_create_gc(conn, gc, bg_pixmap, XCB_GC_FOREGROUND, values);
-    xcb_rectangle_t rect = { 0, 0, resolution[0], resolution[1] };
+    xcb_rectangle_t rect = {0, 0, resolution[0], resolution[1]};
     xcb_poly_fill_rectangle(conn, bg_pixmap, gc, 1, &rect);
     xcb_free_gc(conn, gc);
 
@@ -124,12 +123,12 @@ xcb_window_t open_fullscreen_window(xcb_connection_t *conn, xcb_screen_t *scr, c
 
     xcb_create_window(conn,
                       XCB_COPY_FROM_PARENT,
-                      win, /* the window id */
+                      win,       /* the window id */
                       scr->root, /* parent == root */
                       0, 0,
                       scr->width_in_pixels,
                       scr->height_in_pixels, /* dimensions */
-                      0, /* border = 0, we draw our own */
+                      0,                     /* border = 0, we draw our own */
                       XCB_WINDOW_CLASS_INPUT_OUTPUT,
                       XCB_WINDOW_CLASS_COPY_FROM_PARENT, /* copy visual from parent */
                       mask,
@@ -188,8 +187,7 @@ void grab_pointer_and_keyboard(xcb_connection_t *conn, xcb_screen_t *screen, xcb
             XCB_GRAB_MODE_ASYNC, /* keyboard mode */
             XCB_NONE,            /* confine_to = in which window should the cursor stay */
             cursor,              /* we change the cursor to whatever the user wanted */
-            XCB_CURRENT_TIME
-        );
+            XCB_CURRENT_TIME);
 
         if ((preply = xcb_grab_pointer_reply(conn, pcookie, NULL)) &&
             preply->status == XCB_GRAB_STATUS_SUCCESS) {
@@ -204,12 +202,11 @@ void grab_pointer_and_keyboard(xcb_connection_t *conn, xcb_screen_t *screen, xcb
     while (tries-- > 0) {
         kcookie = xcb_grab_keyboard(
             conn,
-            true,                /* report events */
-            screen->root,        /* grab the root window */
+            true,         /* report events */
+            screen->root, /* grab the root window */
             XCB_CURRENT_TIME,
             XCB_GRAB_MODE_ASYNC, /* process events as normal, do not require sync */
-            XCB_GRAB_MODE_ASYNC
-        );
+            XCB_GRAB_MODE_ASYNC);
 
         if ((kreply = xcb_grab_keyboard_reply(conn, kcookie, NULL)) &&
             kreply->status == XCB_GRAB_STATUS_SUCCESS) {
@@ -230,8 +227,8 @@ xcb_cursor_t create_cursor(xcb_connection_t *conn, xcb_screen_t *screen, xcb_win
     xcb_pixmap_t mask;
     xcb_cursor_t cursor;
 
-    unsigned char* curs_bits;
-    unsigned char* mask_bits;
+    unsigned char *curs_bits;
+    unsigned char *mask_bits;
     int curs_w, curs_h;
 
     switch (choice) {
@@ -278,9 +275,9 @@ xcb_cursor_t create_cursor(xcb_connection_t *conn, xcb_screen_t *screen, xcb_win
                       cursor,
                       bitmap,
                       mask,
-                      65535,65535,65535,
-                      0,0,0,
-                      0,0);
+                      65535, 65535, 65535,
+                      0, 0, 0,
+                      0, 0);
 
     xcb_free_pixmap(conn, bitmap);
     xcb_free_pixmap(conn, mask);
diff --git a/xinerama.c b/xinerama.c
index 47a35f9..7d4b2e7 100644
--- a/xinerama.c
+++ b/xinerama.c
@@ -82,8 +82,8 @@ void xinerama_query_screens(void) {
         xr_resolutions[screen].width = screen_info[screen].width;
         xr_resolutions[screen].height = screen_info[screen].height;
         DEBUG("found Xinerama screen: %d x %d at %d x %d\n",
-                        screen_info[screen].width, screen_info[screen].height,
-                        screen_info[screen].x_org, screen_info[screen].y_org);
+              screen_info[screen].width, screen_info[screen].height,
+              screen_info[screen].x_org, screen_info[screen].y_org);
     }
 
     free(reply);