Extract if(dpms) calls to wrapper functions

[i3/i3lock] / i3lock.c

diff --git a/i3lock.c b/i3lock.c
index 74e15f262972e0fa53a2debd5bc123fe2dcf7479..28a93f081e1312dc874833bff04318bdcc4c2f84 100644 (file)
--- a/i3lock.c
+++ b/i3lock.c
@@ -73,6 +73,16 @@ void u8_dec(char *s, int *i) {
     (void)(isutf(s[--(*i)]) || isutf(s[--(*i)]) || isutf(s[--(*i)]) || --(*i));
 }
 
+static void turn_monitors_on(void) {
+    if (dpms)
+        dpms_set_mode(conn, XCB_DPMS_DPMS_MODE_ON);
+}
+
+static void turn_monitors_off(void) {
+    if (dpms)
+        dpms_set_mode(conn, XCB_DPMS_DPMS_MODE_OFF);
+}
+
 /*
  * Loads the XKB keymap from the X11 server and feeds it to xkbcommon.
  * Necessary so that we can properly let xkbcommon track the keyboard state and
@@ -212,6 +222,9 @@ static void input_done(void) {
     if (pam_authenticate(pam_handle, 0) == PAM_SUCCESS) {
         DEBUG("successfully authenticated\n");
         clear_password_memory();
+        /* Turn the screen on, as it may have been turned off
+         * on release of the 'enter' key. */
+        turn_monitors_on();
         exit(0);
     }
 
@@ -364,7 +377,8 @@ static void handle_key_press(xcb_key_press_event_t *event) {
  * hiding us) gets hidden.
  *
  */
-static void handle_visibility_notify(xcb_visibility_notify_event_t *event) {
+static void handle_visibility_notify(xcb_connection_t *conn,
+    xcb_visibility_notify_event_t *event) {
     if (event->state != XCB_VISIBILITY_UNOBSCURED) {
         uint32_t values[] = { XCB_STACK_MODE_ABOVE };
         xcb_configure_window(conn, event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
@@ -495,13 +509,13 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
 
                 /* If this was the backspace or escape key we are back at an
                  * empty input, so turn off the screen if DPMS is enabled */
-                if (dpms && input_position == 0)
-                    dpms_turn_off_screen(conn);
+                if (input_position == 0)
+                    turn_monitors_off();
 
                 break;
 
             case XCB_VISIBILITY_NOTIFY:
-                handle_visibility_notify((xcb_visibility_notify_event_t*)event);
+                handle_visibility_notify(conn, (xcb_visibility_notify_event_t*)event);
                 break;
 
             case XCB_MAP_NOTIFY:
@@ -531,6 +545,63 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
     }
 }
 
+/*
+ * This function is called from a fork()ed child and will raise the i3lock
+ * window when the window is obscured, even when the main i3lock process is
+ * blocked due to PAM.
+ *
+ */
+static void raise_loop(xcb_window_t window) {
+    xcb_connection_t *conn;
+    xcb_generic_event_t *event;
+    int screens;
+
+    if ((conn = xcb_connect(NULL, &screens)) == NULL ||
+        xcb_connection_has_error(conn))
+        errx(EXIT_FAILURE, "Cannot open display\n");
+
+    /* 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
+        });
+    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;
+            DEBUG("X11 Error received! sequence 0x%x, error_code = %d\n",
+                 error->sequence, error->error_code);
+            free(event);
+            continue;
+        }
+        /* Strip off the highest bit (set if the event is generated) */
+        int type = (event->response_type & 0x7F);
+        DEBUG("Read event of type %d\n", type);
+        switch (type) {
+            case XCB_VISIBILITY_NOTIFY:
+                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)
+                    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)
+                    exit(EXIT_SUCCESS);
+                break;
+            default:
+                DEBUG("Unhandled event type %d\n", type);
+                break;
+        }
+        free(event);
+    }
+}
+
 int main(int argc, char *argv[]) {
     char *username;
     char *image_path = NULL;
@@ -692,6 +763,17 @@ int main(int argc, char *argv[]) {
     win = open_fullscreen_window(conn, screen, color, bg_pixmap);
     xcb_free_pixmap(conn, bg_pixmap);
 
+    pid_t pid = fork();
+    /* The pid == -1 case is intentionally ignored here:
+     * While the child process is useful for preventing other windows from
+     * popping up while i3lock blocks, it is not critical. */
+    if (pid == 0) {
+        /* Child */
+        close(xcb_get_file_descriptor(conn));
+        raise_loop(win);
+        exit(EXIT_SUCCESS);
+    }
+
     cursor = create_cursor(conn, screen, win, curs_choice);
 
     grab_pointer_and_keyboard(conn, screen, cursor);
@@ -701,8 +783,7 @@ int main(int argc, char *argv[]) {
      * keyboard. */
     (void)load_keymap();
 
-    if (dpms)
-        dpms_turn_off_screen(conn);
+    turn_monitors_off();
 
     /* Initialize the libev event loop. */
     main_loop = EV_DEFAULT;