i3
config_directives.c
Go to the documentation of this file.
1/*
2 * vim:ts=4:sw=4:expandtab
3 *
4 * i3 - an improved tiling window manager
5 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
6 *
7 * config_directives.c: all config storing functions (see config_parser.c)
8 *
9 */
10#include "all.h"
11
12#include <wordexp.h>
13
14/*******************************************************************************
15 * Include functions.
16 ******************************************************************************/
17
18CFGFUN(include, const char *pattern) {
19 DLOG("include %s\n", pattern);
20
21 wordexp_t p;
22 const int ret = wordexp(pattern, &p, 0);
23 if (ret != 0) {
24 ELOG("wordexp(%s): error %d\n", pattern, ret);
25 result->has_errors = true;
26 return;
27 }
28 char **w = p.we_wordv;
29 for (size_t i = 0; i < p.we_wordc; i++) {
30 char resolved_path[PATH_MAX] = {'\0'};
31 if (realpath(w[i], resolved_path) == NULL) {
32 LOG("Skipping %s: %s\n", w[i], strerror(errno));
33 continue;
34 }
35
36 bool skip = false;
37 IncludedFile *file;
38 TAILQ_FOREACH (file, &included_files, files) {
39 if (strcmp(file->path, resolved_path) == 0) {
40 skip = true;
41 break;
42 }
43 }
44 if (skip) {
45 LOG("Skipping file %s (already included)\n", resolved_path);
46 continue;
47 }
48
49 LOG("Including config file %s\n", resolved_path);
50
51 file = scalloc(1, sizeof(IncludedFile));
52 file->path = sstrdup(resolved_path);
53 TAILQ_INSERT_TAIL(&included_files, file, files);
54
55 struct stack stack;
56 memset(&stack, '\0', sizeof(struct stack));
57 struct parser_ctx ctx = {
58 .use_nagbar = result->ctx->use_nagbar,
59 .stack = &stack,
60 .variables = result->ctx->variables,
61 };
62 switch (parse_file(&ctx, resolved_path, file)) {
64 break;
65
67 ELOG("including config file %s: %s\n", resolved_path, strerror(errno));
68 /* fallthrough */
69
71 result->has_errors = true;
72 TAILQ_REMOVE(&included_files, file, files);
73 FREE(file->path);
74 FREE(file->raw_contents);
76 FREE(file);
77 break;
78
79 default:
80 /* missing case statement */
81 assert(false);
82 break;
83 }
84 }
85 wordfree(&p);
86}
87
88/*******************************************************************************
89 * Criteria functions.
90 ******************************************************************************/
91
93
94/*
95 * Initializes the specified 'Match' data structure and the initial state of
96 * commands.c for matching target windows of a command.
97 *
98 */
99CFGFUN(criteria_init, int _state) {
100 criteria_next_state = _state;
101
102 DLOG("Initializing criteria, current_match = %p, state = %d\n", current_match, _state);
105}
106
107CFGFUN(criteria_pop_state) {
108 result->next_state = criteria_next_state;
109}
110
111/*
112 * Interprets a ctype=cvalue pair and adds it to the current match
113 * specification.
114 *
115 */
116CFGFUN(criteria_add, const char *ctype, const char *cvalue) {
117 match_parse_property(current_match, ctype, cvalue);
118}
119
120/*******************************************************************************
121 * Utility functions
122 ******************************************************************************/
123
124/*
125 * A utility function to convert a string containing the group and modifiers to
126 * the corresponding bit mask.
127 */
129 /* It might be better to use strtok() here, but the simpler strstr() should
130 * do for now. */
131 i3_event_state_mask_t result = 0;
132 if (str == NULL) {
133 return result;
134 }
135 if (strstr(str, "Mod1") != NULL) {
136 result |= XCB_KEY_BUT_MASK_MOD_1;
137 }
138 if (strstr(str, "Mod2") != NULL) {
139 result |= XCB_KEY_BUT_MASK_MOD_2;
140 }
141 if (strstr(str, "Mod3") != NULL) {
142 result |= XCB_KEY_BUT_MASK_MOD_3;
143 }
144 if (strstr(str, "Mod4") != NULL) {
145 result |= XCB_KEY_BUT_MASK_MOD_4;
146 }
147 if (strstr(str, "Mod5") != NULL) {
148 result |= XCB_KEY_BUT_MASK_MOD_5;
149 }
150 if (strstr(str, "Control") != NULL ||
151 strstr(str, "Ctrl") != NULL) {
152 result |= XCB_KEY_BUT_MASK_CONTROL;
153 }
154 if (strstr(str, "Shift") != NULL) {
155 result |= XCB_KEY_BUT_MASK_SHIFT;
156 }
157
158 if (strstr(str, "Group1") != NULL) {
159 result |= (I3_XKB_GROUP_MASK_1 << 16);
160 }
161 if (strstr(str, "Group2") != NULL ||
162 strstr(str, "Mode_switch") != NULL) {
163 result |= (I3_XKB_GROUP_MASK_2 << 16);
164 }
165 if (strstr(str, "Group3") != NULL) {
166 result |= (I3_XKB_GROUP_MASK_3 << 16);
167 }
168 if (strstr(str, "Group4") != NULL) {
169 result |= (I3_XKB_GROUP_MASK_4 << 16);
170 }
171 return result;
172}
173
174CFGFUN(font, const char *font) {
175 config.font = load_font(font, true);
177}
178
179CFGFUN(binding, const char *bindtype, const char *modifiers, const char *key, const char *release, const char *border, const char *whole_window, const char *exclude_titlebar, const char *command) {
180 configure_binding(bindtype, modifiers, key, release, border, whole_window, exclude_titlebar, command, DEFAULT_BINDING_MODE, false);
181}
182
183/*******************************************************************************
184 * Mode handling
185 ******************************************************************************/
186
187static char *current_mode;
189
190CFGFUN(mode_binding, const char *bindtype, const char *modifiers, const char *key, const char *release, const char *border, const char *whole_window, const char *exclude_titlebar, const char *command) {
191 if (current_mode == NULL) {
192 /* When using an invalid mode name, e.g. “default” */
193 return;
194 }
195
196 configure_binding(bindtype, modifiers, key, release, border, whole_window, exclude_titlebar, command, current_mode, current_mode_pango_markup);
197}
198
199CFGFUN(enter_mode, const char *pango_markup, const char *modename) {
200 if (strcmp(modename, DEFAULT_BINDING_MODE) == 0) {
201 ELOG("You cannot use the name %s for your mode\n", DEFAULT_BINDING_MODE);
202 return;
203 }
204
205 struct Mode *mode;
206 SLIST_FOREACH (mode, &modes, modes) {
207 if (strcmp(mode->name, modename) == 0) {
208 ELOG("The binding mode with name \"%s\" is defined at least twice.\n", modename);
209 }
210 }
211
212 DLOG("\t now in mode %s\n", modename);
214 current_mode = sstrdup(modename);
216}
217
218CFGFUN(exec, const char *exectype, const char *no_startup_id, const char *command) {
219 struct Autostart *new = smalloc(sizeof(struct Autostart));
220 new->command = sstrdup(command);
221 new->no_startup_id = (no_startup_id != NULL);
222 if (strcmp(exectype, "exec") == 0) {
224 } else {
226 }
227}
228
229CFGFUN(for_window, const char *command) {
230 if (current_match->error != NULL) {
231 ELOG("match has error: %s\n", current_match->error);
232 return;
233 }
235 ELOG("Match is empty, ignoring this for_window statement\n");
236 return;
237 }
238 DLOG("\t should execute command %s for the criteria mentioned above\n", command);
239 Assignment *assignment = scalloc(1, sizeof(Assignment));
240 assignment->type = A_COMMAND;
241 match_copy(&(assignment->match), current_match);
242 assignment->dest.command = sstrdup(command);
244}
245
246static void apply_gaps(gaps_t *gaps, gaps_mask_t mask, int value) {
247 if (gaps == NULL) {
248 return;
249 }
250 if (mask & GAPS_INNER) {
251 gaps->inner = value;
252 }
253 if (mask & GAPS_TOP) {
254 gaps->top = value;
255 }
256 if (mask & GAPS_RIGHT) {
257 gaps->right = value;
258 }
259 if (mask & GAPS_BOTTOM) {
260 gaps->bottom = value;
261 }
262 if (mask & GAPS_LEFT) {
263 gaps->left = value;
264 }
265}
266
267static void create_gaps_assignment(const char *workspace, const gaps_mask_t mask, const int pixels) {
268 if (mask == 0) {
269 return;
270 }
271
272 DLOG("Setting gaps for workspace %s", workspace);
273
274 bool found = false;
275 struct Workspace_Assignment *assignment;
277 if (strcasecmp(assignment->name, workspace) == 0) {
278 found = true;
279 break;
280 }
281 }
282
283 /* Assignment does not yet exist, let's create it. */
284 if (!found) {
285 assignment = scalloc(1, sizeof(struct Workspace_Assignment));
286 assignment->name = sstrdup(workspace);
287 assignment->output = NULL;
289 }
290
291 assignment->gaps_mask |= mask;
292 apply_gaps(&assignment->gaps, mask, pixels);
293}
294
295static gaps_mask_t gaps_scope_to_mask(const char *scope) {
296 if (!strcmp(scope, "inner")) {
297 return GAPS_INNER;
298 } else if (!strcmp(scope, "outer")) {
299 return GAPS_OUTER;
300 } else if (!strcmp(scope, "vertical")) {
301 return GAPS_VERTICAL;
302 } else if (!strcmp(scope, "horizontal")) {
303 return GAPS_HORIZONTAL;
304 } else if (!strcmp(scope, "top")) {
305 return GAPS_TOP;
306 } else if (!strcmp(scope, "right")) {
307 return GAPS_RIGHT;
308 } else if (!strcmp(scope, "bottom")) {
309 return GAPS_BOTTOM;
310 } else if (!strcmp(scope, "left")) {
311 return GAPS_LEFT;
312 }
313 ELOG("Invalid command, cannot process scope %s", scope);
314 return 0;
315}
316
317CFGFUN(gaps, const char *workspace, const char *scope, const long value) {
318 int pixels = logical_px(value);
319 gaps_mask_t mask = gaps_scope_to_mask(scope);
320
321 if (workspace == NULL) {
322 apply_gaps(&config.gaps, mask, pixels);
323 } else {
324 create_gaps_assignment(workspace, mask, pixels);
325 }
326}
327
328CFGFUN(smart_borders, const char *enable) {
329 if (!strcmp(enable, "no_gaps")) {
331 } else if (boolstr(enable)) {
333 /* Only enable this if hide_edge_borders is at the default value as it otherwise takes precedence */
335 } else {
336 ELOG("Both hide_edge_borders and smart_borders was used. "
337 "Ignoring smart_borders as it is deprecated.\n");
338 }
339 }
340}
341
342CFGFUN(smart_gaps, const char *enable) {
343 if (!strcmp(enable, "inverse_outer")) {
345 } else {
347 }
348}
349
350CFGFUN(floating_minimum_size, const long width, const long height) {
353}
354
355CFGFUN(floating_maximum_size, const long width, const long height) {
358}
359
360CFGFUN(floating_modifier, const char *modifiers) {
362}
363
364CFGFUN(tiling_drag_swap_modifier, const char *modifiers) {
366}
367
368CFGFUN(default_orientation, const char *orientation) {
369 if (strcmp(orientation, "horizontal") == 0) {
371 } else if (strcmp(orientation, "vertical") == 0) {
373 } else {
375 }
376}
377
378CFGFUN(workspace_layout, const char *layout) {
379 if (strcmp(layout, "default") == 0) {
381 } else if (strcmp(layout, "stacking") == 0 ||
382 strcmp(layout, "stacked") == 0) {
384 } else {
386 }
387}
388
389CFGFUN(default_border, const char *windowtype, const char *border, const long width) {
390 int border_style;
391 int border_width;
392
393 if (strcmp(border, "1pixel") == 0) {
394 border_style = BS_PIXEL;
395 border_width = 1;
396 } else if (strcmp(border, "none") == 0) {
397 border_style = BS_NONE;
398 border_width = 0;
399 } else if (strcmp(border, "pixel") == 0) {
400 border_style = BS_PIXEL;
401 border_width = width;
402 } else {
403 border_style = BS_NORMAL;
404 border_width = width;
405 }
406
407 if ((strcmp(windowtype, "default_border") == 0) ||
408 (strcmp(windowtype, "new_window") == 0)) {
409 DLOG("default tiled border style = %d and border width = %d (%d physical px)\n",
410 border_style, border_width, logical_px(border_width));
411 config.default_border = border_style;
412 config.default_border_width = logical_px(border_width);
413 } else {
414 DLOG("default floating border style = %d and border width = %d (%d physical px)\n",
415 border_style, border_width, logical_px(border_width));
416 config.default_floating_border = border_style;
418 }
419}
420
421CFGFUN(hide_edge_borders, const char *borders) {
422 if (strcmp(borders, "smart_no_gaps") == 0) {
424 } else if (strcmp(borders, "smart") == 0) {
426 } else if (strcmp(borders, "vertical") == 0) {
428 } else if (strcmp(borders, "horizontal") == 0) {
430 } else if (strcmp(borders, "both") == 0) {
432 } else if (strcmp(borders, "none") == 0) {
434 } else if (boolstr(borders)) {
436 } else {
438 }
439}
440
441CFGFUN(focus_follows_mouse, const char *value) {
443}
444
445CFGFUN(mouse_warping, const char *value) {
446 if (strcmp(value, "none") == 0) {
448 } else if (strcmp(value, "output") == 0) {
450 }
451}
452
453CFGFUN(force_xinerama, const char *value) {
455}
456
457CFGFUN(disable_randr15, const char *value) {
459}
460
461CFGFUN(focus_wrapping, const char *value) {
462 if (strcmp(value, "force") == 0) {
464 } else if (strcmp(value, "workspace") == 0) {
466 } else if (boolstr(value)) {
468 } else {
470 }
471}
472
473CFGFUN(force_focus_wrapping, const char *value) {
474 /* Legacy syntax. */
475 if (boolstr(value)) {
477 } else {
478 /* For "force_focus_wrapping off", don't enable or disable
479 * focus wrapping, just ensure it's not forced. */
482 }
483 }
484}
485
489
490CFGFUN(fake_outputs, const char *outputs) {
491 free(config.fake_outputs);
493}
494
495CFGFUN(force_display_urgency_hint, const long duration_ms) {
496 config.workspace_urgency_timer = duration_ms / 1000.0;
497}
498
499CFGFUN(focus_on_window_activation, const char *mode) {
500 if (strcmp(mode, "smart") == 0) {
502 } else if (strcmp(mode, "urgent") == 0) {
504 } else if (strcmp(mode, "focus") == 0) {
506 } else if (strcmp(mode, "none") == 0) {
508 } else {
509 ELOG("Unknown focus_on_window_activation mode \"%s\", ignoring it.\n", mode);
510 return;
511 }
512
513 DLOG("Set new focus_on_window_activation mode = %i.\n", config.focus_on_window_activation);
514}
515
516CFGFUN(title_align, const char *alignment) {
517 if (strcmp(alignment, "left") == 0) {
518 config.title_align = ALIGN_LEFT;
519 } else if (strcmp(alignment, "center") == 0) {
520 config.title_align = ALIGN_CENTER;
521 } else if (strcmp(alignment, "right") == 0) {
522 config.title_align = ALIGN_RIGHT;
523 } else {
524 assert(false);
525 }
526}
527
528CFGFUN(show_marks, const char *value) {
529 config.show_marks = boolstr(value);
530}
531
532static char *current_workspace = NULL;
533
534CFGFUN(workspace, const char *workspace, const char *output) {
535 struct Workspace_Assignment *assignment;
536
537 /* When a new workspace line is encountered, for the first output word,
538 * $workspace from the config.spec is non-NULL. Afterwards, the parser calls
539 * clear_stack() because of the call line. Thus, we have to preserve the
540 * workspace string. */
541 if (workspace) {
543
545 if (strcasecmp(assignment->name, workspace) == 0) {
546 if (assignment->output != NULL) {
547 ELOG("You have a duplicate workspace assignment for workspace \"%s\"\n",
548 workspace);
549 return;
550 }
551 }
552 }
553
554 current_workspace = sstrdup(workspace);
555 } else {
556 if (!current_workspace) {
557 DLOG("Both workspace and current_workspace are NULL, assuming we had an error before\n");
558 return;
559 }
560 workspace = current_workspace;
561 }
562
563 DLOG("Assigning workspace \"%s\" to output \"%s\"\n", workspace, output);
564
565 assignment = scalloc(1, sizeof(struct Workspace_Assignment));
566 assignment->name = sstrdup(workspace);
567 assignment->output = sstrdup(output);
569}
570
571CFGFUN(ipc_socket, const char *path) {
574}
575
576CFGFUN(restart_state, const char *path) {
579}
580
581CFGFUN(popup_during_fullscreen, const char *value) {
582 if (strcmp(value, "ignore") == 0) {
583 config.popup_during_fullscreen = PDF_IGNORE;
584 } else if (strcmp(value, "leave_fullscreen") == 0) {
585 config.popup_during_fullscreen = PDF_LEAVE_FULLSCREEN;
586 } else if (strcmp(value, "all") == 0) {
588 } else {
590 }
591}
592
593CFGFUN(color_single, const char *colorclass, const char *color) {
594 /* used for client.background only currently */
596}
597
598CFGFUN(color, const char *colorclass, const char *border, const char *background, const char *text, const char *indicator, const char *child_border) {
599#define APPLY_COLORS(classname) \
600 do { \
601 if (strcmp(colorclass, "client." #classname) == 0) { \
602 if (strcmp("focused_tab_title", #classname) == 0) { \
603 config.client.got_focused_tab_title = true; \
604 if (indicator || child_border) { \
605 ELOG("indicator and child_border colors have no effect for client.focused_tab_title\n"); \
606 } \
607 } \
608 config.client.classname.border = draw_util_hex_to_color(border); \
609 config.client.classname.background = draw_util_hex_to_color(background); \
610 config.client.classname.text = draw_util_hex_to_color(text); \
611 if (indicator != NULL) { \
612 config.client.classname.indicator = draw_util_hex_to_color(indicator); \
613 } \
614 if (child_border != NULL) { \
615 config.client.classname.child_border = draw_util_hex_to_color(child_border); \
616 } else { \
617 config.client.classname.child_border = config.client.classname.background; \
618 } \
619 return; \
620 } \
621 } while (0)
622
623 APPLY_COLORS(focused_inactive);
624 APPLY_COLORS(focused_tab_title);
626 APPLY_COLORS(unfocused);
627 APPLY_COLORS(urgent);
628 APPLY_COLORS(placeholder);
629
630#undef APPLY_COLORS
631}
632
633CFGFUN(assign_output, const char *output) {
634 if (current_match->error != NULL) {
635 ELOG("match has error: %s\n", current_match->error);
636 return;
637 }
639 ELOG("Match is empty, ignoring this assignment\n");
640 return;
641 }
642
643 if (current_match->window_mode != WM_ANY) {
644 ELOG("Assignments using window mode (floating/tiling) is not supported\n");
645 return;
646 }
647
648 DLOG("New assignment, using above criteria, to output \"%s\".\n", output);
649 Assignment *assignment = scalloc(1, sizeof(Assignment));
650 match_copy(&(assignment->match), current_match);
651 assignment->type = A_TO_OUTPUT;
652 assignment->dest.output = sstrdup(output);
654}
655
656CFGFUN(assign, const char *workspace, bool is_number) {
657 if (current_match->error != NULL) {
658 ELOG("match has error: %s\n", current_match->error);
659 return;
660 }
662 ELOG("Match is empty, ignoring this assignment\n");
663 return;
664 }
665
666 if (current_match->window_mode != WM_ANY) {
667 ELOG("Assignments using window mode (floating/tiling) is not supported\n");
668 return;
669 }
670
671 if (is_number && ws_name_to_number(workspace) == -1) {
672 ELOG("Could not parse initial part of \"%s\" as a number.\n", workspace);
673 return;
674 }
675
676 DLOG("New assignment, using above criteria, to workspace \"%s\".\n", workspace);
677 Assignment *assignment = scalloc(1, sizeof(Assignment));
678 match_copy(&(assignment->match), current_match);
679 assignment->type = is_number ? A_TO_WORKSPACE_NUMBER : A_TO_WORKSPACE;
680 assignment->dest.workspace = sstrdup(workspace);
682}
683
684CFGFUN(no_focus) {
685 if (current_match->error != NULL) {
686 ELOG("match has error: %s\n", current_match->error);
687 return;
688 }
690 ELOG("Match is empty, ignoring this assignment\n");
691 return;
692 }
693
694 DLOG("New assignment, using above criteria, to ignore focus on manage.\n");
695 Assignment *assignment = scalloc(1, sizeof(Assignment));
696 match_copy(&(assignment->match), current_match);
697 assignment->type = A_NO_FOCUS;
699}
700
701CFGFUN(ipc_kill_timeout, const long timeout_ms) {
702 ipc_set_kill_timeout(timeout_ms / 1000.0);
703}
704
705CFGFUN(tiling_drag, const char *value) {
706 if (strcmp(value, "modifier") == 0) {
708 } else if (strcmp(value, "titlebar") == 0) {
710 } else if (strcmp(value, "modifier,titlebar") == 0 ||
711 strcmp(value, "titlebar,modifier") == 0) {
712 /* Switch the above to strtok() or similar if we ever grow more options */
714 } else {
716 }
717}
718
719/*******************************************************************************
720 * Bar configuration (i3bar)
721 ******************************************************************************/
722
724
725CFGFUN(bar_font, const char *font) {
727 current_bar->font = sstrdup(font);
728}
729
730CFGFUN(bar_separator_symbol, const char *separator) {
733}
734
735CFGFUN(bar_mode, const char *mode) {
736 current_bar->mode = (strcmp(mode, "dock") == 0 ? M_DOCK : (strcmp(mode, "hide") == 0 ? M_HIDE : M_INVISIBLE));
737}
738
739CFGFUN(bar_hidden_state, const char *hidden_state) {
740 current_bar->hidden_state = (strcmp(hidden_state, "hide") == 0 ? S_HIDE : S_SHOW);
741}
742
743CFGFUN(bar_id, const char *bar_id) {
744 current_bar->id = sstrdup(bar_id);
745}
746
747CFGFUN(bar_output, const char *output) {
748 int new_outputs = current_bar->num_outputs + 1;
749 current_bar->outputs = srealloc(current_bar->outputs, sizeof(char *) * new_outputs);
751 current_bar->num_outputs = new_outputs;
752}
753
754CFGFUN(bar_verbose, const char *verbose) {
756}
757
758CFGFUN(bar_height, const long height) {
759 current_bar->bar_height = (uint32_t)height;
760}
761
762static void dlog_padding(void) {
763 DLOG("padding now: x=%d, y=%d, w=%d, h=%d\n",
768}
769
770CFGFUN(bar_padding_one, const long all) {
771 current_bar->padding.x = (uint32_t)all;
772 current_bar->padding.y = (uint32_t)all;
773 current_bar->padding.width = (uint32_t)all;
774 current_bar->padding.height = (uint32_t)all;
775 dlog_padding();
776}
777
778CFGFUN(bar_padding_two, const long top_and_bottom, const long right_and_left) {
779 current_bar->padding.x = (uint32_t)right_and_left;
780 current_bar->padding.y = (uint32_t)top_and_bottom;
781 current_bar->padding.width = (uint32_t)right_and_left;
782 current_bar->padding.height = (uint32_t)top_and_bottom;
783 dlog_padding();
784}
785
786CFGFUN(bar_padding_three, const long top, const long right_and_left, const long bottom) {
787 current_bar->padding.x = (uint32_t)right_and_left;
788 current_bar->padding.y = (uint32_t)top;
789 current_bar->padding.width = (uint32_t)right_and_left;
790 current_bar->padding.height = (uint32_t)bottom;
791 dlog_padding();
792}
793
794CFGFUN(bar_padding_four, const long top, const long right, const long bottom, const long left) {
795 current_bar->padding.x = (uint32_t)left;
796 current_bar->padding.y = (uint32_t)top;
797 current_bar->padding.width = (uint32_t)right;
798 current_bar->padding.height = (uint32_t)bottom;
799 dlog_padding();
800}
801
802CFGFUN(bar_modifier, const char *modifiers) {
803 current_bar->modifier = modifiers ? event_state_from_str(modifiers) : XCB_NONE;
804}
805
806static void bar_configure_binding(const char *button, const char *release, const char *command) {
807 if (strncasecmp(button, "button", strlen("button")) != 0) {
808 ELOG("Bindings for a bar can only be mouse bindings, not \"%s\", ignoring.\n", button);
809 return;
810 }
811
812 int input_code = atoi(button + strlen("button"));
813 if (input_code < 1) {
814 ELOG("Button \"%s\" does not seem to be in format 'buttonX'.\n", button);
815 return;
816 }
817 const bool release_bool = release != NULL;
818
819 struct Barbinding *current;
820 TAILQ_FOREACH (current, &(current_bar->bar_bindings), bindings) {
821 if (current->input_code == input_code && current->release == release_bool) {
822 ELOG("command for button %s was already specified, ignoring.\n", button);
823 return;
824 }
825 }
826
827 struct Barbinding *new_binding = scalloc(1, sizeof(struct Barbinding));
828 new_binding->release = release_bool;
829 new_binding->input_code = input_code;
830 new_binding->command = sstrdup(command);
831 TAILQ_INSERT_TAIL(&(current_bar->bar_bindings), new_binding, bindings);
832}
833
834CFGFUN(bar_wheel_up_cmd, const char *command) {
835 ELOG("'wheel_up_cmd' is deprecated. Please use 'bindsym button4 %s' instead.\n", command);
836 bar_configure_binding("button4", NULL, command);
837}
838
839CFGFUN(bar_wheel_down_cmd, const char *command) {
840 ELOG("'wheel_down_cmd' is deprecated. Please use 'bindsym button5 %s' instead.\n", command);
841 bar_configure_binding("button5", NULL, command);
842}
843
844CFGFUN(bar_bindsym, const char *button, const char *release, const char *command) {
846}
847
848CFGFUN(bar_position, const char *position) {
849 current_bar->position = (strcmp(position, "top") == 0 ? P_TOP : P_BOTTOM);
850}
851
852CFGFUN(bar_i3bar_command, const char *i3bar_command) {
854 current_bar->i3bar_command = sstrdup(i3bar_command);
855}
856
857CFGFUN(bar_color, const char *colorclass, const char *border, const char *background, const char *text) {
858#define APPLY_COLORS(classname) \
859 do { \
860 if (strcmp(colorclass, #classname) == 0) { \
861 if (text != NULL) { \
862 /* New syntax: border, background, text */ \
863 current_bar->colors.classname##_border = sstrdup(border); \
864 current_bar->colors.classname##_bg = sstrdup(background); \
865 current_bar->colors.classname##_text = sstrdup(text); \
866 } else { \
867 /* Old syntax: text, background */ \
868 current_bar->colors.classname##_bg = sstrdup(background); \
869 current_bar->colors.classname##_text = sstrdup(border); \
870 } \
871 } \
872 } while (0)
873
874 APPLY_COLORS(focused_workspace);
875 APPLY_COLORS(active_workspace);
876 APPLY_COLORS(inactive_workspace);
877 APPLY_COLORS(urgent_workspace);
878 APPLY_COLORS(binding_mode);
879
880#undef APPLY_COLORS
881}
882
883CFGFUN(bar_socket_path, const char *socket_path) {
885 current_bar->socket_path = sstrdup(socket_path);
886}
887
888CFGFUN(bar_tray_output, const char *output) {
889 struct tray_output_t *tray_output = scalloc(1, sizeof(struct tray_output_t));
890 tray_output->output = sstrdup(output);
891 TAILQ_INSERT_TAIL(&(current_bar->tray_outputs), tray_output, tray_outputs);
892}
893
894CFGFUN(bar_tray_padding, const long padding_px) {
895 current_bar->tray_padding = padding_px;
896}
897
898CFGFUN(bar_color_single, const char *colorclass, const char *color) {
899 if (strcmp(colorclass, "background") == 0) {
901 } else if (strcmp(colorclass, "separator") == 0) {
903 } else if (strcmp(colorclass, "statusline") == 0) {
905 } else if (strcmp(colorclass, "focused_background") == 0) {
907 } else if (strcmp(colorclass, "focused_separator") == 0) {
909 } else {
911 }
912}
913
914CFGFUN(bar_status_command, const char *command) {
917}
918
919CFGFUN(bar_workspace_command, const char *command) {
922}
923
924CFGFUN(bar_binding_mode_indicator, const char *value) {
926}
927
928CFGFUN(bar_workspace_buttons, const char *value) {
930}
931
932CFGFUN(bar_workspace_min_width, const long width) {
934}
935
936CFGFUN(bar_strip_workspace_numbers, const char *value) {
938}
939
940CFGFUN(bar_strip_workspace_name, const char *value) {
942}
943
944CFGFUN(bar_start) {
945 current_bar = scalloc(1, sizeof(struct Barconfig));
946 TAILQ_INIT(&(current_bar->bar_bindings));
947 TAILQ_INIT(&(current_bar->tray_outputs));
949 current_bar->modifier = XCB_KEY_BUT_MASK_MOD_4;
950}
951
952CFGFUN(bar_finish) {
953 DLOG("\t new bar configuration finished, saving.\n");
954 /* Generate a unique ID for this bar if not already configured */
955 if (current_bar->id == NULL) {
957 }
958
960
962 /* Simply reset the pointer, but don't free the resources. */
963 current_bar = NULL;
964}
const char * DEFAULT_BINDING_MODE
The name of the default mode.
Definition bindings.c:25
Binding * configure_binding(const char *bindtype, const char *modifiers, const char *input_code, const char *release, const char *border, const char *whole_window, const char *exclude_titlebar, const char *command, const char *modename, bool pango_markup)
Adds a binding from config parameters given as strings and returns a pointer to the binding structure...
Definition bindings.c:59
static struct stack stack
static Match current_match
struct includedfiles_head included_files
Definition config.c:22
Config config
Definition config.c:19
struct barconfig_head barconfigs
Definition config.c:21
struct modes_head modes
Definition config.c:20
static void apply_gaps(gaps_t *gaps, gaps_mask_t mask, int value)
static bool current_mode_pango_markup
static void bar_configure_binding(const char *button, const char *release, const char *command)
static void create_gaps_assignment(const char *workspace, const gaps_mask_t mask, const int pixels)
static char * current_workspace
static void dlog_padding(void)
static int criteria_next_state
static Barconfig * current_bar
#define APPLY_COLORS(classname)
static char * current_mode
static gaps_mask_t gaps_scope_to_mask(const char *scope)
i3_event_state_mask_t event_state_from_str(const char *str)
A utility function to convert a string containing the group and modifiers to the corresponding bit ma...
parse_file_result_t parse_file(struct parser_ctx *ctx, const char *f, IncludedFile *included_file)
Parses the given file by first replacing the variables, then calling parse_config and launching i3-na...
bool match_is_empty(Match *match)
Check if a match is empty.
Definition match.c:39
void match_init(Match *match)
Initializes the Match data structure.
Definition match.c:26
void match_copy(Match *dest, Match *src)
Copies the data of a match from src to dest.
Definition match.c:64
void match_free(Match *match)
Frees the given match.
Definition match.c:279
void match_parse_property(Match *match, const char *ctype, const char *cvalue)
Interprets a ctype=cvalue pair and adds it to the given match specification.
Definition match.c:295
struct outputs_head outputs
Definition randr.c:22
void tiling_drag(Con *con, xcb_button_press_event_t *event, bool use_threshold)
Initiates a mouse drag operation on a tiled window.
struct Con * focused
Definition tree.c:13
int ws_name_to_number(const char *name)
Parses the workspace name as a number.
Definition util.c:111
void workspace_back_and_forth(void)
Focuses the previously focused workspace.
Definition workspace.c:894
static xcb_cursor_context_t * ctx
Definition xcursor.c:19
static bool verbose
Definition log.c:36
bool force_xinerama
Definition main.c:107
struct autostarts_always_head autostarts_always
Definition main.c:94
struct autostarts_head autostarts
Definition main.c:91
struct assignments_head assignments
Definition main.c:97
struct ws_assignments_head ws_assignments
Definition main.c:101
struct bindings_head * bindings
Definition main.c:87
#define CFGFUN(name,...)
@ PARSE_FILE_CONFIG_ERRORS
@ PARSE_FILE_SUCCESS
@ PARSE_FILE_FAILED
@ HEBM_VERTICAL
Definition data.h:89
@ HEBM_SMART_NO_GAPS
Definition data.h:93
@ HEBM_HORIZONTAL
Definition data.h:90
@ HEBM_BOTH
Definition data.h:91
@ HEBM_SMART
Definition data.h:92
@ HEBM_NONE
Definition data.h:88
@ SMART_GAPS_INVERSE_OUTER
Definition data.h:86
@ SMART_GAPS_ON
Definition data.h:85
@ SMART_GAPS_OFF
Definition data.h:84
@ I3_XKB_GROUP_MASK_2
Definition data.h:125
@ I3_XKB_GROUP_MASK_3
Definition data.h:126
@ I3_XKB_GROUP_MASK_4
Definition data.h:127
@ I3_XKB_GROUP_MASK_1
Definition data.h:124
gaps_mask_t
Definition data.h:154
@ GAPS_HORIZONTAL
Definition data.h:161
@ GAPS_LEFT
Definition data.h:159
@ GAPS_VERTICAL
Definition data.h:160
@ GAPS_RIGHT
Definition data.h:157
@ GAPS_INNER
Definition data.h:155
@ GAPS_OUTER
Definition data.h:162
@ GAPS_BOTTOM
Definition data.h:158
@ GAPS_TOP
Definition data.h:156
uint32_t i3_event_state_mask_t
The lower 16 bits contain a xcb_key_but_mask_t, the higher 16 bits contain an i3_xkb_group_mask_t.
Definition data.h:136
@ POINTER_WARPING_OUTPUT
Definition data.h:142
@ POINTER_WARPING_NONE
Definition data.h:143
@ L_STACKED
Definition data.h:103
@ L_TABBED
Definition data.h:104
@ L_DEFAULT
Definition data.h:102
@ FOCUS_WRAPPING_OFF
Definition data.h:169
@ FOCUS_WRAPPING_ON
Definition data.h:170
@ FOCUS_WRAPPING_FORCE
Definition data.h:171
@ FOCUS_WRAPPING_WORKSPACE
Definition data.h:172
@ VERT
Definition data.h:62
@ HORIZ
Definition data.h:61
@ NO_ORIENTATION
Definition data.h:60
@ BS_NONE
Definition data.h:66
@ BS_PIXEL
Definition data.h:67
@ BS_NORMAL
Definition data.h:68
int logical_px(const int logical)
Convert a logical amount of pixels (e.g.
#define DLOG(fmt,...)
Definition libi3.h:105
#define LOG(fmt,...)
Definition libi3.h:95
char * sstrdup(const char *str)
Safe-wrapper around strdup which exits if malloc returns NULL (meaning that there is no more memory a...
#define ELOG(fmt,...)
Definition libi3.h:100
void * scalloc(size_t num, size_t size)
Safe-wrapper around calloc which exits if malloc returns NULL (meaning that there is no more memory a...
color_t draw_util_hex_to_color(const char *color)
Parses the given color in hex format to an internal color representation.
int sasprintf(char **strp, const char *fmt,...)
Safe-wrapper around asprintf which exits if it returns -1 (meaning that there is no more memory avail...
void * srealloc(void *ptr, size_t size)
Safe-wrapper around realloc which exits if realloc returns NULL (meaning that there is no more memory...
bool boolstr(const char *str)
Reports whether str represents the enabled state (1, yes, true, …).
void set_font(i3Font *font)
Defines the font to be used for the forthcoming calls.
i3Font load_font(const char *pattern, const bool fallback)
Loads a font for usage, also getting its height.
void * smalloc(size_t size)
Safe-wrapper around malloc which exits if malloc returns NULL (meaning that there is no more memory a...
#define SLIST_FOREACH(var, head, field)
Definition queue.h:114
#define TAILQ_FOREACH(var, head, field)
Definition queue.h:347
#define TAILQ_INIT(head)
Definition queue.h:360
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition queue.h:376
#define TAILQ_REMOVE(head, elm, field)
Definition queue.h:402
@ TILING_DRAG_MODIFIER_OR_TITLEBAR
Definition tiling_drag.h:21
@ TILING_DRAG_OFF
Definition tiling_drag.h:18
@ TILING_DRAG_TITLEBAR
Definition tiling_drag.h:20
@ TILING_DRAG_MODIFIER
Definition tiling_drag.h:19
#define FREE(pointer)
Definition util.h:47
void ipc_set_kill_timeout(ev_tstamp new)
Set the maximum duration that we allow for a connection with an unwriteable socket.
List entry struct for an included file.
char * variable_replaced_contents
char * raw_contents
The configuration file can contain multiple sets of bindings.
char * name
bool pango_markup
enum Config::@6 popup_during_fullscreen
What should happen when a new popup is opened during fullscreen mode.
focus_wrapping_t focus_wrapping
When focus wrapping is enabled (the default), attempting to move focus past the edge of the screen (i...
gaps_t gaps
char * restart_state_path
bool workspace_auto_back_and_forth
Automatic workspace back and forth switching.
tiling_drag_t tiling_drag
int32_t floating_minimum_width
uint32_t swap_modifier
The modifier which needs to be pressed in combination with the floating modifier and your mouse butto...
enum Config::@5 title_align
Title alignment options.
int default_border_width
i3Font font
hide_edge_borders_mode_t hide_edge_borders
Remove borders if they are adjacent to the screen edge.
int32_t floating_minimum_height
bool disable_focus_follows_mouse
By default, focus follows mouse.
struct Config::config_client client
warping_t mouse_warping
By default, when switching focus to a window on a different output (e.g.
smart_gaps_t smart_gaps
char * fake_outputs
Overwrites output detection (for testing), see src/fake_outputs.c.
int default_floating_border_width
int default_orientation
Default orientation for new containers.
uint32_t floating_modifier
The modifier which needs to be pressed in combination with your mouse buttons to do things with float...
char * ipc_socket_path
bool show_marks
Specifies whether or not marks should be displayed in the window decoration.
float workspace_urgency_timer
By default, urgency is cleared immediately when switching to another workspace leads to focusing the ...
bool disable_randr15
Don’t use RandR 1.5 for querying outputs.
enum Config::@4 focus_on_window_activation
Behavior when a window sends a NET_ACTIVE_WINDOW message.
int32_t floating_maximum_width
Maximum and minimum dimensions of a floating window.
bool force_xinerama
By default, use the RandR API for multi-monitor setups.
int32_t floating_maximum_height
border_style_t default_border
The default border style for new windows.
layout_t default_layout
border_style_t default_floating_border
The default border style for new floating windows.
int number_barconfigs
Holds the status bar configuration (i3bar).
struct Rect padding
bool hide_workspace_buttons
Hide workspace buttons? Configuration option is 'workspace_buttons no' but we invert the bool to get ...
char * separator_symbol
A custom separator to use instead of a vertical line.
int workspace_min_width
The minimal width for workspace buttons.
struct Barconfig::bar_colors colors
uint32_t modifier
Bar modifier (to show bar when in hide mode).
uint32_t bar_height
Defines the height of the bar in pixels.
char * i3bar_command
Command that should be run to execute i3bar, give a full path if i3bar is not in your $PATH.
int num_outputs
Number of outputs in the outputs array.
enum Barconfig::@8 hidden_state
char * font
Font specification for all text rendered on the bar.
char * id
Automatically generated ID for this bar config.
enum Barconfig::@7 mode
Bar display mode (hide unless modifier is pressed or show in dock mode or always hide in invisible mo...
char * workspace_command
Command that should be run to get the workspace buttons.
bool hide_binding_mode_indicator
Hide mode button? Configuration option is 'binding_mode_indicator no' but we invert the bool for the ...
char * status_command
Command that should be run to get a statusline, for example 'i3status'.
bool strip_workspace_numbers
Strip workspace numbers? Configuration option is 'strip_workspace_numbers yes'.
bool strip_workspace_name
Strip workspace name? Configuration option is 'strip_workspace_name yes'.
char ** outputs
Outputs on which this bar should show up on.
enum Barconfig::@9 position
Bar position (bottom by default).
char * socket_path
Path to the i3 IPC socket.
bool verbose
Enable verbose mode? Useful for debugging purposes.
Defines a mouse command to be executed instead of the default behavior when clicking on the non-statu...
bool release
If true, the command will be executed after the button is released.
int input_code
The button to be used (e.g., 1 for "button1").
char * command
The command which is to be executed for this button.
Definition data.h:146
int inner
Definition data.h:147
int left
Definition data.h:151
int right
Definition data.h:149
int top
Definition data.h:148
int bottom
Definition data.h:150
uint32_t height
Definition data.h:189
uint32_t x
Definition data.h:186
uint32_t y
Definition data.h:187
uint32_t width
Definition data.h:188
Stores which workspace (by name or number) goes to which output and its gaps config.
Definition data.h:235
gaps_mask_t gaps_mask
Definition data.h:239
Holds a command specified by either an:
Definition data.h:369
bool no_startup_id
no_startup_id flag for start_application().
Definition data.h:374
char * command
Command, like in command mode.
Definition data.h:371
enum Match::@14 window_mode
char * error
Definition data.h:531
An Assignment makes specific windows go to a specific workspace/output or run a command for that wind...
Definition data.h:594
Match match
the criteria to check if a window matches
Definition data.h:616
union Assignment::@17 dest
destination workspace/command/output, depending on the type
char * output
Definition data.h:622
char * command
Definition data.h:620
char * workspace
Definition data.h:621
enum Assignment::@16 type
type of this assignment: