X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fmain.c;h=002eb6a5729a93df1988f1bd7121baef09b5d097;hb=5aa43d61f84e69c9b46cfc3e37c6806b887f01d8;hp=ea7f82f23b63b29553331d8ec0d58b6f14d7bc72;hpb=5098e45f234d9fd49af43f82c32fcbc9be9e1a60;p=i3%2Fi3 diff --git a/src/main.c b/src/main.c index ea7f82f2..cc60d69c 100644 --- a/src/main.c +++ b/src/main.c @@ -3,9 +3,10 @@ */ #include #include -#include #include "all.h" +#include "sd-daemon.h" + static int xkb_event_base; int xkb_current_group; @@ -15,13 +16,13 @@ extern Con *focused; char **start_argv; xcb_connection_t *conn; -xcb_event_handlers_t evenths; -xcb_property_handlers_t prophs; -xcb_atom_t atoms[NUM_ATOMS]; +xcb_screen_t *root_screen; xcb_window_t root; uint8_t root_depth; +struct ev_loop *main_loop; + xcb_key_symbols_t *keysyms; /* Those are our connections to X11 for use with libXcursor and XKB */ @@ -33,9 +34,16 @@ struct bindings_head *bindings; /* The list of exec-lines */ struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts); +/* The list of exec_always lines */ +struct autostarts_always_head autostarts_always = TAILQ_HEAD_INITIALIZER(autostarts_always); + /* The list of assignments */ struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments); +/* The list of workspace assignments (which workspace should end up on which + * output) */ +struct ws_assignments_head ws_assignments = TAILQ_HEAD_INITIALIZER(ws_assignments); + /* We hope that those are supported and set them to true */ bool xcursor_supported = true; bool xkb_supported = true; @@ -66,9 +74,101 @@ static void xcb_check_cb(EV_P_ ev_check *w, int revents) { xcb_generic_event_t *event; while ((event = xcb_poll_for_event(conn)) != NULL) { - xcb_event_handle(&evenths, event); + if (event->response_type == 0) { + if (event_is_ignored(event->sequence, 0)) + DLOG("Expected X11 Error received for sequence %x\n", event->sequence); + else { + xcb_generic_error_t *error = (xcb_generic_error_t*)event; + ELOG("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); + + handle_event(type, event); + + free(event); + } +} + + +/* + * When using xmodmap to change the keyboard mapping, this event + * is only sent via XKB. Therefore, we need this special handler. + * + */ +static void xkb_got_event(EV_P_ struct ev_io *w, int revents) { + DLOG("Handling XKB event\n"); + XkbEvent ev; + + /* When using xmodmap, every change (!) gets an own event. + * Therefore, we just read all events and only handle the + * mapping_notify once. */ + bool mapping_changed = false; + while (XPending(xkbdpy)) { + XNextEvent(xkbdpy, (XEvent*)&ev); + /* While we should never receive a non-XKB event, + * better do sanity checking */ + if (ev.type != xkb_event_base) + continue; + + if (ev.any.xkb_type == XkbMapNotify) { + mapping_changed = true; + continue; + } + + if (ev.any.xkb_type != XkbStateNotify) { + ELOG("Unknown XKB event received (type %d)\n", ev.any.xkb_type); + continue; + } + + /* See The XKB Extension: Library Specification, section 14.1 */ + /* We check if the current group (each group contains + * two levels) has been changed. Mode_switch activates + * group XkbGroup2Index */ + if (xkb_current_group == ev.state.group) + continue; + + xkb_current_group = ev.state.group; + + if (ev.state.group == XkbGroup2Index) { + DLOG("Mode_switch enabled\n"); + grab_all_keys(conn, true); + } + + if (ev.state.group == XkbGroup1Index) { + DLOG("Mode_switch disabled\n"); + ungrab_all_keys(conn); + grab_all_keys(conn, false); + } } + + if (!mapping_changed) + return; + + DLOG("Keyboard mapping changed, updating keybindings\n"); + xcb_key_symbols_free(keysyms); + keysyms = xcb_key_symbols_alloc(conn); + + xcb_get_numlock_mask(conn); + + ungrab_all_keys(conn); + DLOG("Re-grabbing...\n"); + translate_keysyms(); + grab_all_keys(conn, (xkb_current_group == XkbGroup2Index)); + DLOG("Done\n"); +} + +/* + * Exit handler which destroys the main_loop. Will trigger cleanup handlers. + * + */ +static void i3_exit() { + ev_loop_destroy(main_loop); } int main(int argc, char *argv[]) { @@ -77,10 +177,10 @@ int main(int argc, char *argv[]) { char *override_configpath = NULL; bool autostart = true; char *layout_path = NULL; - bool delete_layout_path; + bool delete_layout_path = false; bool only_check_config = false; bool force_xinerama = false; - xcb_intern_atom_cookie_t atom_cookies[NUM_ATOMS]; + bool disable_signalhandler = false; static struct option long_options[] = { {"no-autostart", no_argument, 0, 'a'}, {"config", required_argument, 0, 'c'}, @@ -89,6 +189,7 @@ int main(int argc, char *argv[]) { {"layout", required_argument, 0, 'L'}, {"restart", required_argument, 0, 0}, {"force-xinerama", no_argument, 0, 0}, + {"disable-signalhandler", no_argument, 0, 0}, {0, 0, 0, 0} }; int option_index = 0, opt; @@ -99,6 +200,8 @@ int main(int argc, char *argv[]) { if (!isatty(fileno(stdout))) setbuf(stdout, NULL); + init_logging(); + start_argv = argv; while ((opt = getopt_long(argc, argv, "c:CvaL:hld:V", long_options, &option_index)) != -1) { @@ -108,10 +211,12 @@ int main(int argc, char *argv[]) { autostart = false; break; case 'L': + FREE(layout_path); layout_path = sstrdup(optarg); delete_layout_path = false; break; case 'c': + FREE(override_configpath); override_configpath = sstrdup(optarg); break; case 'C': @@ -119,7 +224,7 @@ int main(int argc, char *argv[]) { only_check_config = true; break; case 'v': - printf("i3 version " I3_VERSION " © 2009 Michael Stapelberg and contributors\n"); + printf("i3 version " I3_VERSION " © 2009-2011 Michael Stapelberg and contributors\n"); exit(EXIT_SUCCESS); case 'V': set_verbosity(true); @@ -140,7 +245,11 @@ int main(int argc, char *argv[]) { "Please check if your driver really does not support RandR " "and disable this option as soon as you can.\n"); break; + } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) { + disable_signalhandler = true; + break; } else if (strcmp(long_options[option_index].name, "restart") == 0) { + FREE(layout_path); layout_path = sstrdup(optarg); delete_layout_path = true; break; @@ -169,15 +278,32 @@ int main(int argc, char *argv[]) { if (xcb_connection_has_error(conn)) errx(EXIT_FAILURE, "Cannot open display\n"); + /* Initialize the libev event loop. This needs to be done before loading + * the config file because the parser will install an ev_child watcher + * for the nagbar when config errors are found. */ + main_loop = EV_DEFAULT; + if (main_loop == NULL) + die("Could not initialize libev. Bad LIBEV_FLAGS?\n"); + + root_screen = xcb_aux_get_screen(conn, screens); + root = root_screen->root; + root_depth = root_screen->root_depth; + xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root); + xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root); + load_configuration(conn, override_configpath, false); if (only_check_config) { LOG("Done checking configuration file. Exiting.\n"); exit(0); } - xcb_screen_t *root_screen = xcb_aux_get_screen(conn, screens); - root = root_screen->root; - root_depth = root_screen->root_depth; + if (config.ipc_socket_path == NULL) { + /* Fall back to a file name in /tmp/ based on the PID */ + if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL) + config.ipc_socket_path = get_process_filename("ipc-socket"); + else + config.ipc_socket_path = sstrdup(config.ipc_socket_path); + } uint32_t mask = XCB_CW_EVENT_MASK; uint32_t values[] = { XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | @@ -191,30 +317,18 @@ int main(int argc, char *argv[]) { cookie = xcb_change_window_attributes_checked(conn, root, mask, values); check_error(conn, cookie, "Another window manager seems to be running"); + xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL); + if (greply == NULL) { + ELOG("Could not get geometry of the root window, exiting\n"); + return 1; + } + DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height); + /* Place requests for the atoms we need as soon as possible */ - #define REQUEST_ATOM(name) atom_cookies[name] = xcb_intern_atom(conn, 0, strlen(#name), #name); - - REQUEST_ATOM(_NET_SUPPORTED); - REQUEST_ATOM(_NET_WM_STATE_FULLSCREEN); - REQUEST_ATOM(_NET_SUPPORTING_WM_CHECK); - REQUEST_ATOM(_NET_WM_NAME); - REQUEST_ATOM(_NET_WM_STATE); - REQUEST_ATOM(_NET_WM_WINDOW_TYPE); - REQUEST_ATOM(_NET_WM_DESKTOP); - REQUEST_ATOM(_NET_WM_WINDOW_TYPE_DOCK); - REQUEST_ATOM(_NET_WM_WINDOW_TYPE_DIALOG); - REQUEST_ATOM(_NET_WM_WINDOW_TYPE_UTILITY); - REQUEST_ATOM(_NET_WM_WINDOW_TYPE_TOOLBAR); - REQUEST_ATOM(_NET_WM_WINDOW_TYPE_SPLASH); - REQUEST_ATOM(_NET_WM_STRUT_PARTIAL); - REQUEST_ATOM(WM_PROTOCOLS); - REQUEST_ATOM(WM_DELETE_WINDOW); - REQUEST_ATOM(UTF8_STRING); - REQUEST_ATOM(WM_STATE); - REQUEST_ATOM(WM_CLIENT_LEADER); - REQUEST_ATOM(_NET_CURRENT_DESKTOP); - REQUEST_ATOM(_NET_ACTIVE_WINDOW); - REQUEST_ATOM(_NET_WORKAREA); + #define xmacro(atom) \ + xcb_intern_atom_cookie_t atom ## _cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom); + #include "atoms.xmacro" + #undef xmacro /* Initialize the Xlib connection */ xlibdpy = xkbdpy = XOpenDisplay(NULL); @@ -232,91 +346,71 @@ int main(int argc, char *argv[]) { /*init_xkb();*/ } - memset(&evenths, 0, sizeof(xcb_event_handlers_t)); - memset(&prophs, 0, sizeof(xcb_property_handlers_t)); - - xcb_event_handlers_init(conn, &evenths); - xcb_property_handlers_init(&prophs, &evenths); - xcb_event_set_key_press_handler(&evenths, handle_key_press, NULL); - - xcb_event_set_button_press_handler(&evenths, handle_button_press, NULL); - - xcb_event_set_map_request_handler(&evenths, handle_map_request, NULL); - - xcb_event_set_unmap_notify_handler(&evenths, handle_unmap_notify_event, NULL); - xcb_event_set_destroy_notify_handler(&evenths, handle_destroy_notify_event, NULL); - - xcb_event_set_expose_handler(&evenths, handle_expose_event, NULL); + /* Set a cursor for the root window (otherwise the root window will show no + cursor until the first client is launched). */ + if (xcursor_supported) { + xcursor_set_root_cursor(); + } else { + xcb_cursor_t cursor_id = xcb_generate_id(conn); + i3Font cursor_font = load_font("cursor", false); + int xcb_cursor = xcursor_get_xcb_cursor(XCURSOR_CURSOR_POINTER); + xcb_create_glyph_cursor(conn, cursor_id, cursor_font.id, cursor_font.id, + xcb_cursor, xcb_cursor + 1, 0, 0, 0, 65535, 65535, 65535); + xcb_change_window_attributes(conn, root, XCB_CW_CURSOR, &cursor_id); + xcb_free_cursor(conn, cursor_id); + } - xcb_event_set_motion_notify_handler(&evenths, handle_motion_notify, NULL); + if (xkb_supported) { + int errBase, + major = XkbMajorVersion, + minor = XkbMinorVersion; - /* Enter window = user moved his mouse over the window */ - xcb_event_set_enter_notify_handler(&evenths, handle_enter_notify, NULL); + if (fcntl(ConnectionNumber(xkbdpy), F_SETFD, FD_CLOEXEC) == -1) { + fprintf(stderr, "Could not set FD_CLOEXEC on xkbdpy\n"); + return 1; + } - /* Client message are sent to the root window. The only interesting client message - for us is _NET_WM_STATE, we honour _NET_WM_STATE_FULLSCREEN */ - xcb_event_set_client_message_handler(&evenths, handle_client_message, NULL); + int i1; + if (!XkbQueryExtension(xkbdpy,&i1,&xkb_event_base,&errBase,&major,&minor)) { + fprintf(stderr, "XKB not supported by X-server\n"); + return 1; + } + /* end of ugliness */ - /* Configure request = window tried to change size on its own */ - xcb_event_set_configure_request_handler(&evenths, handle_configure_request, NULL); + if (!XkbSelectEvents(xkbdpy, XkbUseCoreKbd, + XkbMapNotifyMask | XkbStateNotifyMask, + XkbMapNotifyMask | XkbStateNotifyMask)) { + fprintf(stderr, "Could not set XKB event mask\n"); + return 1; + } + } /* Setup NetWM atoms */ - #define GET_ATOM(name) \ + #define xmacro(name) \ do { \ - xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, atom_cookies[name], NULL); \ + xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name ## _cookie, NULL); \ if (!reply) { \ ELOG("Could not get atom " #name "\n"); \ exit(-1); \ } \ - atoms[name] = reply->atom; \ + A_ ## name = reply->atom; \ free(reply); \ - } while (0) - - GET_ATOM(_NET_SUPPORTED); - GET_ATOM(_NET_WM_STATE_FULLSCREEN); - GET_ATOM(_NET_SUPPORTING_WM_CHECK); - GET_ATOM(_NET_WM_NAME); - GET_ATOM(_NET_WM_STATE); - GET_ATOM(_NET_WM_WINDOW_TYPE); - GET_ATOM(_NET_WM_DESKTOP); - GET_ATOM(_NET_WM_WINDOW_TYPE_DOCK); - GET_ATOM(_NET_WM_WINDOW_TYPE_DIALOG); - GET_ATOM(_NET_WM_WINDOW_TYPE_UTILITY); - GET_ATOM(_NET_WM_WINDOW_TYPE_TOOLBAR); - GET_ATOM(_NET_WM_WINDOW_TYPE_SPLASH); - GET_ATOM(_NET_WM_STRUT_PARTIAL); - GET_ATOM(WM_PROTOCOLS); - GET_ATOM(WM_DELETE_WINDOW); - GET_ATOM(UTF8_STRING); - GET_ATOM(WM_STATE); - GET_ATOM(WM_CLIENT_LEADER); - GET_ATOM(_NET_CURRENT_DESKTOP); - GET_ATOM(_NET_ACTIVE_WINDOW); - GET_ATOM(_NET_WORKAREA); - - /* Watch _NET_WM_NAME (title of the window encoded in UTF-8) */ - xcb_property_set_handler(&prophs, atoms[_NET_WM_NAME], 128, handle_windowname_change, NULL); - - /* Watch WM_HINTS (contains the urgent property) */ - xcb_property_set_handler(&prophs, WM_HINTS, UINT_MAX, handle_hints, NULL); - - /* Watch WM_NAME (title of the window encoded in COMPOUND_TEXT) */ - xcb_watch_wm_name(&prophs, 128, handle_windowname_change_legacy, NULL); - - /* Watch WM_NORMAL_HINTS (aspect ratio, size increments, …) */ - xcb_property_set_handler(&prophs, WM_NORMAL_HINTS, UINT_MAX, handle_normal_hints, NULL); - - /* Watch WM_CLIENT_LEADER (= logical parent window for toolbars etc.) */ - xcb_property_set_handler(&prophs, atoms[WM_CLIENT_LEADER], UINT_MAX, handle_clientleader_change, NULL); - - /* Watch WM_TRANSIENT_FOR property (to which client this popup window belongs) */ - xcb_property_set_handler(&prophs, WM_TRANSIENT_FOR, UINT_MAX, handle_transient_for, NULL); + } while (0); + #include "atoms.xmacro" + #undef xmacro + + property_handlers_init(); /* Set up the atoms we support */ - xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, atoms[_NET_SUPPORTED], ATOM, 32, 7, atoms); + xcb_atom_t supported_atoms[] = { +#define xmacro(atom) A_ ## atom, +#include "atoms.xmacro" +#undef xmacro + }; + xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A__NET_SUPPORTED, XCB_ATOM_ATOM, 32, 16, supported_atoms); /* Set up the window manager’s name */ - xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, atoms[_NET_SUPPORTING_WM_CHECK], WINDOW, 32, 1, &root); - xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, atoms[_NET_WM_NAME], atoms[UTF8_STRING], 8, strlen("i3"), "i3"); + xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A__NET_SUPPORTING_WM_CHECK, XCB_ATOM_WINDOW, 32, 1, &root); + xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A__NET_WM_NAME, A_UTF8_STRING, 8, strlen("i3"), "i3"); keysyms = xcb_key_symbols_alloc(conn); @@ -328,63 +422,103 @@ int main(int argc, char *argv[]) { bool needs_tree_init = true; if (layout_path) { LOG("Trying to restore the layout from %s...", layout_path); - needs_tree_init = !tree_restore(layout_path); + needs_tree_init = !tree_restore(layout_path, greply); if (delete_layout_path) unlink(layout_path); free(layout_path); } if (needs_tree_init) - tree_init(); + tree_init(greply); + + free(greply); - int randr_base; - if (force_xinerama) { + /* Force Xinerama (for drivers which don't support RandR yet, esp. the + * nVidia binary graphics driver), when specified either in the config + * file or on command-line */ + if (force_xinerama || config.force_xinerama) { xinerama_init(); } else { DLOG("Checking for XRandR...\n"); randr_init(&randr_base); + } + + xcb_query_pointer_reply_t *pointerreply; + Output *output = NULL; + if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) { + ELOG("Could not query pointer position, using first screen\n"); + output = get_first_output(); + } else { + DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y); + output = get_output_containing(pointerreply->root_x, pointerreply->root_y); + if (!output) { + ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n", + pointerreply->root_x, pointerreply->root_y); + output = get_first_output(); + } - xcb_event_set_handler(&evenths, - randr_base + XCB_RANDR_SCREEN_CHANGE_NOTIFY, - handle_screen_change, - NULL); + con_focus(con_descend_focused(output_get_content(output->con))); } tree_render(); - struct ev_loop *loop = ev_loop_new(0); - if (loop == NULL) - die("Could not initialize libev. Bad LIBEV_FLAGS?\n"); - /* Create the UNIX domain socket for IPC */ - if (config.ipc_socket_path != NULL) { - int ipc_socket = ipc_create_socket(config.ipc_socket_path); - if (ipc_socket == -1) { - ELOG("Could not create the IPC socket, IPC disabled\n"); - } else { + int ipc_socket = ipc_create_socket(config.ipc_socket_path); + if (ipc_socket == -1) { + ELOG("Could not create the IPC socket, IPC disabled\n"); + } else { + free(config.ipc_socket_path); + struct ev_io *ipc_io = scalloc(sizeof(struct ev_io)); + ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ); + ev_io_start(main_loop, ipc_io); + } + + /* Also handle the UNIX domain sockets passed via socket activation */ + int fds = sd_listen_fds(1); + if (fds < 0) + ELOG("socket activation: Error in sd_listen_fds\n"); + else if (fds == 0) + DLOG("socket activation: no sockets passed\n"); + else { + for (int fd = SD_LISTEN_FDS_START; fd < (SD_LISTEN_FDS_START + fds); fd++) { + DLOG("socket activation: also listening on fd %d\n", fd); struct ev_io *ipc_io = scalloc(sizeof(struct ev_io)); - ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ); - ev_io_start(loop, ipc_io); + ev_io_init(ipc_io, ipc_new_client, fd, EV_READ); + ev_io_start(main_loop, ipc_io); } } + /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */ + x_set_i3_atoms(); + struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io)); + struct ev_io *xkb = scalloc(sizeof(struct ev_io)); struct ev_check *xcb_check = scalloc(sizeof(struct ev_check)); struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare)); ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ); - ev_io_start(loop, xcb_watcher); + ev_io_start(main_loop, xcb_watcher); + + + if (xkb_supported) { + ev_io_init(xkb, xkb_got_event, ConnectionNumber(xkbdpy), EV_READ); + ev_io_start(main_loop, xkb); + + /* Flush the buffer so that libev can properly get new events */ + XFlush(xkbdpy); + } ev_check_init(xcb_check, xcb_check_cb); - ev_check_start(loop, xcb_check); + ev_check_start(main_loop, xcb_check); ev_prepare_init(xcb_prepare, xcb_prepare_cb); - ev_prepare_start(loop, xcb_prepare); + ev_prepare_start(main_loop, xcb_prepare); xcb_flush(conn); manage_existing_windows(root); - setup_signal_handler(); + if (!disable_signalhandler) + setup_signal_handler(); /* Ignore SIGPIPE to survive errors when an IPC client disconnects * while we are sending him a message */ @@ -399,5 +533,16 @@ int main(int argc, char *argv[]) { } } - ev_loop(loop, 0); + /* Autostarting exec_always-lines */ + struct Autostart *exec_always; + TAILQ_FOREACH(exec_always, &autostarts_always, autostarts_always) { + LOG("auto-starting (always!) %s\n", exec_always->command); + start_application(exec_always->command); + } + + /* Make sure to destroy the event loop to invoke the cleeanup callbacks + * when calling exit() */ + atexit(i3_exit); + + ev_loop(main_loop, 0); }