i3
config_directives.c
Go to the documentation of this file.
1/*
2 * vim:ts=4:sw=4:expandtab
3 *
4 * i3 - an improved dynamic 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 /* The include mechanism was added in v4, so we can skip the
60 * auto-detection and get rid of the risk of detecting the wrong
61 * version in potentially very short include fragments: */
62 .assume_v4 = true,
63 .stack = &stack,
64 .variables = result->ctx->variables,
65 };
66 switch (parse_file(&ctx, resolved_path, file)) {
68 break;
69
71 ELOG("including config file %s: %s\n", resolved_path, strerror(errno));
72 /* fallthrough */
73
75 result->has_errors = true;
76 TAILQ_REMOVE(&included_files, file, files);
77 FREE(file->path);
78 FREE(file->raw_contents);
80 FREE(file);
81 break;
82
83 default:
84 /* missing case statement */
85 assert(false);
86 break;
87 }
88 }
89 wordfree(&p);
90}
91
92/*******************************************************************************
93 * Criteria functions.
94 ******************************************************************************/
95
97
98/*
99 * Initializes the specified 'Match' data structure and the initial state of
100 * commands.c for matching target windows of a command.
101 *
102 */
103CFGFUN(criteria_init, int _state) {
104 criteria_next_state = _state;
105
106 DLOG("Initializing criteria, current_match = %p, state = %d\n", current_match, _state);
109}
110
111CFGFUN(criteria_pop_state) {
112 result->next_state = criteria_next_state;
113}
114
115/*
116 * Interprets a ctype=cvalue pair and adds it to the current match
117 * specification.
118 *
119 */
120CFGFUN(criteria_add, const char *ctype, const char *cvalue) {
121 match_parse_property(current_match, ctype, cvalue);
122}
123
124/*******************************************************************************
125 * Utility functions
126 ******************************************************************************/
127
128/*
129 * A utility function to convert a string containing the group and modifiers to
130 * the corresponding bit mask.
131 */
133 /* It might be better to use strtok() here, but the simpler strstr() should
134 * do for now. */
135 i3_event_state_mask_t result = 0;
136 if (str == NULL)
137 return result;
138 if (strstr(str, "Mod1") != NULL)
139 result |= XCB_KEY_BUT_MASK_MOD_1;
140 if (strstr(str, "Mod2") != NULL)
141 result |= XCB_KEY_BUT_MASK_MOD_2;
142 if (strstr(str, "Mod3") != NULL)
143 result |= XCB_KEY_BUT_MASK_MOD_3;
144 if (strstr(str, "Mod4") != NULL)
145 result |= XCB_KEY_BUT_MASK_MOD_4;
146 if (strstr(str, "Mod5") != NULL)
147 result |= XCB_KEY_BUT_MASK_MOD_5;
148 if (strstr(str, "Control") != NULL ||
149 strstr(str, "Ctrl") != NULL)
150 result |= XCB_KEY_BUT_MASK_CONTROL;
151 if (strstr(str, "Shift") != NULL)
152 result |= XCB_KEY_BUT_MASK_SHIFT;
153
154 if (strstr(str, "Group1") != NULL)
155 result |= (I3_XKB_GROUP_MASK_1 << 16);
156 if (strstr(str, "Group2") != NULL ||
157 strstr(str, "Mode_switch") != NULL)
158 result |= (I3_XKB_GROUP_MASK_2 << 16);
159 if (strstr(str, "Group3") != NULL)
160 result |= (I3_XKB_GROUP_MASK_3 << 16);
161 if (strstr(str, "Group4") != NULL)
162 result |= (I3_XKB_GROUP_MASK_4 << 16);
163 return result;
164}
165
166CFGFUN(font, const char *font) {
167 config.font = load_font(font, true);
169}
170
171CFGFUN(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) {
172 configure_binding(bindtype, modifiers, key, release, border, whole_window, exclude_titlebar, command, DEFAULT_BINDING_MODE, false);
173}
174
175/*******************************************************************************
176 * Mode handling
177 ******************************************************************************/
178
179static char *current_mode;
181
182CFGFUN(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) {
183 if (current_mode == NULL) {
184 /* When using an invalid mode name, e.g. “default” */
185 return;
186 }
187
188 configure_binding(bindtype, modifiers, key, release, border, whole_window, exclude_titlebar, command, current_mode, current_mode_pango_markup);
189}
190
191CFGFUN(enter_mode, const char *pango_markup, const char *modename) {
192 if (strcmp(modename, DEFAULT_BINDING_MODE) == 0) {
193 ELOG("You cannot use the name %s for your mode\n", DEFAULT_BINDING_MODE);
194 return;
195 }
196
197 struct Mode *mode;
198 SLIST_FOREACH (mode, &modes, modes) {
199 if (strcmp(mode->name, modename) == 0) {
200 ELOG("The binding mode with name \"%s\" is defined at least twice.\n", modename);
201 }
202 }
203
204 DLOG("\t now in mode %s\n", modename);
206 current_mode = sstrdup(modename);
208}
209
210CFGFUN(exec, const char *exectype, const char *no_startup_id, const char *command) {
211 struct Autostart *new = smalloc(sizeof(struct Autostart));
212 new->command = sstrdup(command);
213 new->no_startup_id = (no_startup_id != NULL);
214 if (strcmp(exectype, "exec") == 0) {
216 } else {
218 }
219}
220
221CFGFUN(for_window, const char *command) {
223 ELOG("Match is empty, ignoring this for_window statement\n");
224 return;
225 }
226 DLOG("\t should execute command %s for the criteria mentioned above\n", command);
227 Assignment *assignment = scalloc(1, sizeof(Assignment));
228 assignment->type = A_COMMAND;
229 match_copy(&(assignment->match), current_match);
230 assignment->dest.command = sstrdup(command);
232}
233
234static void apply_gaps(gaps_t *gaps, gaps_mask_t mask, int value) {
235 if (gaps == NULL) {
236 return;
237 }
238 if (mask & GAPS_INNER) {
239 gaps->inner = value;
240 }
241 if (mask & GAPS_TOP) {
242 gaps->top = value;
243 }
244 if (mask & GAPS_RIGHT) {
245 gaps->right = value;
246 }
247 if (mask & GAPS_BOTTOM) {
248 gaps->bottom = value;
249 }
250 if (mask & GAPS_LEFT) {
251 gaps->left = value;
252 }
253}
254
255static void create_gaps_assignment(const char *workspace, const gaps_mask_t mask, const int pixels) {
256 if (mask == 0) {
257 return;
258 }
259
260 DLOG("Setting gaps for workspace %s", workspace);
261
262 bool found = false;
263 struct Workspace_Assignment *assignment;
265 if (strcasecmp(assignment->name, workspace) == 0) {
266 found = true;
267 break;
268 }
269 }
270
271 /* Assignment does not yet exist, let's create it. */
272 if (!found) {
273 assignment = scalloc(1, sizeof(struct Workspace_Assignment));
274 assignment->name = sstrdup(workspace);
275 assignment->output = NULL;
277 }
278
279 assignment->gaps_mask |= mask;
280 apply_gaps(&assignment->gaps, mask, pixels);
281}
282
283static gaps_mask_t gaps_scope_to_mask(const char *scope) {
284 if (!strcmp(scope, "inner")) {
285 return GAPS_INNER;
286 } else if (!strcmp(scope, "outer")) {
287 return GAPS_OUTER;
288 } else if (!strcmp(scope, "vertical")) {
289 return GAPS_VERTICAL;
290 } else if (!strcmp(scope, "horizontal")) {
291 return GAPS_HORIZONTAL;
292 } else if (!strcmp(scope, "top")) {
293 return GAPS_TOP;
294 } else if (!strcmp(scope, "right")) {
295 return GAPS_RIGHT;
296 } else if (!strcmp(scope, "bottom")) {
297 return GAPS_BOTTOM;
298 } else if (!strcmp(scope, "left")) {
299 return GAPS_LEFT;
300 }
301 ELOG("Invalid command, cannot process scope %s", scope);
302 return 0;
303}
304
305CFGFUN(gaps, const char *workspace, const char *scope, const long value) {
306 int pixels = logical_px(value);
307 gaps_mask_t mask = gaps_scope_to_mask(scope);
308
309 if (workspace == NULL) {
310 apply_gaps(&config.gaps, mask, pixels);
311 } else {
312 create_gaps_assignment(workspace, mask, pixels);
313 }
314}
315
316CFGFUN(smart_borders, const char *enable) {
317 if (!strcmp(enable, "no_gaps"))
319 else
321}
322
323CFGFUN(smart_gaps, const char *enable) {
324 if (!strcmp(enable, "inverse_outer"))
326 else
328}
329
330CFGFUN(floating_minimum_size, const long width, const long height) {
333}
334
335CFGFUN(floating_maximum_size, const long width, const long height) {
338}
339
340CFGFUN(floating_modifier, const char *modifiers) {
342}
343
344CFGFUN(default_orientation, const char *orientation) {
345 if (strcmp(orientation, "horizontal") == 0)
347 else if (strcmp(orientation, "vertical") == 0)
349 else
351}
352
353CFGFUN(workspace_layout, const char *layout) {
354 if (strcmp(layout, "default") == 0)
356 else if (strcmp(layout, "stacking") == 0 ||
357 strcmp(layout, "stacked") == 0)
359 else
361}
362
363CFGFUN(default_border, const char *windowtype, const char *border, const long width) {
364 int border_style;
365 int border_width;
366
367 if (strcmp(border, "1pixel") == 0) {
368 border_style = BS_PIXEL;
369 border_width = 1;
370 } else if (strcmp(border, "none") == 0) {
371 border_style = BS_NONE;
372 border_width = 0;
373 } else if (strcmp(border, "pixel") == 0) {
374 border_style = BS_PIXEL;
375 border_width = width;
376 } else {
377 border_style = BS_NORMAL;
378 border_width = width;
379 }
380
381 if ((strcmp(windowtype, "default_border") == 0) ||
382 (strcmp(windowtype, "new_window") == 0)) {
383 DLOG("default tiled border style = %d and border width = %d (%d physical px)\n",
384 border_style, border_width, logical_px(border_width));
385 config.default_border = border_style;
386 config.default_border_width = logical_px(border_width);
387 } else {
388 DLOG("default floating border style = %d and border width = %d (%d physical px)\n",
389 border_style, border_width, logical_px(border_width));
390 config.default_floating_border = border_style;
392 }
393}
394
395CFGFUN(hide_edge_borders, const char *borders) {
396 if (strcmp(borders, "smart_no_gaps") == 0)
398 else if (strcmp(borders, "smart") == 0)
400 else if (strcmp(borders, "vertical") == 0)
402 else if (strcmp(borders, "horizontal") == 0)
404 else if (strcmp(borders, "both") == 0)
406 else if (strcmp(borders, "none") == 0)
408 else if (boolstr(borders))
410 else
412}
413
414CFGFUN(focus_follows_mouse, const char *value) {
416}
417
418CFGFUN(mouse_warping, const char *value) {
419 if (strcmp(value, "none") == 0)
421 else if (strcmp(value, "output") == 0)
423}
424
425CFGFUN(force_xinerama, const char *value) {
427}
428
429CFGFUN(disable_randr15, const char *value) {
431}
432
433CFGFUN(focus_wrapping, const char *value) {
434 if (strcmp(value, "force") == 0) {
436 } else if (strcmp(value, "workspace") == 0) {
438 } else if (boolstr(value)) {
440 } else {
442 }
443}
444
445CFGFUN(force_focus_wrapping, const char *value) {
446 /* Legacy syntax. */
447 if (boolstr(value)) {
449 } else {
450 /* For "force_focus_wrapping off", don't enable or disable
451 * focus wrapping, just ensure it's not forced. */
454 }
455 }
456}
457
461
462CFGFUN(fake_outputs, const char *outputs) {
463 free(config.fake_outputs);
465}
466
467CFGFUN(force_display_urgency_hint, const long duration_ms) {
468 config.workspace_urgency_timer = duration_ms / 1000.0;
469}
470
471CFGFUN(focus_on_window_activation, const char *mode) {
472 if (strcmp(mode, "smart") == 0)
474 else if (strcmp(mode, "urgent") == 0)
476 else if (strcmp(mode, "focus") == 0)
478 else if (strcmp(mode, "none") == 0)
480 else {
481 ELOG("Unknown focus_on_window_activation mode \"%s\", ignoring it.\n", mode);
482 return;
483 }
484
485 DLOG("Set new focus_on_window_activation mode = %i.\n", config.focus_on_window_activation);
486}
487
488CFGFUN(title_align, const char *alignment) {
489 if (strcmp(alignment, "left") == 0) {
490 config.title_align = ALIGN_LEFT;
491 } else if (strcmp(alignment, "center") == 0) {
492 config.title_align = ALIGN_CENTER;
493 } else if (strcmp(alignment, "right") == 0) {
494 config.title_align = ALIGN_RIGHT;
495 } else {
496 assert(false);
497 }
498}
499
500CFGFUN(show_marks, const char *value) {
501 config.show_marks = boolstr(value);
502}
503
504static char *current_workspace = NULL;
505
506CFGFUN(workspace, const char *workspace, const char *output) {
507 struct Workspace_Assignment *assignment;
508
509 /* When a new workspace line is encountered, for the first output word,
510 * $workspace from the config.spec is non-NULL. Afterwards, the parser calls
511 * clear_stack() because of the call line. Thus, we have to preserve the
512 * workspace string. */
513 if (workspace) {
515
517 if (strcasecmp(assignment->name, workspace) == 0) {
518 if (assignment->output != NULL) {
519 ELOG("You have a duplicate workspace assignment for workspace \"%s\"\n",
520 workspace);
521 return;
522 }
523 }
524 }
525
526 current_workspace = sstrdup(workspace);
527 } else {
528 if (!current_workspace) {
529 DLOG("Both workspace and current_workspace are NULL, assuming we had an error before\n");
530 return;
531 }
532 workspace = current_workspace;
533 }
534
535 DLOG("Assigning workspace \"%s\" to output \"%s\"\n", workspace, output);
536
537 assignment = scalloc(1, sizeof(struct Workspace_Assignment));
538 assignment->name = sstrdup(workspace);
539 assignment->output = sstrdup(output);
541}
542
543CFGFUN(ipc_socket, const char *path) {
546}
547
548CFGFUN(restart_state, const char *path) {
551}
552
553CFGFUN(popup_during_fullscreen, const char *value) {
554 if (strcmp(value, "ignore") == 0) {
555 config.popup_during_fullscreen = PDF_IGNORE;
556 } else if (strcmp(value, "leave_fullscreen") == 0) {
557 config.popup_during_fullscreen = PDF_LEAVE_FULLSCREEN;
558 } else {
560 }
561}
562
563CFGFUN(color_single, const char *colorclass, const char *color) {
564 /* used for client.background only currently */
566}
567
568CFGFUN(color, const char *colorclass, const char *border, const char *background, const char *text, const char *indicator, const char *child_border) {
569#define APPLY_COLORS(classname) \
570 do { \
571 if (strcmp(colorclass, "client." #classname) == 0) { \
572 if (strcmp("focused_tab_title", #classname) == 0) { \
573 config.client.got_focused_tab_title = true; \
574 if (indicator || child_border) { \
575 ELOG("indicator and child_border colors have no effect for client.focused_tab_title\n"); \
576 } \
577 } \
578 config.client.classname.border = draw_util_hex_to_color(border); \
579 config.client.classname.background = draw_util_hex_to_color(background); \
580 config.client.classname.text = draw_util_hex_to_color(text); \
581 if (indicator != NULL) { \
582 config.client.classname.indicator = draw_util_hex_to_color(indicator); \
583 } \
584 if (child_border != NULL) { \
585 config.client.classname.child_border = draw_util_hex_to_color(child_border); \
586 } else { \
587 config.client.classname.child_border = config.client.classname.background; \
588 } \
589 return; \
590 } \
591 } while (0)
592
593 APPLY_COLORS(focused_inactive);
594 APPLY_COLORS(focused_tab_title);
596 APPLY_COLORS(unfocused);
597 APPLY_COLORS(urgent);
598 APPLY_COLORS(placeholder);
599
600#undef APPLY_COLORS
601}
602
603CFGFUN(assign_output, const char *output) {
605 ELOG("Match is empty, ignoring this assignment\n");
606 return;
607 }
608
609 if (current_match->window_mode != WM_ANY) {
610 ELOG("Assignments using window mode (floating/tiling) is not supported\n");
611 return;
612 }
613
614 DLOG("New assignment, using above criteria, to output \"%s\".\n", output);
615 Assignment *assignment = scalloc(1, sizeof(Assignment));
616 match_copy(&(assignment->match), current_match);
617 assignment->type = A_TO_OUTPUT;
618 assignment->dest.output = sstrdup(output);
620}
621
622CFGFUN(assign, const char *workspace, bool is_number) {
624 ELOG("Match is empty, ignoring this assignment\n");
625 return;
626 }
627
628 if (current_match->window_mode != WM_ANY) {
629 ELOG("Assignments using window mode (floating/tiling) is not supported\n");
630 return;
631 }
632
633 if (is_number && ws_name_to_number(workspace) == -1) {
634 ELOG("Could not parse initial part of \"%s\" as a number.\n", workspace);
635 return;
636 }
637
638 DLOG("New assignment, using above criteria, to workspace \"%s\".\n", workspace);
639 Assignment *assignment = scalloc(1, sizeof(Assignment));
640 match_copy(&(assignment->match), current_match);
641 assignment->type = is_number ? A_TO_WORKSPACE_NUMBER : A_TO_WORKSPACE;
642 assignment->dest.workspace = sstrdup(workspace);
644}
645
646CFGFUN(no_focus) {
648 ELOG("Match is empty, ignoring this assignment\n");
649 return;
650 }
651
652 DLOG("New assignment, using above criteria, to ignore focus on manage.\n");
653 Assignment *assignment = scalloc(1, sizeof(Assignment));
654 match_copy(&(assignment->match), current_match);
655 assignment->type = A_NO_FOCUS;
657}
658
659CFGFUN(ipc_kill_timeout, const long timeout_ms) {
660 ipc_set_kill_timeout(timeout_ms / 1000.0);
661}
662
663CFGFUN(tiling_drag, const char *value) {
664 if (strcmp(value, "modifier") == 0) {
666 } else if (strcmp(value, "titlebar") == 0) {
668 } else if (strcmp(value, "modifier,titlebar") == 0 ||
669 strcmp(value, "titlebar,modifier") == 0) {
670 /* Switch the above to strtok() or similar if we ever grow more options */
672 } else {
674 }
675}
676
677/*******************************************************************************
678 * Bar configuration (i3bar)
679 ******************************************************************************/
680
682
683CFGFUN(bar_font, const char *font) {
685 current_bar->font = sstrdup(font);
686}
687
688CFGFUN(bar_separator_symbol, const char *separator) {
691}
692
693CFGFUN(bar_mode, const char *mode) {
694 current_bar->mode = (strcmp(mode, "dock") == 0 ? M_DOCK : (strcmp(mode, "hide") == 0 ? M_HIDE : M_INVISIBLE));
695}
696
697CFGFUN(bar_hidden_state, const char *hidden_state) {
698 current_bar->hidden_state = (strcmp(hidden_state, "hide") == 0 ? S_HIDE : S_SHOW);
699}
700
701CFGFUN(bar_id, const char *bar_id) {
702 current_bar->id = sstrdup(bar_id);
703}
704
705CFGFUN(bar_output, const char *output) {
706 int new_outputs = current_bar->num_outputs + 1;
707 current_bar->outputs = srealloc(current_bar->outputs, sizeof(char *) * new_outputs);
709 current_bar->num_outputs = new_outputs;
710}
711
712CFGFUN(bar_verbose, const char *verbose) {
714}
715
716CFGFUN(bar_height, const long height) {
717 current_bar->bar_height = (uint32_t)height;
718}
719
720static void dlog_padding(void) {
721 DLOG("padding now: x=%d, y=%d, w=%d, h=%d\n",
726}
727
728CFGFUN(bar_padding_one, const long all) {
729 current_bar->padding.x = (uint32_t)all;
730 current_bar->padding.y = (uint32_t)all;
731 current_bar->padding.width = (uint32_t)all;
732 current_bar->padding.height = (uint32_t)all;
733 dlog_padding();
734}
735
736CFGFUN(bar_padding_two, const long top_and_bottom, const long right_and_left) {
737 current_bar->padding.x = (uint32_t)right_and_left;
738 current_bar->padding.y = (uint32_t)top_and_bottom;
739 current_bar->padding.width = (uint32_t)right_and_left;
740 current_bar->padding.height = (uint32_t)top_and_bottom;
741 dlog_padding();
742}
743
744CFGFUN(bar_padding_three, const long top, const long right_and_left, const long bottom) {
745 current_bar->padding.x = (uint32_t)right_and_left;
746 current_bar->padding.y = (uint32_t)top;
747 current_bar->padding.width = (uint32_t)right_and_left;
748 current_bar->padding.height = (uint32_t)bottom;
749 dlog_padding();
750}
751
752CFGFUN(bar_padding_four, const long top, const long right, const long bottom, const long left) {
753 current_bar->padding.x = (uint32_t)left;
754 current_bar->padding.y = (uint32_t)top;
755 current_bar->padding.width = (uint32_t)right;
756 current_bar->padding.height = (uint32_t)bottom;
757 dlog_padding();
758}
759
760CFGFUN(bar_modifier, const char *modifiers) {
761 current_bar->modifier = modifiers ? event_state_from_str(modifiers) : XCB_NONE;
762}
763
764static void bar_configure_binding(const char *button, const char *release, const char *command) {
765 if (strncasecmp(button, "button", strlen("button")) != 0) {
766 ELOG("Bindings for a bar can only be mouse bindings, not \"%s\", ignoring.\n", button);
767 return;
768 }
769
770 int input_code = atoi(button + strlen("button"));
771 if (input_code < 1) {
772 ELOG("Button \"%s\" does not seem to be in format 'buttonX'.\n", button);
773 return;
774 }
775 const bool release_bool = release != NULL;
776
777 struct Barbinding *current;
778 TAILQ_FOREACH (current, &(current_bar->bar_bindings), bindings) {
779 if (current->input_code == input_code && current->release == release_bool) {
780 ELOG("command for button %s was already specified, ignoring.\n", button);
781 return;
782 }
783 }
784
785 struct Barbinding *new_binding = scalloc(1, sizeof(struct Barbinding));
786 new_binding->release = release_bool;
787 new_binding->input_code = input_code;
788 new_binding->command = sstrdup(command);
789 TAILQ_INSERT_TAIL(&(current_bar->bar_bindings), new_binding, bindings);
790}
791
792CFGFUN(bar_wheel_up_cmd, const char *command) {
793 ELOG("'wheel_up_cmd' is deprecated. Please us 'bindsym button4 %s' instead.\n", command);
794 bar_configure_binding("button4", NULL, command);
795}
796
797CFGFUN(bar_wheel_down_cmd, const char *command) {
798 ELOG("'wheel_down_cmd' is deprecated. Please us 'bindsym button5 %s' instead.\n", command);
799 bar_configure_binding("button5", NULL, command);
800}
801
802CFGFUN(bar_bindsym, const char *button, const char *release, const char *command) {
804}
805
806CFGFUN(bar_position, const char *position) {
807 current_bar->position = (strcmp(position, "top") == 0 ? P_TOP : P_BOTTOM);
808}
809
810CFGFUN(bar_i3bar_command, const char *i3bar_command) {
812 current_bar->i3bar_command = sstrdup(i3bar_command);
813}
814
815CFGFUN(bar_color, const char *colorclass, const char *border, const char *background, const char *text) {
816#define APPLY_COLORS(classname) \
817 do { \
818 if (strcmp(colorclass, #classname) == 0) { \
819 if (text != NULL) { \
820 /* New syntax: border, background, text */ \
821 current_bar->colors.classname##_border = sstrdup(border); \
822 current_bar->colors.classname##_bg = sstrdup(background); \
823 current_bar->colors.classname##_text = sstrdup(text); \
824 } else { \
825 /* Old syntax: text, background */ \
826 current_bar->colors.classname##_bg = sstrdup(background); \
827 current_bar->colors.classname##_text = sstrdup(border); \
828 } \
829 } \
830 } while (0)
831
832 APPLY_COLORS(focused_workspace);
833 APPLY_COLORS(active_workspace);
834 APPLY_COLORS(inactive_workspace);
835 APPLY_COLORS(urgent_workspace);
836 APPLY_COLORS(binding_mode);
837
838#undef APPLY_COLORS
839}
840
841CFGFUN(bar_socket_path, const char *socket_path) {
843 current_bar->socket_path = sstrdup(socket_path);
844}
845
846CFGFUN(bar_tray_output, const char *output) {
847 struct tray_output_t *tray_output = scalloc(1, sizeof(struct tray_output_t));
848 tray_output->output = sstrdup(output);
849 TAILQ_INSERT_TAIL(&(current_bar->tray_outputs), tray_output, tray_outputs);
850}
851
852CFGFUN(bar_tray_padding, const long padding_px) {
853 current_bar->tray_padding = padding_px;
854}
855
856CFGFUN(bar_color_single, const char *colorclass, const char *color) {
857 if (strcmp(colorclass, "background") == 0)
859 else if (strcmp(colorclass, "separator") == 0)
861 else if (strcmp(colorclass, "statusline") == 0)
863 else if (strcmp(colorclass, "focused_background") == 0)
865 else if (strcmp(colorclass, "focused_separator") == 0)
867 else
869}
870
871CFGFUN(bar_status_command, const char *command) {
874}
875
876CFGFUN(bar_workspace_command, const char *command) {
879}
880
881CFGFUN(bar_binding_mode_indicator, const char *value) {
883}
884
885CFGFUN(bar_workspace_buttons, const char *value) {
887}
888
889CFGFUN(bar_workspace_min_width, const long width) {
891}
892
893CFGFUN(bar_strip_workspace_numbers, const char *value) {
895}
896
897CFGFUN(bar_strip_workspace_name, const char *value) {
899}
900
901CFGFUN(bar_start) {
902 current_bar = scalloc(1, sizeof(struct Barconfig));
903 TAILQ_INIT(&(current_bar->bar_bindings));
904 TAILQ_INIT(&(current_bar->tray_outputs));
906 current_bar->modifier = XCB_KEY_BUT_MASK_MOD_4;
907}
908
909CFGFUN(bar_finish) {
910 DLOG("\t new bar configuration finished, saving.\n");
911 /* Generate a unique ID for this bar if not already configured */
912 if (current_bar->id == NULL)
914
916
918 /* Simply reset the pointer, but don't free the resources. */
919 current_bar = NULL;
920}
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:276
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:292
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:109
void workspace_back_and_forth(void)
Focuses the previously focused workspace.
Definition workspace.c:809
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:93
@ HEBM_SMART_NO_GAPS
Definition data.h:97
@ HEBM_HORIZONTAL
Definition data.h:94
@ HEBM_BOTH
Definition data.h:95
@ HEBM_SMART
Definition data.h:96
@ HEBM_NONE
Definition data.h:92
@ SMART_GAPS_INVERSE_OUTER
Definition data.h:90
@ SMART_GAPS_ON
Definition data.h:89
@ SMART_GAPS_OFF
Definition data.h:88
@ I3_XKB_GROUP_MASK_2
Definition data.h:129
@ I3_XKB_GROUP_MASK_3
Definition data.h:130
@ I3_XKB_GROUP_MASK_4
Definition data.h:131
@ I3_XKB_GROUP_MASK_1
Definition data.h:128
@ SMART_BORDERS_ON
Definition data.h:85
@ SMART_BORDERS_NO_GAPS
Definition data.h:86
@ SMART_BORDERS_OFF
Definition data.h:84
gaps_mask_t
Definition data.h:158
@ GAPS_HORIZONTAL
Definition data.h:165
@ GAPS_LEFT
Definition data.h:163
@ GAPS_VERTICAL
Definition data.h:164
@ GAPS_RIGHT
Definition data.h:161
@ GAPS_INNER
Definition data.h:159
@ GAPS_OUTER
Definition data.h:166
@ GAPS_BOTTOM
Definition data.h:162
@ GAPS_TOP
Definition data.h:160
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:140
@ POINTER_WARPING_OUTPUT
Definition data.h:146
@ POINTER_WARPING_NONE
Definition data.h:147
@ L_STACKED
Definition data.h:107
@ L_TABBED
Definition data.h:108
@ L_DEFAULT
Definition data.h:106
@ FOCUS_WRAPPING_OFF
Definition data.h:173
@ FOCUS_WRAPPING_ON
Definition data.h:174
@ FOCUS_WRAPPING_FORCE
Definition data.h:175
@ FOCUS_WRAPPING_WORKSPACE
Definition data.h:176
@ 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
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.
smart_borders_t smart_borders
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:150
int inner
Definition data.h:151
int left
Definition data.h:155
int right
Definition data.h:153
int top
Definition data.h:152
int bottom
Definition data.h:154
uint32_t height
Definition data.h:193
uint32_t x
Definition data.h:190
uint32_t y
Definition data.h:191
uint32_t width
Definition data.h:192
Stores which workspace (by name or number) goes to which output and its gaps config.
Definition data.h:239
gaps_mask_t gaps_mask
Definition data.h:243
Holds a command specified by either an:
Definition data.h:373
bool no_startup_id
no_startup_id flag for start_application().
Definition data.h:378
char * command
Command, like in command mode.
Definition data.h:375
enum Match::@14 window_mode
An Assignment makes specific windows go to a specific workspace/output or run a command for that wind...
Definition data.h:598
Match match
the criteria to check if a window matches
Definition data.h:620
union Assignment::@17 dest
destination workspace/command/output, depending on the type
char * output
Definition data.h:626
char * command
Definition data.h:624
char * workspace
Definition data.h:625
enum Assignment::@16 type
type of this assignment: