void ungrabXServer()
{
assert(server_grab_count > 0);
if (--server_grab_count == 0) {
xcb_ungrab_server(connection());
xcb_flush(connection());
}
}
void client_unmanage(Client *c, bool destroyed) {
Monitor *m = c->mon;
/* The server grab construct avoids race conditions. */
client_detach(c);
client_detach_stack(c);
printf("unmanage %i, %i\n", destroyed, c->win);
if(!destroyed) {
uint32_t values[] = { c->oldbw };
xcb_grab_server(conn);
xcb_configure_window_checked(conn, c->win,
XCB_CONFIG_WINDOW_BORDER_WIDTH, values);
xcb_ungrab_button_checked(conn, XCB_BUTTON_INDEX_ANY, c->win,
XCB_GRAB_ANY);
client_set_state(c, XCB_ICCCM_WM_STATE_WITHDRAWN);
xcb_flush(conn);
xcb_ungrab_server(conn);
}
free(c);
client_focus(NULL);
arrange(m);
}
int bind_key(xcb_key_but_mask_t mod_mask, xcb_keysym_t keysym, SCM proc)
{
xcb_grab_server(wm_conf.connection);
xcb_keycode_t *keycode_array = xcb_key_symbols_get_keycode(wm_conf.key_syms,
keysym);
xcb_keycode_t keycode;
int i = 0;
if (keycode_array) {
while ((keycode = keycode_array[i++]) != XCB_NO_SYMBOL) {
xcb_grab_key(wm_conf.connection, 1, wm_conf.screen->root,
mod_mask, keycode,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
}
free(keycode_array);
keybinding_t *binding = keybinding_init(keybinding_alloc());
binding->keysym = keysym;
binding->mod_mask = mod_mask;
binding->scm_proc = proc;
sglib_keybinding_t_add(&keybinding_list, binding);
}
xcb_ungrab_server(wm_conf.connection);
xcb_flush(wm_conf.connection);
return 1;
}
int main(int argc, char **argv)
{
xcb_connection_t *connection = xcb_connect(NULL, &wm_conf.default_screen_num);
if (xcb_connection_has_error(connection)) {
fprintf(stderr, "failed to open display\n");
exit(1);
}
init_wm_conf();
init_conf_dir();
wm_conf.connection = connection;
const xcb_setup_t *setup = xcb_get_setup(connection);
int num_screens = xcb_setup_roots_length(setup);
fprintf(stderr, "init: num_screens = %d\n", num_screens);
fprintf(stderr, "init: default_screen_num = %d\n", wm_conf.default_screen_num);
xcb_screen_t *screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data;
wm_conf.screen = screen;
xcb_window_t root_window = screen->root;
xcb_grab_server(connection);
xcb_flush(connection);
xcb_event_handlers_t *event_handlers = &wm_conf.event_handlers;
xcb_event_handlers_init(connection, event_handlers);
set_exclusive_error_handler(event_handlers, handle_startup_error);
/* Try to get substructure redirect events from root window.
* This will cause an error if a window manager is already running.
*/
const uint32_t sub_redirect = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
xcb_change_window_attributes(connection,
root_window,
XCB_CW_EVENT_MASK,
&sub_redirect);
/* Need to xcb_flush to validate error handler */
xcb_aux_sync(connection);
/* Process all errors in the queue if any */
xcb_event_poll_for_event_loop(event_handlers);
scan_windows();
xinerama_test();
set_exclusive_error_handler(event_handlers, handle_error);
set_event_handlers(event_handlers);
/* Allocate the key symbols */
wm_conf.key_syms = xcb_key_symbols_alloc(connection);
fprintf(stderr, "selecting events from root window\n");
const uint32_t root_win_event_mask = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
XCB_EVENT_MASK_ENTER_WINDOW |
XCB_EVENT_MASK_LEAVE_WINDOW |
XCB_EVENT_MASK_STRUCTURE_NOTIFY |
XCB_EVENT_MASK_PROPERTY_CHANGE |
XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_BUTTON_RELEASE |
XCB_EVENT_MASK_FOCUS_CHANGE;
xcb_change_window_attributes(connection, root_window, XCB_CW_EVENT_MASK, &root_win_event_mask);
xcb_ungrab_server(connection);
xcb_flush(connection);
wm_conf.repl_server = repl_server_init();
load_init_scheme();
fprintf(stderr, "entering event loop\n");
event_loop();
xcb_disconnect(connection);
return 0;
}
/** Hello, this is main.
* \param argc Who knows.
* \param argv Who knows.
* \return EXIT_SUCCESS I hope.
*/
int
main(int argc, char **argv)
{
char *confpath = NULL;
int xfd, i, screen_nbr, opt, colors_nbr;
xcolor_init_request_t colors_reqs[2];
ssize_t cmdlen = 1;
xdgHandle xdg;
xcb_generic_event_t *event;
static struct option long_options[] =
{
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "check", 0, NULL, 'k' },
{ NULL, 0, NULL, 0 }
};
/* event loop watchers */
ev_io xio = { .fd = -1 };
ev_check xcheck;
ev_prepare a_refresh;
ev_signal sigint;
ev_signal sigterm;
ev_signal sighup;
/* clear the globalconf structure */
p_clear(&globalconf, 1);
globalconf.keygrabber = LUA_REFNIL;
globalconf.mousegrabber = LUA_REFNIL;
buffer_init(&globalconf.startup_errors);
/* save argv */
for(i = 0; i < argc; i++)
cmdlen += a_strlen(argv[i]) + 1;
globalconf.argv = p_new(char, cmdlen);
a_strcpy(globalconf.argv, cmdlen, argv[0]);
for(i = 1; i < argc; i++)
{
a_strcat(globalconf.argv, cmdlen, " ");
a_strcat(globalconf.argv, cmdlen, argv[i]);
}
/* Text won't be printed correctly otherwise */
setlocale(LC_CTYPE, "");
/* Get XDG basedir data */
xdgInitHandle(&xdg);
/* init lua */
luaA_init(&xdg);
/* check args */
while((opt = getopt_long(argc, argv, "vhkc:",
long_options, NULL)) != -1)
switch(opt)
{
case 'v':
eprint_version();
break;
case 'h':
exit_help(EXIT_SUCCESS);
break;
case 'k':
if(!luaA_parserc(&xdg, confpath, false))
{
fprintf(stderr, "✘ Configuration file syntax error.\n");
return EXIT_FAILURE;
}
else
{
fprintf(stderr, "✔ Configuration file syntax OK.\n");
return EXIT_SUCCESS;
}
case 'c':
if(a_strlen(optarg))
confpath = a_strdup(optarg);
else
fatal("-c option requires a file name");
break;
}
globalconf.loop = ev_default_loop(0);
ev_timer_init(&globalconf.timer, &luaA_on_timer, 0., 0.);
/* register function for signals */
ev_signal_init(&sigint, exit_on_signal, SIGINT);
ev_signal_init(&sigterm, exit_on_signal, SIGTERM);
ev_signal_init(&sighup, restart_on_signal, SIGHUP);
ev_signal_start(globalconf.loop, &sigint);
ev_signal_start(globalconf.loop, &sigterm);
ev_signal_start(globalconf.loop, &sighup);
ev_unref(globalconf.loop);
ev_unref(globalconf.loop);
ev_unref(globalconf.loop);
struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 };
sigemptyset(&sa.sa_mask);
sigaction(SIGSEGV, &sa, 0);
/* XLib sucks */
XkbIgnoreExtension(True);
/* X stuff */
globalconf.display = XOpenDisplay(NULL);
if (globalconf.display == NULL)
fatal("cannot open display");
globalconf.default_screen = XDefaultScreen(globalconf.display);
globalconf.connection = XGetXCBConnection(globalconf.display);
/* Double checking then everything is OK. */
if(xcb_connection_has_error(globalconf.connection))
fatal("cannot open display");
/* Prefetch all the extensions we might need */
xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_shape_id);
/* initialize dbus */
a_dbus_init();
/* Get the file descriptor corresponding to the X connection */
xfd = xcb_get_file_descriptor(globalconf.connection);
ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ);
ev_io_start(globalconf.loop, &xio);
ev_check_init(&xcheck, &a_xcb_check_cb);
ev_check_start(globalconf.loop, &xcheck);
ev_unref(globalconf.loop);
ev_prepare_init(&a_refresh, &a_refresh_cb);
ev_prepare_start(globalconf.loop, &a_refresh);
ev_unref(globalconf.loop);
/* Grab server */
xcb_grab_server(globalconf.connection);
/* Make sure there are no pending events. Since we didn't really do anything
* at all yet, we will just discard all events which we received so far.
* The above GrabServer should make sure no new events are generated. */
xcb_aux_sync(globalconf.connection);
while ((event = xcb_poll_for_event(globalconf.connection)) != NULL)
{
/* Make sure errors are printed */
uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event);
if(response_type == 0)
event_handle(event);
p_delete(&event);
}
for(screen_nbr = 0;
screen_nbr < xcb_setup_roots_length(xcb_get_setup(globalconf.connection));
screen_nbr++)
{
const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
/* This causes an error if some other window manager is running */
xcb_change_window_attributes(globalconf.connection,
xutil_screen_get(globalconf.connection, screen_nbr)->root,
XCB_CW_EVENT_MASK, &select_input_val);
}
/* Need to xcb_flush to validate error handler */
xcb_aux_sync(globalconf.connection);
/* Process all errors in the queue if any. There can be no events yet, so if
* this function returns something, it must be an error. */
if (xcb_poll_for_event(globalconf.connection) != NULL)
fatal("another window manager is already running");
/* Prefetch the maximum request length */
xcb_prefetch_maximum_request_length(globalconf.connection);
/* check for xtest extension */
const xcb_query_extension_reply_t *xtest_query;
xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id);
globalconf.have_xtest = xtest_query->present;
/* Allocate the key symbols */
globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection);
xcb_get_modifier_mapping_cookie_t xmapping_cookie =
xcb_get_modifier_mapping_unchecked(globalconf.connection);
/* init atom cache */
atoms_init(globalconf.connection);
/* init screens information */
screen_scan();
/* init default font and colors */
colors_reqs[0] = xcolor_init_unchecked(&globalconf.colors.fg,
"black", sizeof("black") - 1);
colors_reqs[1] = xcolor_init_unchecked(&globalconf.colors.bg,
"white", sizeof("white") - 1);
globalconf.font = draw_font_new("sans 8");
for(colors_nbr = 0; colors_nbr < 2; colors_nbr++)
xcolor_init_reply(colors_reqs[colors_nbr]);
xutil_lock_mask_get(globalconf.connection, xmapping_cookie,
globalconf.keysyms, &globalconf.numlockmask,
&globalconf.shiftlockmask, &globalconf.capslockmask,
&globalconf.modeswitchmask);
/* Get the window tree associated to this screen */
const int screen_max = xcb_setup_roots_length(xcb_get_setup(globalconf.connection));
xcb_query_tree_cookie_t tree_c[screen_max];
/* do this only for real screen */
for(screen_nbr = 0; screen_nbr < screen_max; screen_nbr++)
{
/* select for events */
const uint32_t change_win_vals[] =
{
XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY
| XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW
| XCB_EVENT_MASK_STRUCTURE_NOTIFY
| XCB_EVENT_MASK_PROPERTY_CHANGE
| XCB_EVENT_MASK_BUTTON_PRESS
| XCB_EVENT_MASK_BUTTON_RELEASE
| XCB_EVENT_MASK_FOCUS_CHANGE
};
tree_c[screen_nbr] = xcb_query_tree_unchecked(globalconf.connection,
xutil_screen_get(globalconf.connection, screen_nbr)->root);
xcb_change_window_attributes(globalconf.connection,
xutil_screen_get(globalconf.connection, screen_nbr)->root,
XCB_CW_EVENT_MASK,
change_win_vals);
ewmh_init(screen_nbr);
systray_init(screen_nbr);
}
/* init spawn (sn) */
spawn_init();
/* we will receive events, stop grabbing server */
xcb_ungrab_server(globalconf.connection);
/* Parse and run configuration file */
if (!luaA_parserc(&xdg, confpath, true))
fatal("couldn't find any rc file");
scan(tree_c);
xcb_flush(globalconf.connection);
/* main event loop */
ev_loop(globalconf.loop, 0);
/* cleanup event loop */
ev_ref(globalconf.loop);
ev_check_stop(globalconf.loop, &xcheck);
ev_ref(globalconf.loop);
ev_prepare_stop(globalconf.loop, &a_refresh);
ev_ref(globalconf.loop);
ev_io_stop(globalconf.loop, &xio);
awesome_atexit(false);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
memset(&globalconf, 0, sizeof(globalconf));
globalconf.connection = xcb_connect(NULL, &globalconf.screen_nbr);
if(xcb_connection_has_error(globalconf.connection))
fatal("Cannot open display");
/* Get the root window */
globalconf.screen = xcb_aux_get_screen(globalconf.connection,
globalconf.screen_nbr);
/* Set up signal handlers and function called on normal exit */
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler = exit_on_signal;
sa.sa_flags = 0;
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
atexit(exit_cleanup);
/**
* First round-trip
*/
/* Send requests for EWMH atoms initialisation */
xcb_intern_atom_cookie_t *ewmh_cookies = atoms_init();
parse_command_line_parameters(argc, argv);
/* Prefetch the extensions data */
xcb_prefetch_extension_data(globalconf.connection, &xcb_composite_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_damage_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_xfixes_id);
/* Initialise errors handlers */
xcb_event_handlers_init(globalconf.connection, &globalconf.evenths);
event_init_start_handlers();
/* Pre-initialisation of the rendering backend */
if(!rendering_load())
{
free(ewmh_cookies);
fatal("Can't initialise rendering backend");
}
/* Get replies for EWMH atoms initialisation */
if(!atoms_init_finalise(ewmh_cookies))
/* No need to free ewmh_cookies in case of error as it's already
handles by xcb-ewmh when getting the replies */
fatal("Cannot initialise atoms");
/* First check whether there is already a Compositing Manager (ICCCM) */
xcb_get_selection_owner_cookie_t wm_cm_owner_cookie =
xcb_ewmh_get_wm_cm_owner(&globalconf.ewmh, globalconf.screen_nbr);
/**
* Second round-trip
*/
/* Initialise extensions based on the cache and perform
initialisation of the rendering backend */
display_init_extensions();
if(!(*globalconf.rendering->init)())
return EXIT_FAILURE;
/* Check ownership for WM_CM_Sn before actually claiming it (ICCCM) */
xcb_window_t wm_cm_owner_win;
if(xcb_ewmh_get_wm_cm_owner_reply(&globalconf.ewmh, wm_cm_owner_cookie,
&wm_cm_owner_win, NULL) &&
wm_cm_owner_win != XCB_NONE)
fatal("A compositing manager is already active (window=%jx)",
(uintmax_t) wm_cm_owner_win);
/* Now send requests to register the CM */
display_register_cm();
/**
* Third round-trip
*/
/* Check extensions version and finish initialisation of the
rendering backend */
display_init_extensions_finalise();
if(!(*globalconf.rendering->init_finalise)())
return EXIT_FAILURE;
/* All the plugins given in the configuration file */
plugin_load_all();
/* Validate errors and get PropertyNotify needed to acquire
_NET_WM_CM_Sn ownership */
xcb_aux_sync(globalconf.connection);
xcb_event_poll_for_event_loop(&globalconf.evenths);
globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection);
xcb_get_modifier_mapping_cookie_t key_mapping_cookie =
xcb_get_modifier_mapping_unchecked(globalconf.connection);
/* Finish CM X registration */
if(!display_register_cm_finalise())
fatal("Could not acquire _NET_WM_CM_Sn ownership");
/**
* Last initialisation round-trip
*/
/* Grab the server before performing redirection and get the tree of
windows to ensure there won't be anything else at the same
time */
xcb_grab_server(globalconf.connection);
/* Now redirect windows and add existing windows */
display_init_redirect();
/* Validate errors handlers during redirect */
xcb_aux_sync(globalconf.connection);
xcb_event_poll_for_event_loop(&globalconf.evenths);
/* Manage existing windows */
display_init_redirect_finalise();
xcb_ungrab_server(globalconf.connection);
/* Check the plugin requirements which will disable plugins which
don't meet the requirements */
plugin_check_requirements();
/* Get the lock masks reply of the request previously sent */
key_lock_mask_get_reply(key_mapping_cookie);
/* Initialise normal errors and events handlers */
event_init_handlers();
xcb_generic_event_t *event;
/* Flush existing requests before the loop as DamageNotify events
may have been received in the meantime */
xcb_flush(globalconf.connection);
globalconf.do_repaint = true;
/* Main event and error loop */
do
{
/* Block until an event is received */
event = xcb_wait_for_event(globalconf.connection);
/* Check X connection to avoid SIGSEGV */
if(xcb_connection_has_error(globalconf.connection))
fatal("X connection invalid");
xcb_event_handle(&globalconf.evenths, event);
free(event);
/* Then process all remaining events in the queue because before
painting, all the DamageNotify have to be received */
xcb_event_poll_for_event_loop(&globalconf.evenths);
/* Now paint the windows */
if(globalconf.do_repaint)
{
window_t *windows = NULL;
for(plugin_t *plugin = globalconf.plugins; plugin; plugin = plugin->next)
if(plugin->enable && plugin->vtable->render_windows &&
(windows = (*plugin->vtable->render_windows)()))
break;
if(!windows)
windows = globalconf.windows;
window_paint_all(windows);
xcb_aux_sync(globalconf.connection);
}
globalconf.do_repaint = false;
}
while(true);
return EXIT_SUCCESS;
}
static xcb_rectangle_t get_window_position(void) {
xcb_rectangle_t result = (xcb_rectangle_t){logical_px(50), logical_px(50), MAX_WIDTH, font.height + 2 * BORDER + 2 * PADDING};
xcb_get_property_reply_t *supporting_wm_reply = NULL;
xcb_get_input_focus_reply_t *input_focus = NULL;
xcb_get_geometry_reply_t *geometry = NULL;
xcb_get_property_reply_t *wm_class = NULL;
xcb_translate_coordinates_reply_t *coordinates = NULL;
xcb_atom_t A__NET_SUPPORTING_WM_CHECK;
xcb_intern_atom_cookie_t nswc_cookie = xcb_intern_atom(conn, 0, strlen("_NET_SUPPORTING_WM_CHECK"), "_NET_SUPPORTING_WM_CHECK");
xcb_intern_atom_reply_t *nswc_reply = xcb_intern_atom_reply(conn, nswc_cookie, NULL);
if (nswc_reply == NULL) {
ELOG("Could not intern atom _NET_SUPPORTING_WM_CHECK\n");
exit(-1);
}
A__NET_SUPPORTING_WM_CHECK = nswc_reply->atom;
free(nswc_reply);
supporting_wm_reply = xcb_get_property_reply(
conn, xcb_get_property(conn, false, root, A__NET_SUPPORTING_WM_CHECK, XCB_ATOM_WINDOW, 0, 32), NULL);
xcb_window_t *supporting_wm_win = NULL;
if (supporting_wm_reply == NULL || xcb_get_property_value_length(supporting_wm_reply) == 0) {
DLOG("Could not determine EWMH support window.\n");
} else {
supporting_wm_win = xcb_get_property_value(supporting_wm_reply);
}
/* In rare cases, the window holding the input focus might disappear while we are figuring out its
* position. To avoid this, we grab the server in the meantime. */
xcb_grab_server(conn);
input_focus = xcb_get_input_focus_reply(conn, xcb_get_input_focus(conn), NULL);
if (input_focus == NULL || input_focus->focus == XCB_NONE) {
DLOG("Failed to receive the current input focus or no window has the input focus right now.\n");
goto free_resources;
}
/* We need to ignore the EWMH support window to which the focus can be set if there's no suitable window to focus. */
if (supporting_wm_win != NULL && input_focus->focus == *supporting_wm_win) {
DLOG("Input focus is on the EWMH support window, ignoring.\n");
goto free_resources;
}
geometry = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, input_focus->focus), NULL);
if (geometry == NULL) {
DLOG("Failed to received window geometry.\n");
goto free_resources;
}
wm_class = xcb_get_property_reply(
conn, xcb_get_property(conn, false, input_focus->focus, XCB_ATOM_WM_CLASS, XCB_GET_PROPERTY_TYPE_ANY, 0, 32), NULL);
/* We need to find out whether the input focus is on an i3 frame window. If it is, we must not translate the coordinates. */
if (wm_class == NULL || xcb_get_property_value_length(wm_class) == 0 || strcmp(xcb_get_property_value(wm_class), "i3-frame") != 0) {
coordinates = xcb_translate_coordinates_reply(
conn, xcb_translate_coordinates(conn, input_focus->focus, root, geometry->x, geometry->y), NULL);
if (coordinates == NULL) {
DLOG("Failed to translate coordinates.\n");
goto free_resources;
}
DLOG("Determined coordinates of window with input focus at x = %i / y = %i.\n", coordinates->dst_x, coordinates->dst_y);
result.x += coordinates->dst_x;
result.y += coordinates->dst_y;
} else {
DLOG("Determined coordinates of window with input focus at x = %i / y = %i.\n", geometry->x, geometry->y);
result.x += geometry->x;
result.y += geometry->y;
}
free_resources:
xcb_ungrab_server(conn);
xcb_flush(conn);
FREE(supporting_wm_reply);
FREE(input_focus);
FREE(geometry);
FREE(wm_class);
FREE(coordinates);
return result;
}
/** Hello, this is main.
* \param argc Who knows.
* \param argv Who knows.
* \return EXIT_SUCCESS I hope.
*/
int
main(int argc, char **argv)
{
char *confpath = NULL;
int xfd, i, opt;
ssize_t cmdlen = 1;
xdgHandle xdg;
bool no_argb = false;
xcb_generic_event_t *event;
xcb_query_tree_cookie_t tree_c;
static struct option long_options[] =
{
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "check", 0, NULL, 'k' },
{ "no-argb", 0, NULL, 'a' },
{ NULL, 0, NULL, 0 }
};
/* event loop watchers */
ev_io xio = { .fd = -1 };
ev_check xcheck;
ev_prepare a_refresh;
ev_signal sigint;
ev_signal sigterm;
ev_signal sighup;
/* clear the globalconf structure */
p_clear(&globalconf, 1);
globalconf.keygrabber = LUA_REFNIL;
globalconf.mousegrabber = LUA_REFNIL;
buffer_init(&globalconf.startup_errors);
/* save argv */
for(i = 0; i < argc; i++)
cmdlen += a_strlen(argv[i]) + 1;
awesome_argv = p_new(char, cmdlen);
a_strcpy(awesome_argv, cmdlen, argv[0]);
for(i = 1; i < argc; i++)
{
a_strcat(awesome_argv, cmdlen, " ");
a_strcat(awesome_argv, cmdlen, argv[i]);
}
/* Text won't be printed correctly otherwise */
setlocale(LC_CTYPE, "");
/* Get XDG basedir data */
xdgInitHandle(&xdg);
/* init lua */
luaA_init(&xdg);
/* check args */
while((opt = getopt_long(argc, argv, "vhkc:a",
long_options, NULL)) != -1)
switch(opt)
{
case 'v':
eprint_version();
break;
case 'h':
exit_help(EXIT_SUCCESS);
break;
case 'k':
if(!luaA_parserc(&xdg, confpath, false))
{
fprintf(stderr, "✘ Configuration file syntax error.\n");
return EXIT_FAILURE;
}
else
{
fprintf(stderr, "✔ Configuration file syntax OK.\n");
return EXIT_SUCCESS;
}
case 'c':
if(a_strlen(optarg))
confpath = a_strdup(optarg);
else
fatal("-c option requires a file name");
break;
case 'a':
no_argb = true;
break;
}
globalconf.loop = ev_default_loop(EVFLAG_NOSIGFD);
/* register function for signals */
ev_signal_init(&sigint, exit_on_signal, SIGINT);
ev_signal_init(&sigterm, exit_on_signal, SIGTERM);
ev_signal_init(&sighup, restart_on_signal, SIGHUP);
ev_signal_start(globalconf.loop, &sigint);
ev_signal_start(globalconf.loop, &sigterm);
ev_signal_start(globalconf.loop, &sighup);
ev_unref(globalconf.loop);
ev_unref(globalconf.loop);
ev_unref(globalconf.loop);
struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 };
sigemptyset(&sa.sa_mask);
sigaction(SIGSEGV, &sa, 0);
/* X stuff */
globalconf.connection = xcb_connect(NULL, &globalconf.default_screen);
if(xcb_connection_has_error(globalconf.connection))
fatal("cannot open display");
globalconf.screen = xcb_aux_get_screen(globalconf.connection, globalconf.default_screen);
/* FIXME The following two assignments were swapped on purpose */
if(!no_argb)
globalconf.visual = a_default_visual(globalconf.screen);
if(!globalconf.visual)
globalconf.visual = a_argb_visual(globalconf.screen);
globalconf.default_depth = a_visual_depth(globalconf.screen, globalconf.visual->visual_id);
globalconf.default_cmap = globalconf.screen->default_colormap;
if(globalconf.default_depth != globalconf.screen->root_depth)
{
// We need our own color map if we aren't using the default depth
globalconf.default_cmap = xcb_generate_id(globalconf.connection);
xcb_create_colormap(globalconf.connection, XCB_COLORMAP_ALLOC_NONE,
globalconf.default_cmap, globalconf.screen->root,
globalconf.visual->visual_id);
}
/* Prefetch all the extensions we might need */
xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id);
xcb_prefetch_extension_data(globalconf.connection, &xcb_xinerama_id);
/* initialize dbus */
a_dbus_init();
/* Get the file descriptor corresponding to the X connection */
xfd = xcb_get_file_descriptor(globalconf.connection);
ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ);
ev_io_start(globalconf.loop, &xio);
ev_check_init(&xcheck, &a_xcb_check_cb);
ev_check_start(globalconf.loop, &xcheck);
ev_unref(globalconf.loop);
ev_prepare_init(&a_refresh, &a_refresh_cb);
ev_prepare_start(globalconf.loop, &a_refresh);
ev_unref(globalconf.loop);
/* Grab server */
xcb_grab_server(globalconf.connection);
/* Make sure there are no pending events. Since we didn't really do anything
* at all yet, we will just discard all events which we received so far.
* The above GrabServer should make sure no new events are generated. */
xcb_aux_sync(globalconf.connection);
while ((event = xcb_poll_for_event(globalconf.connection)) != NULL)
{
/* Make sure errors are printed */
uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event);
if(response_type == 0)
event_handle(event);
p_delete(&event);
}
{
const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
/* This causes an error if some other window manager is running */
xcb_change_window_attributes(globalconf.connection,
globalconf.screen->root,
XCB_CW_EVENT_MASK, &select_input_val);
}
/* Need to xcb_flush to validate error handler */
xcb_aux_sync(globalconf.connection);
/* Process all errors in the queue if any. There can be no events yet, so if
* this function returns something, it must be an error. */
if (xcb_poll_for_event(globalconf.connection) != NULL)
fatal("another window manager is already running");
/* Prefetch the maximum request length */
xcb_prefetch_maximum_request_length(globalconf.connection);
/* check for xtest extension */
const xcb_query_extension_reply_t *xtest_query;
xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id);
globalconf.have_xtest = xtest_query->present;
/* Allocate the key symbols */
globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection);
xcb_get_modifier_mapping_cookie_t xmapping_cookie =
xcb_get_modifier_mapping_unchecked(globalconf.connection);
/* init atom cache */
atoms_init(globalconf.connection);
/* init screens information */
screen_scan();
xutil_lock_mask_get(globalconf.connection, xmapping_cookie,
globalconf.keysyms, &globalconf.numlockmask,
&globalconf.shiftlockmask, &globalconf.capslockmask,
&globalconf.modeswitchmask);
/* do this only for real screen */
ewmh_init();
systray_init();
/* init spawn (sn) */
spawn_init();
/* The default GC is just a newly created associated with a window with
* depth globalconf.default_depth */
xcb_window_t tmp_win = xcb_generate_id(globalconf.connection);
globalconf.gc = xcb_generate_id(globalconf.connection);
xcb_create_window(globalconf.connection, globalconf.default_depth,
tmp_win, globalconf.screen->root,
-1, -1, 1, 1, 0,
XCB_COPY_FROM_PARENT, globalconf.visual->visual_id,
XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP,
(const uint32_t [])
{
globalconf.screen->black_pixel,
globalconf.screen->black_pixel,
globalconf.default_cmap
});
xcb_create_gc(globalconf.connection, globalconf.gc, tmp_win, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND,
(const uint32_t[]) {
globalconf.screen->black_pixel, globalconf.screen->white_pixel
});
xcb_destroy_window(globalconf.connection, tmp_win);
/* Get the window tree associated to this screen */
tree_c = xcb_query_tree_unchecked(globalconf.connection,
globalconf.screen->root);
xcb_change_window_attributes(globalconf.connection,
globalconf.screen->root,
XCB_CW_EVENT_MASK,
ROOT_WINDOW_EVENT_MASK);
/* we will receive events, stop grabbing server */
xcb_ungrab_server(globalconf.connection);
/* Parse and run configuration file */
if (!luaA_parserc(&xdg, confpath, true))
fatal("couldn't find any rc file");
p_delete(&confpath);
xdgWipeHandle(&xdg);
/* scan existing windows */
scan(tree_c);
xcb_flush(globalconf.connection);
/* main event loop */
ev_loop(globalconf.loop, 0);
/* cleanup event loop */
ev_ref(globalconf.loop);
ev_check_stop(globalconf.loop, &xcheck);
ev_ref(globalconf.loop);
ev_prepare_stop(globalconf.loop, &a_refresh);
ev_ref(globalconf.loop);
ev_io_stop(globalconf.loop, &xio);
awesome_atexit(false);
return EXIT_SUCCESS;
}