* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2013 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
*
* main.c: Initialization, main loop
*
#include <sys/resource.h>
#include <sys/mman.h>
#include <sys/stat.h>
+#include <libgen.h>
#include "all.h"
#include "shmlog.h"
* temporarily for drag_pointer(). */
static struct ev_check *xcb_check;
-static int xkb_event_base;
-
-int xkb_current_group;
-
extern Con *focused;
char **start_argv;
xcb_key_symbols_t *keysyms;
-/* Those are our connections to X11 for use with libXcursor and XKB */
-Display *xlibdpy, *xkbdpy;
-
/* Default shmlog size if not set by user. */
const int default_shmlog_size = 25 * 1024 * 1024;
/* We hope that those are supported and set them to true */
bool xcursor_supported = true;
-bool xkb_supported = true;
-
-/* This will be set to true when -C is used so that functions can behave
- * slightly differently. We don’t want i3-nagbar to be started when validating
- * the config, for example. */
-bool only_check_config = false;
/*
* This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
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;
+ xcb_generic_error_t *error = (xcb_generic_error_t *)event;
DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
error->sequence, error->error_code);
}
}
}
-/*
- * 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_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
-
- 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.
*
int main(int argc, char *argv[]) {
/* Keep a symbol pointing to the I3_VERSION string constant so that we have
* it in gdb backtraces. */
- const char *i3_version __attribute__ ((unused)) = I3_VERSION;
+ const char *_i3_version __attribute__((unused)) = i3_version;
char *override_configpath = NULL;
bool autostart = true;
char *layout_path = NULL;
bool force_xinerama = false;
char *fake_outputs = NULL;
bool disable_signalhandler = false;
+ bool only_check_config = false;
static struct option long_options[] = {
{"no-autostart", no_argument, 0, 'a'},
{"config", required_argument, 0, 'c'},
{"fake_outputs", required_argument, 0, 0},
{"fake-outputs", required_argument, 0, 0},
{"force-old-config-parser-v4.4-only", no_argument, 0, 0},
- {0, 0, 0, 0}
- };
+ {0, 0, 0, 0}};
int option_index = 0, opt;
setlocale(LC_ALL, "");
only_check_config = true;
break;
case 'v':
- printf("i3 version " I3_VERSION " © 2009-2013 Michael Stapelberg and contributors\n");
+ printf("i3 version %s © 2009 Michael Stapelberg and contributors\n", i3_version);
exit(EXIT_SUCCESS);
break;
case 'm':
- printf("Binary i3 version: " I3_VERSION " © 2009-2013 Michael Stapelberg and contributors\n");
+ printf("Binary i3 version: %s © 2009 Michael Stapelberg and contributors\n", i3_version);
display_running_version();
exit(EXIT_SUCCESS);
break;
ELOG("You are passing --force-old-config-parser-v4.4-only, but that flag was removed by now.\n");
break;
}
- /* fall-through */
+ /* fall-through */
default:
fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "\t--shmlog-size <limit>\n"
"\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
"\tto 0 disables SHM logging entirely.\n"
- "\tThe default is %d bytes.\n", shmlog_size);
+ "\tThe default is %d bytes.\n",
+ shmlog_size);
fprintf(stderr, "\n");
fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
"to send to a currently running i3 (like i3-msg). This allows you to\n"
}
}
+ if (only_check_config) {
+ exit(parse_configuration(override_configpath, false) ? 0 : 1);
+ }
+
/* If the user passes more arguments, we act like i3-msg would: Just send
* the arguments as an IPC message to i3. This allows for nice semantic
* commands such as 'i3 border none'. */
- if (!only_check_config && optind < argc) {
+ if (optind < argc) {
/* We enable verbose mode so that the user knows what’s going on.
* This should make it easier to find mistakes when the user passes
* arguments by mistake. */
memset(&addr, 0, sizeof(struct sockaddr_un));
addr.sun_family = AF_LOCAL;
strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
- if (connect(sockfd, (const struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0)
+ if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
err(EXIT_FAILURE, "Could not connect to i3");
if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
- (uint8_t*)payload) == -1)
+ (uint8_t *)payload) == -1)
err(EXIT_FAILURE, "IPC: write()");
uint32_t reply_length;
/* Try to enable core dumps by default when running a debug build */
if (is_debug_build()) {
- struct rlimit limit = { RLIM_INFINITY, RLIM_INFINITY };
+ struct rlimit limit = {RLIM_INFINITY, RLIM_INFINITY};
setrlimit(RLIMIT_CORE, &limit);
/* The following code is helpful, but not required. We thus don’t pay
memset(cwd, '\0', cwd_size);
if (read(patternfd, cwd, cwd_size) > 0)
/* a trailing newline is included in cwd */
- LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
+ LOG("CORE DUMPS: Your core_pattern is: \"%s\".\n", cwd);
close(patternfd);
}
free(cwd);
}
- LOG("i3 " I3_VERSION " starting\n");
+ LOG("i3 %s starting\n", i3_version);
conn = xcb_connect(NULL, &conn_screen);
if (xcb_connection_has_error(conn))
* 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");
+ die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
root_screen = xcb_aux_get_screen(conn, conn_screen);
root = root_screen->root;
+/* Place requests for the atoms we need as soon as possible */
+#define xmacro(atom) \
+ xcb_intern_atom_cookie_t atom##_cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
+#include "atoms.xmacro"
+#undef xmacro
+
/* By default, we use the same depth and visual as the root window, which
* usually is TrueColor (24 bit depth) and the corresponding visual.
* However, we also check if a 32 bit depth and visual are available (for
colormap = root_screen->default_colormap;
DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
+ DLOG("root_screen->height_in_pixels = %d, root_screen->height_in_millimeters = %d, dpi = %d\n",
+ root_screen->height_in_pixels, root_screen->height_in_millimeters,
+ (int)((double)root_screen->height_in_pixels * 25.4 / (double)root_screen->height_in_millimeters));
+ DLOG("One logical pixel corresponds to %d physical pixels on this display.\n", logical_px(1));
xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
+/* Setup NetWM atoms */
+#define xmacro(name) \
+ do { \
+ 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); \
+ } \
+ A_##name = reply->atom; \
+ free(reply); \
+ } while (0);
+#include "atoms.xmacro"
+#undef xmacro
+
load_configuration(conn, override_configpath, false);
- if (only_check_config) {
- LOG("Done checking configuration file. Exiting.\n");
- exit(0);
- }
if (config.ipc_socket_path == NULL) {
/* Fall back to a file name in /tmp/ based on the PID */
}
xcb_void_cookie_t cookie;
- cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ ROOT_EVENT_MASK });
+ cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ROOT_EVENT_MASK});
check_error(conn, cookie, "Another window manager seems to be running");
xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
}
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 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);
-
- /* Try to load the X cursors and initialize the XKB extension */
- if (xlibdpy == NULL) {
- ELOG("ERROR: XOpenDisplay() failed, disabling libXcursor/XKB support\n");
- xcursor_supported = false;
- xkb_supported = false;
- } else if (fcntl(ConnectionNumber(xlibdpy), F_SETFD, FD_CLOEXEC) == -1) {
- ELOG("Could not set FD_CLOEXEC on xkbdpy\n");
- return 1;
- } else {
- xcursor_load_cursors();
- /*init_xkb();*/
- }
+ xcursor_load_cursors();
/* 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(XCURSOR_CURSOR_POINTER);
- else xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
-
- if (xkb_supported) {
- int errBase,
- major = XkbMajorVersion,
- minor = XkbMinorVersion;
-
- if (fcntl(ConnectionNumber(xkbdpy), F_SETFD, FD_CLOEXEC) == -1) {
- fprintf(stderr, "Could not set FD_CLOEXEC on xkbdpy\n");
- return 1;
- }
-
- int i1;
- if (!XkbQueryExtension(xkbdpy,&i1,&xkb_event_base,&errBase,&major,&minor)) {
- fprintf(stderr, "XKB not supported by X-server\n");
- xkb_supported = false;
- }
- /* end of ugliness */
+ else
+ xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
- if (xkb_supported && !XkbSelectEvents(xkbdpy, XkbUseCoreKbd,
- XkbMapNotifyMask | XkbStateNotifyMask,
- XkbMapNotifyMask | XkbStateNotifyMask)) {
- fprintf(stderr, "Could not set XKB event mask\n");
- return 1;
- }
+ const xcb_query_extension_reply_t *extreply;
+ extreply = xcb_get_extension_data(conn, &xcb_xkb_id);
+ if (!extreply->present) {
+ DLOG("xkb is not present on this server\n");
+ } else {
+ DLOG("initializing xcb-xkb\n");
+ xcb_xkb_use_extension(conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
+ xcb_xkb_select_events(conn,
+ XCB_XKB_ID_USE_CORE_KBD,
+ XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
+ 0,
+ XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
+ 0xff,
+ 0xff,
+ NULL);
+ xkb_base = extreply->first_event;
}
restore_connect();
- /* Setup NetWM atoms */
- #define xmacro(name) \
- do { \
- 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); \
- } \
- A_ ## name = reply->atom; \
- free(reply); \
- } while (0);
- #include "atoms.xmacro"
- #undef xmacro
-
property_handlers_init();
ewmh_setup_hints();
bool needs_tree_init = true;
if (layout_path) {
- LOG("Trying to restore the layout from %s...", layout_path);
+ LOG("Trying to restore the layout from \"%s\".\n", layout_path);
needs_tree_init = !tree_restore(layout_path, greply);
- if (delete_layout_path)
+ if (delete_layout_path) {
unlink(layout_path);
+ const char *dir = dirname(layout_path);
+ /* possibly fails with ENOTEMPTY if there are files (or
+ * sockets) left. */
+ rmdir(dir);
+ }
free(layout_path);
}
if (needs_tree_init)
ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
pointerreply->root_x, pointerreply->root_y);
output = get_first_output();
+ if (!output)
+ die("No usable outputs available.\n");
}
con_focus(con_descend_focused(output_get_content(output->con)));
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);
x_set_i3_atoms();
ewmh_update_workarea();
+ /* Set the ewmh desktop properties. */
+ ewmh_update_current_desktop();
+ ewmh_update_number_of_desktops();
+ ewmh_update_desktop_names();
+ ewmh_update_desktop_viewport();
+
struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
- struct ev_io *xkb = scalloc(sizeof(struct ev_io));
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(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(main_loop, xcb_check);
xcb_create_pixmap(conn, root->root_depth, pixmap, root->root, width, height);
xcb_create_gc(conn, gc, root->root,
- XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
- (uint32_t[]){ XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS });
+ XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
+ (uint32_t[]){XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS});
xcb_copy_area(conn, root->root, pixmap, gc, 0, 0, 0, 0, width, height);
- xcb_change_window_attributes_checked(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]){ pixmap });
+ xcb_change_window_attributes_checked(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]){pixmap});
xcb_flush(conn);
xcb_free_gc(conn, gc);
xcb_free_pixmap(conn, pixmap);
sigaction(SIGABRT, &action, NULL) == -1 ||
sigaction(SIGFPE, &action, NULL) == -1 ||
sigaction(SIGSEGV, &action, NULL) == -1)
- ELOG("Could not setup signal handler");
+ ELOG("Could not setup signal handler.\n");
}
/* Catch all signals with default action "Term", see signal(7) */
sigaction(SIGALRM, &action, NULL) == -1 ||
sigaction(SIGUSR1, &action, NULL) == -1 ||
sigaction(SIGUSR2, &action, NULL) == -1)
- ELOG("Could not setup signal handler");
+ ELOG("Could not setup signal handler.\n");
/* Ignore SIGPIPE to survive errors when an IPC client disconnects
- * while we are sending him a message */
+ * while we are sending them a message */
signal(SIGPIPE, SIG_IGN);
/* Autostarting exec-lines */
TAILQ_FOREACH(barconfig, &barconfigs, configs) {
char *command = NULL;
sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
- barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
- barconfig->id, current_socketpath);
+ barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
+ barconfig->id, current_socketpath);
LOG("Starting bar process: %s\n", command);
start_application(command, true);
free(command);
projects / i3 / i3 / blobdiff