mid-kid
/
i3lock-color
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

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.
master
Michael Stapelberg 10 years ago
parent
783509b872
commit
68b78a7f57
7 changed files with 190 additions and 195 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      cursors.h
  2. 284
      i3lock.c
  3. 9
      i3lock.h
  4. 21
      unlock_indicator.c
  5. 14
      unlock_indicator.h
  6. 49
      xcb.c
  7. 4
      xinerama.c

4
cursors.h
View File

@ -1,8 +1,8 @@
#ifndef _CURSORS_H #ifndef _CURSORS_H
#define _CURSORS_H #define _CURSORS_H
#define CURS_NONE 0 #define CURS_NONE 0
#define CURS_WIN 1 #define CURS_WIN 1
#define CURS_DEFAULT 2 #define CURS_DEFAULT 2
#endif #endif

284
i3lock.c
View File

@ -84,7 +84,7 @@ bool ignore_empty_password = false;
bool skip_repeated_empty_password = false; bool skip_repeated_empty_password = false;
/* isutf, u8_dec © 2005 Jeff Bezanson, public domain */ /* 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 * Decrements i to point to the previous unicode glyph
@ -181,7 +181,7 @@ static void clear_password_memory(void) {
vpassword[c] = c + (int)beep; 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) { if (timer_obj) {
ev_timer_stop(main_loop, timer_obj); ev_timer_stop(main_loop, timer_obj);
ev_timer_set(timer_obj, timeout, 0.); 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; return timer_obj;
} }
ev_timer* stop_timer(ev_timer *timer_obj) { ev_timer *stop_timer(ev_timer *timer_obj) {
if (timer_obj) { if (timer_obj) {
ev_timer_stop(main_loop, timer_obj); ev_timer_stop(main_loop, timer_obj);
free(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) { 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)) { switch (xkb_compose_state_get_status(xkb_compose_state)) {
case XKB_COMPOSE_NOTHING: case XKB_COMPOSE_NOTHING:
break; break;
case XKB_COMPOSE_COMPOSING: case XKB_COMPOSE_COMPOSING:
return; return;
case XKB_COMPOSE_COMPOSED: case XKB_COMPOSE_COMPOSED:
/* xkb_compose_state_get_utf8 doesn't include the terminating byte in the return value /* 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. */ * 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; n = xkb_compose_state_get_utf8(xkb_compose_state, buffer, sizeof(buffer)) + 1;
ksym = xkb_compose_state_get_one_sym(xkb_compose_state); ksym = xkb_compose_state_get_one_sym(xkb_compose_state);
composed = true; composed = true;
break; break;
case XKB_COMPOSE_CANCELLED: case XKB_COMPOSE_CANCELLED:
xkb_compose_state_reset(xkb_compose_state); xkb_compose_state_reset(xkb_compose_state);
return; return;
} }
} }
@ -348,54 +348,54 @@ static void handle_key_press(xcb_key_press_event_t *event) {
} }
switch (ksym) { switch (ksym) {
case XKB_KEY_Return: case XKB_KEY_Return:
case XKB_KEY_KP_Enter: case XKB_KEY_KP_Enter:
case XKB_KEY_XF86ScreenSaver: case XKB_KEY_XF86ScreenSaver:
if (pam_state == STATE_PAM_WRONG) if (pam_state == STATE_PAM_WRONG)
return; return;
if (skip_without_validation()) { if (skip_without_validation()) {
clear_input(); clear_input();
return;
}
password[input_position] = '\0';
unlock_state = STATE_KEY_PRESSED;
redraw_screen();
input_done();
skip_repeated_empty_password = true;
return; return;
} default:
password[input_position] = '\0'; skip_repeated_empty_password = false;
unlock_state = STATE_KEY_PRESSED;
redraw_screen();
input_done();
skip_repeated_empty_password = true;
return;
default:
skip_repeated_empty_password = false;
} }
switch (ksym) { switch (ksym) {
case XKB_KEY_u: case XKB_KEY_u:
if (ctrl) { if (ctrl) {
DEBUG("C-u pressed\n"); DEBUG("C-u pressed\n");
clear_input();
return;
}
break;
case XKB_KEY_Escape:
clear_input(); clear_input();
return; return;
}
break;
case XKB_KEY_Escape: case XKB_KEY_BackSpace:
clear_input(); if (input_position == 0)
return; return;
case XKB_KEY_BackSpace:
if (input_position == 0)
return;
/* decrement input_position to point to the previous glyph */ /* decrement input_position to point to the previous glyph */
u8_dec(password, &input_position); u8_dec(password, &input_position);
password[input_position] = '\0'; 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. */ * empty. */
START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb); START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb);
unlock_state = STATE_BACKSPACE_ACTIVE; unlock_state = STATE_BACKSPACE_ACTIVE;
redraw_screen(); redraw_screen();
unlock_state = STATE_KEY_PRESSED; unlock_state = STATE_KEY_PRESSED;
return; return;
} }
if ((input_position + 8) >= sizeof(password)) if ((input_position + 8) >= sizeof(password))
@ -416,8 +416,8 @@ static void handle_key_press(xcb_key_press_event_t *event) {
return; return;
/* store it in the password array as UTF-8 */ /* store it in the password array as UTF-8 */
memcpy(password+input_position, buffer, n-1); memcpy(password + input_position, buffer, n - 1);
input_position += n-1; input_position += n - 1;
DEBUG("current password = %.*s\n", input_position, password); DEBUG("current password = %.*s\n", input_position, password);
unlock_state = STATE_KEY_ACTIVE; 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, 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) { 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_configure_window(conn, event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
xcb_flush(conn); 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_new_keyboard_notify_event_t new_keyboard_notify;
xcb_xkb_map_notify_event_t map_notify; xcb_xkb_map_notify_event_t map_notify;
xcb_xkb_state_notify_event_t state_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); 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, 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) if (num_msg == 0)
return 1; 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) { while ((event = xcb_poll_for_event(conn)) != NULL) {
if (event->response_type == 0) { 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) if (debug_mode)
fprintf(stderr, "X11 Error received! sequence 0x%x, error_code = %d\n", fprintf(stderr, "X11 Error received! sequence 0x%x, error_code = %d\n",
error->sequence, error->error_code); error->sequence, error->error_code);
@ -610,7 +609,7 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
switch (type) { switch (type) {
case XCB_KEY_PRESS: case XCB_KEY_PRESS:
handle_key_press((xcb_key_press_event_t*)event); handle_key_press((xcb_key_press_event_t *)event);
break; break;
case XCB_KEY_RELEASE: case XCB_KEY_RELEASE:
@ -623,7 +622,7 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
break; break;
case XCB_VISIBILITY_NOTIFY: 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; break;
case XCB_MAP_NOTIFY: 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. */ /* We need to know about the window being obscured or getting destroyed. */
xcb_change_window_attributes(conn, window, XCB_CW_EVENT_MASK, xcb_change_window_attributes(conn, window, XCB_CW_EVENT_MASK,
(uint32_t[]){ (uint32_t[]){
XCB_EVENT_MASK_VISIBILITY_CHANGE | XCB_EVENT_MASK_VISIBILITY_CHANGE |
XCB_EVENT_MASK_STRUCTURE_NOTIFY XCB_EVENT_MASK_STRUCTURE_NOTIFY});
});
xcb_flush(conn); xcb_flush(conn);
DEBUG("Watching window 0x%08x\n", window); DEBUG("Watching window 0x%08x\n", window);
while ((event = xcb_wait_for_event(conn)) != NULL) { while ((event = xcb_wait_for_event(conn)) != NULL) {
if (event->response_type == 0) { 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", DEBUG("X11 Error received! sequence 0x%x, error_code = %d\n",
error->sequence, error->error_code); error->sequence, error->error_code);
free(event); free(event);
continue; continue;
} }
@ -690,16 +688,16 @@ static void raise_loop(xcb_window_t window) {
DEBUG("Read event of type %d\n", type); DEBUG("Read event of type %d\n", type);
switch (type) { switch (type) {
case XCB_VISIBILITY_NOTIFY: 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; break;
case XCB_UNMAP_NOTIFY: case XCB_UNMAP_NOTIFY:
DEBUG("UnmapNotify for 0x%08x\n", (((xcb_unmap_notify_event_t*)event)->window)); DEBUG("UnmapNotify for 0x%08x\n", (((xcb_unmap_notify_event_t *)event)->window));
if (((xcb_unmap_notify_event_t*)event)->window == window) if (((xcb_unmap_notify_event_t *)event)->window == window)
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
break; break;
case XCB_DESTROY_NOTIFY: case XCB_DESTROY_NOTIFY:
DEBUG("DestroyNotify for 0x%08x\n", (((xcb_destroy_notify_event_t*)event)->window)); DEBUG("DestroyNotify for 0x%08x\n", (((xcb_destroy_notify_event_t *)event)->window));
if (((xcb_destroy_notify_event_t*)event)->window == window) if (((xcb_destroy_notify_event_t *)event)->window == window)
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
break; break;
default: default:
@ -725,7 +723,7 @@ int main(int argc, char *argv[]) {
{"beep", no_argument, NULL, 'b'}, {"beep", no_argument, NULL, 'b'},
{"dpms", no_argument, NULL, 'd'}, {"dpms", no_argument, NULL, 'd'},
{"color", required_argument, NULL, 'c'}, {"color", required_argument, NULL, 'c'},
{"pointer", required_argument, NULL , 'p'}, {"pointer", required_argument, NULL, 'p'},
{"debug", no_argument, NULL, 0}, {"debug", no_argument, NULL, 0},
{"help", no_argument, NULL, 'h'}, {"help", no_argument, NULL, 'h'},
{"no-unlock-indicator", no_argument, NULL, 'u'}, {"no-unlock-indicator", no_argument, NULL, 'u'},
@ -734,8 +732,7 @@ int main(int argc, char *argv[]) {
{"ignore-empty-password", no_argument, NULL, 'e'}, {"ignore-empty-password", no_argument, NULL, 'e'},
{"inactivity-timeout", required_argument, NULL, 'I'}, {"inactivity-timeout", required_argument, NULL, 'I'},
{"show-failed-attempts", no_argument, NULL, 'f'}, {"show-failed-attempts", no_argument, NULL, 'f'},
{NULL, no_argument, NULL, 0} {NULL, no_argument, NULL, 0}};
};
if ((pw = getpwuid(getuid())) == NULL) if ((pw = getpwuid(getuid())) == NULL)
err(EXIT_FAILURE, "getpwuid() failed"); err(EXIT_FAILURE, "getpwuid() failed");
@ -745,68 +742,67 @@ int main(int argc, char *argv[]) {
char *optstring = "hvnbdc:p:ui:teI:f"; char *optstring = "hvnbdc:p:ui:teI:f";
while ((o = getopt_long(argc, argv, optstring, longopts, &optind)) != -1) { while ((o = getopt_long(argc, argv, optstring, longopts, &optind)) != -1) {
switch (o) { switch (o) {
case 'v': case 'v':
errx(EXIT_SUCCESS, "version " VERSION " © 2010-2012 Michael Stapelberg"); errx(EXIT_SUCCESS, "version " VERSION " © 2010-2012 Michael Stapelberg");
case 'n': case 'n':
dont_fork = true; dont_fork = true;
break; break;
case 'b': case 'b':
beep = true; beep = true;
break; break;
case 'd': case 'd':
dpms = true; dpms = true;
break; break;
case 'I': { case 'I': {
int time = 0; int time = 0;
if (sscanf(optarg, "%d", &time) != 1 || time < 0) if (sscanf(optarg, "%d", &time) != 1 || time < 0)
errx(EXIT_FAILURE, "invalid timeout, it must be a positive integer\n"); errx(EXIT_FAILURE, "invalid timeout, it must be a positive integer\n");
inactivity_timeout = time; inactivity_timeout = time;
break; break;
} }
case 'c': { case 'c': {
char *arg = optarg; char *arg = optarg;
/* Skip # if present */ /* Skip # if present */
if (arg[0] == '#') if (arg[0] == '#')
arg++; arg++;
if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1) 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"); errx(EXIT_FAILURE, "color is invalid, it must be given in 3-byte hexadecimal format: rrggbb\n");
break; 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; case 'u':
case 'e': unlock_indicator = false;
ignore_empty_password = true; break;
break; case 'i':
case 0: image_path = strdup(optarg);
if (strcmp(longopts[optind].name, "debug") == 0) break;
debug_mode = true; case 't':
break; tile = true;
case 'f': break;
show_failed_attempts = true; case 'p':
break; if (!strcmp(optarg, "win")) {
default: curs_choice = CURS_WIN;
errx(EXIT_FAILURE, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default]" } else if (!strcmp(optarg, "default")) {
" [-i image.png] [-t] [-e] [-I] [-f]" 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?"); errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
if (xkb_x11_setup_xkb_extension(conn, if (xkb_x11_setup_xkb_extension(conn,
XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MAJOR_XKB_VERSION,
XKB_X11_MIN_MINOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION,
0, 0,
NULL, NULL,
NULL, NULL,
&xkb_base_event, &xkb_base_event,
&xkb_base_error) != 1) &xkb_base_error) != 1)
errx(EXIT_FAILURE, "Could not setup XKB extension."); errx(EXIT_FAILURE, "Could not setup XKB extension.");
static const xcb_xkb_map_part_t required_map_parts = 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; last_resolution[1] = screen->height_in_pixels;
xcb_change_window_attributes(conn, screen->root, XCB_CW_EVENT_MASK, 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) { if (image_path) {
/* Create a pixmap to render on, fill it with the background color */ /* Create a pixmap to render on, fill it with the background color */

9
i3lock.h
View File

@ -5,9 +5,10 @@
* This is important because xautolock (for example) closes stdout/stderr by * This is important because xautolock (for example) closes stdout/stderr by
* default, so just printing something to stdout will lead to the data ending * default, so just printing something to stdout will lead to the data ending
* up on the X11 socket (!). */ * up on the X11 socket (!). */
#define DEBUG(fmt, ...) do { \ #define DEBUG(fmt, ...) \
if (debug_mode) \ do { \
printf("[i3lock-debug] " fmt, ##__VA_ARGS__); \ if (debug_mode) \
} while (0) printf("[i3lock-debug] " fmt, ##__VA_ARGS__); \
} while (0)
#endif #endif

21
unlock_indicator.c
View File

@ -151,10 +151,10 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
* (currently verifying, wrong password, or default) */ * (currently verifying, wrong password, or default) */
switch (pam_state) { switch (pam_state) {
case STATE_PAM_VERIFY: 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; break;
case STATE_PAM_WRONG: 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; break;
default: default:
cairo_set_source_rgba(ctx, 0, 0, 0, 0.75); 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) { switch (pam_state) {
case STATE_PAM_VERIFY: 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; break;
case STATE_PAM_WRONG: 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; break;
case STATE_PAM_IDLE: 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; break;
} }
cairo_stroke(ctx); cairo_stroke(ctx);
@ -203,7 +203,7 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
text = "wrong!"; text = "wrong!";
break; break;
default: default:
if (show_failed_attempts && failed_attempts > 0){ if (show_failed_attempts && failed_attempts > 0) {
if (failed_attempts > 999) { if (failed_attempts > 999) {
text = "> 999"; text = "> 999";
} else { } else {
@ -244,10 +244,10 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
highlight_start + (M_PI / 3.0)); highlight_start + (M_PI / 3.0));
if (unlock_state == STATE_KEY_ACTIVE) { if (unlock_state == STATE_KEY_ACTIVE) {
/* For normal keys, we use a lighter green. */ /* 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 { } else {
/* For backspace, we use red. */ /* 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); cairo_stroke(ctx);
@ -304,7 +304,7 @@ xcb_pixmap_t draw_image(uint32_t *resolution) {
*/ */
void redraw_screen(void) { void redraw_screen(void) {
xcb_pixmap_t bg_pixmap = draw_image(last_resolution); 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 /* XXX: Possible optimization: Only update the area in the middle of the
* screen instead of the whole screen. */ * screen instead of the whole screen. */
xcb_clear_area(conn, 0, win, 0, 0, last_resolution[0], last_resolution[1]); 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) { void clear_indicator(void) {
if (input_position == 0) { if (input_position == 0) {
unlock_state = STATE_STARTED; unlock_state = STATE_STARTED;
} else unlock_state = STATE_KEY_PRESSED; } else
unlock_state = STATE_KEY_PRESSED;
redraw_screen(); redraw_screen();
} }

14
unlock_indicator.h
View File

@ -2,18 +2,18 @@
#define _UNLOCK_INDICATOR_H #define _UNLOCK_INDICATOR_H
typedef enum { typedef enum {
STATE_STARTED = 0, /* default state */ STATE_STARTED = 0, /* default state */
STATE_KEY_PRESSED = 1, /* key was pressed, show unlock indicator */ STATE_KEY_PRESSED = 1, /* key was pressed, show unlock indicator */
STATE_KEY_ACTIVE = 2, /* a key was pressed recently, highlight part STATE_KEY_ACTIVE = 2, /* a key was pressed recently, highlight part
of the unlock indicator. */ 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. */ part of the unlock indicator in red. */
} unlock_state_t; } unlock_state_t;
typedef enum { typedef enum {
STATE_PAM_IDLE = 0, /* no PAM interaction at the moment */ STATE_PAM_IDLE = 0, /* no PAM interaction at the moment */
STATE_PAM_VERIFY = 1, /* currently verifying the password via PAM */ STATE_PAM_VERIFY = 1, /* currently verifying the password via PAM */
STATE_PAM_WRONG = 2 /* the password was wrong */ STATE_PAM_WRONG = 2 /* the password was wrong */
} pam_state_t; } pam_state_t;
xcb_pixmap_t draw_image(uint32_t* resolution); xcb_pixmap_t draw_image(uint32_t* resolution);

49
xcb.c
View File

@ -28,25 +28,25 @@ xcb_screen_t *screen;
#define curs_invisible_height 8 #define curs_invisible_height 8
static unsigned char curs_invisible_bits[] = { 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_width 11
#define curs_windows_height 19 #define curs_windows_height 19
static unsigned char curs_windows_bits[] = { static unsigned char curs_windows_bits[] = {
0xfe, 0x07, 0xfc, 0x07, 0xfa, 0x07, 0xf6, 0x07, 0xee, 0x07, 0xde, 0x07, 0xfe, 0x07, 0xfc, 0x07, 0xfa, 0x07, 0xf6, 0x07, 0xee, 0x07, 0xde, 0x07,
0xbe, 0x07, 0x7e, 0x07, 0xfe, 0x06, 0xfe, 0x05, 0x3e, 0x00, 0xb6, 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, 0x6a, 0x07, 0x6c, 0x07, 0xde, 0x06, 0xdf, 0x06, 0xbf, 0x05, 0xbf, 0x05,
0x7f, 0x06 }; 0x7f, 0x06};
#define mask_windows_width 11 #define mask_windows_width 11
#define mask_windows_height 19 #define mask_windows_height 19
static unsigned char mask_windows_bits[] = { static unsigned char mask_windows_bits[] = {
0x01, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3f, 0x00, 0x01, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3f, 0x00,
0x7f, 0x00, 0xff, 0x00, 0xff, 0x01, 0xff, 0x03, 0xff, 0x07, 0x7f, 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, 0xf7, 0x00, 0xf3, 0x00, 0xe1, 0x01, 0xe0, 0x01, 0xc0, 0x03, 0xc0, 0x03,
0x80, 0x01 }; 0x80, 0x01};
static uint32_t get_colorpixel(char *hex) { static uint32_t get_colorpixel(char *hex) {
char strgroups[3][3] = {{hex[0], hex[1], '\0'}, 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); for (depth_iter = xcb_screen_allowed_depths_iterator(screen);
depth_iter.rem; depth_iter.rem;
xcb_depth_next(&depth_iter)) { xcb_depth_next(&depth_iter)) {
for (visual_iter = xcb_depth_visuals_iterator(depth_iter.data); for (visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
visual_iter.rem; visual_iter.rem;
xcb_visualtype_next(&visual_iter)) { xcb_visualtype_next(&visual_iter)) {
@ -82,7 +81,7 @@ xcb_visualtype_t *get_root_visual_type(xcb_screen_t *screen) {
return NULL; 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_pixmap_t bg_pixmap = xcb_generate_id(conn);
xcb_create_pixmap(conn, scr->root_depth, bg_pixmap, scr->root, xcb_create_pixmap(conn, scr->root_depth, bg_pixmap, scr->root,
resolution[0], resolution[1]); 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 /* Generate a Graphics Context and fill the pixmap with background color
* (for images that are smaller than your screen) */ * (for images that are smaller than your screen) */
xcb_gcontext_t gc = xcb_generate_id(conn); 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_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_poly_fill_rectangle(conn, bg_pixmap, gc, 1, &rect);
xcb_free_gc(conn, gc); 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_create_window(conn,
XCB_COPY_FROM_PARENT, XCB_COPY_FROM_PARENT,
win, /* the window id */ win, /* the window id */
scr->root, /* parent == root */ scr->root, /* parent == root */
0, 0, 0, 0,
scr->width_in_pixels, scr->width_in_pixels,
scr->height_in_pixels, /* dimensions */ 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_INPUT_OUTPUT,
XCB_WINDOW_CLASS_COPY_FROM_PARENT, /* copy visual from parent */ XCB_WINDOW_CLASS_COPY_FROM_PARENT, /* copy visual from parent */
mask, 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_GRAB_MODE_ASYNC, /* keyboard mode */
XCB_NONE, /* confine_to = in which window should the cursor stay */ XCB_NONE, /* confine_to = in which window should the cursor stay */
cursor, /* we change the cursor to whatever the user wanted */ 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)) && if ((preply = xcb_grab_pointer_reply(conn, pcookie, NULL)) &&
preply->status == XCB_GRAB_STATUS_SUCCESS) { 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) { while (tries-- > 0) {
kcookie = xcb_grab_keyboard( kcookie = xcb_grab_keyboard(
conn, conn,
true, /* report events */ true, /* report events */
screen->root, /* grab the root window */ screen->root, /* grab the root window */
XCB_CURRENT_TIME, XCB_CURRENT_TIME,
XCB_GRAB_MODE_ASYNC, /* process events as normal, do not require sync */ 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)) && if ((kreply = xcb_grab_keyboard_reply(conn, kcookie, NULL)) &&
kreply->status == XCB_GRAB_STATUS_SUCCESS) { 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_pixmap_t mask;
xcb_cursor_t cursor; xcb_cursor_t cursor;
unsigned char* curs_bits; unsigned char *curs_bits;
unsigned char* mask_bits; unsigned char *mask_bits;
int curs_w, curs_h; int curs_w, curs_h;
switch (choice) { switch (choice) {
@ -278,9 +275,9 @@ xcb_cursor_t create_cursor(xcb_connection_t *conn, xcb_screen_t *screen, xcb_win
cursor, cursor,
bitmap, bitmap,
mask, mask,
65535,65535,65535, 65535, 65535, 65535,
0,0,0, 0, 0, 0,
0,0); 0, 0);
xcb_free_pixmap(conn, bitmap); xcb_free_pixmap(conn, bitmap);
xcb_free_pixmap(conn, mask); xcb_free_pixmap(conn, mask);

4
xinerama.c
View File

@ -82,8 +82,8 @@ void xinerama_query_screens(void) {
xr_resolutions[screen].width = screen_info[screen].width; xr_resolutions[screen].width = screen_info[screen].width;
xr_resolutions[screen].height = screen_info[screen].height; xr_resolutions[screen].height = screen_info[screen].height;
DEBUG("found Xinerama screen: %d x %d at %d x %d\n", DEBUG("found Xinerama screen: %d x %d at %d x %d\n",
screen_info[screen].width, screen_info[screen].height, screen_info[screen].width, screen_info[screen].height,
screen_info[screen].x_org, screen_info[screen].y_org); screen_info[screen].x_org, screen_info[screen].y_org);
} }
free(reply); free(reply);

Write Preview
Loading…
Cancel
Save