├── .github
    └── ISSUE_TEMPLATE
├── .gitignore
├── .xinitrc
├── LICENSE
├── Makefile
├── README.md
├── _clang-format
├── docs
    └── img
    │   ├── img1.png
    │   ├── img2.png
    │   └── img3.png
├── run.sh
├── src
    ├── config_parser.c
    ├── config_parser.h
    ├── helper.h
    ├── logger.c
    ├── logger.h
    ├── queue.c
    ├── queue.h
    ├── tree.c
    ├── tree.h
    ├── type.h
    ├── zwm.c
    └── zwm.h
├── zwm.1
└── zwm.conf


/.github/ISSUE_TEMPLATE:
--------------------------------------------------------------------------------
 1 | ## Issue Type
 2 | - [ ] Bug Report
 3 | - [ ] Feature Request
 4 | - [ ] Enhancement
 5 | 
 6 | ## Description
 7 | Provide a brief description of the issue or feature request.
 8 | 
 9 | ## Steps to Reproduce (for Bug Reports)
10 | 1. 
11 | 2. 
12 | 3. 
13 | 
14 | ## Expected Behavior
15 | Describe what you expected to happen.
16 | 
17 | ## Actual Behavior
18 | Describe what actually happened. Include any error messages or logs.
19 | 
20 | ## Configuration
21 | - **WN Version**: 
22 | - **Operating System**: 
23 | - **Compiler Version**: 
24 | - **Configuration File**: 
25 | 
26 | ## Environment
27 | - **Compositor** (if applicable): 
28 | - **Desktop Environment** (if applicable): 
29 | - **Other Relevant Software**: 
30 | 
31 | ## Logs and Screenshots
32 | Attach any relevant logs or screenshots that might help in diagnosing the issue.
33 | 
34 | ## Additional Information
35 | Add any other context about the problem here.
36 | 
37 | ## Checklist
38 | - [ ] I have searched for duplicate issues to ensure this is not a duplicate.
39 | ---
40 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | .idea/*
 4 | zwm
 5 | # Object files
 6 | *.o
 7 | *.ko
 8 | *.obj
 9 | *.elf
10 | 
11 | # Linker output
12 | *.ilk
13 | *.map
14 | *.exp
15 | 
16 | # Precompiled Headers
17 | *.gch
18 | *.pch
19 | 
20 | # Libraries
21 | *.lib
22 | *.a
23 | *.la
24 | *.lo
25 | 
26 | # Shared objects (inc. Windows DLLs)
27 | *.dll
28 | *.so
29 | *.so.*
30 | *.dylib
31 | 
32 | # Executables
33 | *.exe
34 | *.out
35 | *.app
36 | *.i*86
37 | *.x86_64
38 | *.hex
39 | 
40 | # Debug files
41 | *.dSYM/
42 | *.su
43 | *.idb
44 | *.pdb
45 | 
46 | # Kernel Module Compile Results
47 | *.mod*
48 | *.cmd
49 | .tmp_versions/
50 | modules.order
51 | Module.symvers
52 | Mkfile.old
53 | dkms.conf


--------------------------------------------------------------------------------
/.xinitrc:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | userresources=$HOME/.Xresources
 3 | usermodmap=$HOME/.Xmodmap
 4 | sysresources=/etc/X11/xinit/.Xresources
 5 | sysmodmap=/etc/X11/xinit/.Xmodmap
 6 | 
 7 | # merge in defaults and keymaps
 8 | if [ -f $sysresources ]; then
 9 | 	xrdb -merge $sysresources
10 | fi
11 | 
12 | if [ -f $sysmodmap ]; then
13 | 	xmodmap $sysmodmap
14 | fi
15 | 
16 | if [ -f "$userresources" ]; then
17 | 	xrdb -merge "$userresources"
18 | fi
19 | 
20 | if [ -f "$usermodmap" ]; then
21 | 	xmodmap "$usermodmap"
22 | fi
23 | 
24 | # start some nice programs
25 | if [ -d /etc/X11/xinit/xinitrc.d ]; then
26 | 	for f in /etc/X11/xinit/xinitrc.d/?*.sh; do
27 | 		[ -x "$f" ] && . "$f"
28 | 	done
29 | 	unset f
30 | fi
31 | 
32 | setxkbmap us &
33 | nitrogen --restore &
34 | xsetroot -cursor_name left_ptr &
35 | 
36 | exec zwm


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 2-Clause License
 2 | 
 3 | Copyright (c) 2024, Yazeed Alharthi
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice, this
 9 |    list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
19 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
22 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CC = gcc
 2 | CFLAGS = -Wextra -Wshadow -Wunreachable-code -Wcast-align -Wuninitialized -finline-functions -finline-small-functions
 3 | 
 4 | LDFLAGS = -lxcb -lxcb-util -lxcb-keysyms -lxcb-ewmh -lxcb-icccm -lxcb-randr -lxcb-xinerama -lxcb-cursor
 5 | SRC_FILES = ./src/zwm.c ./src/logger.c ./src/tree.c ./src/config_parser.c ./src/queue.c
 6 | HEADER_FILES = ./src/logger.h ./src/tree.h ./src/type.h ./src/zwm.h ./src/config_parser.h ./src/helper.h ./src/queue.h
 7 | OBJ_FILES = $(SRC_FILES:.c=.o)
 8 | DEBUG_FLAGS = -g -D_DEBUG__=1
 9 | GDB_FLAGS = -ggdb3
10 | LOCAL_TEST = -D__LTEST__=1
11 | TARGET = zwm
12 | PREFIX = /usr
13 | BINDIR = $(PREFIX)/bin
14 | MANDIR = $(PREFIX)/share/man/man1
15 | MANPAGE = zwm.1
16 | 
17 | $(TARGET): $(OBJ_FILES)
18 | 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
19 | 
20 | %.o: %.c $(HEADER_FILES)
21 | 	$(CC) $(CFLAGS) -c $< -o $@
22 | 
23 | clean:
24 | 	rm -f $(TARGET) $(OBJ_FILES)
25 | 
26 | install: $(TARGET)
27 | 	mkdir -p "$(DESTDIR)$(BINDIR)"
28 | 	cp -pf $(TARGET) "$(DESTDIR)$(BINDIR)"
29 | 	mkdir -p "$(DESTDIR)$(MANDIR)"
30 | 	cp -pf $(MANPAGE) "$(DESTDIR)$(MANDIR)"
31 | 
32 | uninstall:
33 | 	rm -f "$(DESTDIR)$(BINDIR)/$(TARGET)"
34 | 	rm -f "$(DESTDIR)$(MANDIR)/$(MANPAGE)"
35 | 
36 | debug: CFLAGS += $(DEBUG_FLAGS)
37 | debug: clean $(TARGET)
38 | 
39 | for_gdb: CFLAGS += $(GDB_FLAGS)
40 | for_gdb: clean $(TARGET)
41 | 
42 | test: CFLAGS += $(LOCAL_TEST)
43 | test: clean $(TARGET)
44 | 
45 | all: clean $(TARGET)
46 | 
47 | .PHONY: all clean install uninstall debug
48 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ### zwm
  2 | 
  3 | ## Table of Contents
  4 | 
  5 | -   [About ZWM](#about-zwm)
  6 | -   [Motivation](#motivation)
  7 | -   [Goals](#goals)
  8 | -   [Features](#features)
  9 | -   [The underlying data structure](#the-underlying-data-structure)
 10 | -   [Screenshots](#screenshots)
 11 | -   [Installation](#installation)
 12 | -   [Configuration](#configuration)
 13 | -   [Default Keybindings](#default-keybindings)
 14 | -   [ewmh specific settings for polyabr](#ewmh-specific-settings-for-polyabr)
 15 | -   [Contributing](#contributing)
 16 | 
 17 | ## About ZWM
 18 | 
 19 | zwm is a minimalistic and opinionated tiling window manager for X11. It uses XCB instead of Xlib to communicate with the X server. The underlying data structure for managing windows is a customized BSP tree.
 20 | 
 21 | ## Motivation
 22 | 
 23 | The motivation behind zwm stems from a desire to create a window manager that is both lightweight and highly efficient, yet tailored to how I like to work. Sure, there are other great tiling window managers that perform well and offer robust features, but zwm was developed primarily as a learning exercise in creating a window manager from scratch.
 24 | 
 25 | ## Goals
 26 | 
 27 | -   Minimalism
 28 | -   Efficiency
 29 | -   Performance
 30 | 
 31 | ## Features
 32 | 
 33 | -   Compliance with a subset of [ewmh](https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.html) and [icccm](https://www.x.org/releases/X11R7.6/doc/xorg-docs/specs/ICCCM/icccm.html)
 34 | -   Multiple Layouts (default, master, stack, grid).
 35 | -   Multiple virtual desktops.
 36 | -   Multi-monitor support.
 37 | -   Independent workspaces for each monitor by default.
 38 | -   Low memory footprint, runs within ~2MB of memory
 39 | -   Resize, flip, and swap windows or partitions.
 40 | -   Layouts apply to individual desktops.
 41 | -   Customizable settings.
 42 | -   Customizable window rules.
 43 | -   Keyboard-Driven, fully controlled via keyboard shortcuts.
 44 | -   Can be integrated with any status bar.
 45 | -   Config reload on the fly.
 46 | 
 47 | ## The underlying data structure:
 48 | 
 49 | ZWM uses **binary space partitioning tree** ([BSP-tree](https://en.wikipedia.org/wiki/Binary_space_partitioning)) to store and manage windows. This allows for more flexible layouts.
 50 | 
 51 | -   Each desktop has its own pointer to a bsp-tree
 52 | -   The tree is a partition of a monitor's rectangle into smaller rectangular regions.
 53 | -   Each leaf node holds exactly one window.
 54 | -   Each node in a bsp-tree either has zero or two children.
 55 | -   Each internal node is responsible for splitting a rectangle in half.
 56 | 
 57 | #### The following should illustrate how bsp-tree is used to achive window managment:
 58 | 
 59 | ```
 60 |     Window and Partition Structure in a BSP-tree:
 61 | 
 62 |     The layout of windows in BSPWM follows a binary tree structure:
 63 | 
 64 |          I         ROOT (root is an INTERNAL NODE, unless it is a leaf by definition)
 65 |        /   \
 66 |       I     I      INTERNAL NODES (screen sections/partitions)
 67 |      / \   / \
 68 |     E   E E   E    EXTERNAL NODES (windows/leaves)
 69 | 
 70 |     - Internal Nodes (I) represent screen sections where windows can be displayed.
 71 |     - External Nodes (E) represent the actual windows within those sections.
 72 |     - Windows (E nodes) share the width, height, and coordinates (x, y) of their   parent sections (I nodes).
 73 | 
 74 |     Example Structure:
 75 | 
 76 |          I
 77 |        /   \
 78 |       I     I
 79 |      / \   / \
 80 |     E   E E   I
 81 |              / \
 82 |             E   E
 83 | 
 84 |     Partition Behavior:
 85 |     - Internal nodes (I) can contain other partitions or be contained within other partitions.
 86 |     - External nodes (E) are the leaves (actual windows).
 87 | 
 88 |     Example of tree:
 89 |     - 1, 2, 3 are leaves/windows (EXTERNAL_NODE).
 90 |     - a, b are internal nodes (INTERNAL_NODE), or screen sections/partitions.
 91 | 
 92 |             1                               a                          a
 93 |                                            / \                        / \
 94 |                             --->          1   2         --->         1   b
 95 |                                                                         / \
 96 |                                                                        2   3
 97 |     Visualization of Screen Layout:
 98 | 
 99 |     +-----------------------+  +-----------------------+  +-----------------------+
100 |     |                       |  |           |           |  |           |           |
101 |     |                       |  |           |           |  |           |     2     |
102 |     |                       |  |           |           |  |           |           |
103 |     |           1           |  |     1     |     2     |  |     1     |-----------|
104 |     |                       |  |           |           |  |           |           |
105 |     |                       |  |           |           |  |           |     3     |
106 |     |                       |  |           |           |  |           |           |
107 |     +-----------------------+  +-----------------------+  +-----------------------+
108 | 
109 |     Another Example:
110 |     - Numbers are the are leaves/windows (EXTERNAL_NODE).
111 |     - Letters are internal nodes (INTERNAL_NODE), or screen sections/partitions.
112 | 
113 |              a                             a                          a
114 |             / \                           / \                        / \
115 |            1   b            --->         c   b         --->         c   b
116 |               / \                       / \ / \                    / \ / \
117 |              2   3                     1  4 2  3                  1  d 2  3
118 |                                                              	    / \
119 |                                                                    4   5
120 | 
121 |      +-----------------------+  +-----------------------+  +-----------------------+
122 |      |           |           |  |           |           |  |           |           |
123 |      |           |     2     |  |     1     |     2     |  |     1     |     2     |
124 |      |           |           |  |           |           |  |           |           |
125 |      |     1     |-----------|  |-----------|-----------|  |-----------|-----------|
126 |      |           |           |  |           |           |  |     |     |           |
127 |      |           |     3     |  |     4     |     3     |  |  4  |  5  |     3     |
128 |      |           |           |  |           |           |  |     |     |           |
129 |      +-----------------------+  +-----------------------+  +-----------------------+
130 | 
131 | ```
132 | 
133 | ## Screenshots:
134 | 
135 | <p align="left">
136 |   <img src="https://github.com/Yazeed1s/zwm/blob/main/docs/img/img1.png" width="1000">
137 | </p>
138 | <p align="left">
139 |   <img src="https://github.com/Yazeed1s/zwm/blob/main/docs/img/img2.png" width="1000">
140 | </p>
141 | <p align="left">
142 |   <img src="https://github.com/Yazeed1s/zwm/blob/main/docs/img/img3.png" width="1000">
143 | </p>
144 | 
145 | ## Installation
146 | 
147 | #### Arch Linux (AUR)
148 | 
149 | ```bash
150 | yay -S zwm
151 | ```
152 | 
153 | #### Void Linux (XBPS-SRC)
154 | 
155 | Assuming you have [void-packages](https://github.com/void-linux/void-packages)
156 | 
157 | ```bash
158 | git clone https://github.com/elbachir-one/void-templates
159 | cp void-templates/zwm/ void-packages/srcpkgs/  # Copying the zwm/ directory that has the template
160 | cd void-packages/
161 | ./xbps-src pkg zwm
162 | sudo xbps-install -R hostdir/binpkgs zwm
163 | ```
164 | 
165 | #### Build from source
166 | 
167 | ##### Dependencies
168 | 
169 | -   gcc
170 | -   libxcb
171 | -   xcb-util
172 | -   xcb-util-keysyms
173 | -   xcb-util-wm (ewmh,icccm)
174 | -   lxcb-randr
175 | -   lxcb-xinerama
176 | -   lxcb-cursor
177 | 
178 | ```bash
179 | git clone https://github.com/Yazeed1s/zwm.git
180 | cd zwm && sudo make install
181 | ```
182 | 
183 | ## Configuration
184 | 
185 | ##### A config file will be generated when you first start `zwm`. The file can be found in the following location:
186 | 
187 | -   ~/.config/zwm/zwm.conf
188 | 
189 | ###### As of now, the following configs are offered:
190 | 
191 | ### 1- Config variables
192 | 
193 | ```ini
194 | border_width = 2
195 | active_border_color = 0x4a4a48
196 | normal_border_color = 0x30302f
197 | window_gap = 10
198 | virtual_desktops = 7
199 | focus_follow_pointer = true
200 | ```
201 | 
202 | ##### Available Variables:
203 | 
204 | -   **border_width**: Defines the width of the window borders in pixels.
205 | -   **active_border_color**: Specifies the color of the border for the active (focused) window.
206 | -   **normal_border_color**: Specifies the color of the border for inactive (unfocused) windows.
207 | -   **window_gap**: Sets the gap between windows in pixels.
208 | -   **virtual_desktops**: sets the number of virtual desktops.
209 | -   **focus_follow_pointer**: If false, the window is focused on click; if true, the window is focused when the cursor enters it.
210 | 
211 | ### 2- Commands to run on startup
212 | 
213 | ##### Use the `exec` directive to specify programs that should be started when ZWM is launched.
214 | 
215 | -   For a single command:
216 | 
217 | ```ini
218 | exec = "polybar"
219 | ```
220 | 
221 | -   To specify additional arguments as a list:
222 | 
223 | ```ini
224 | exec = ["polybar", "-c", ".config/polybar/config.ini"]
225 | ```
226 | 
227 | ### 3- Custom window rules
228 | 
229 | ##### Custom window rules allow you to define specific behaviors for windows based on their window class.
230 | 
231 | ##### Syntax:
232 | 
233 | ```ini
234 | rule = wm_class("window class name"), state(tiled|floated), desktop(1..N)
235 | ```
236 | 
237 | ##### Explanation:
238 | 
239 | -   **wm_class**: The window class name used to identify the window.
240 |     -   Use the **`xprop`** tool to find the wm_class of a window.
241 | -   **state**: Specifies whether the window should be tiled or floated.
242 | -   **tiled**: The window will be tiled... clearly.
243 | -   **floated**: The window will be floated... clearly.
244 | -   **desktop**: The virtual desktop number where the window should be placed.
245 |     -   Use **-1** if you do not want to set it to a specific desktop.
246 | 
247 | ```ini
248 | ; Example:
249 | rule = wm_class("firefox"), state(tiled), desktop(-1)
250 | ; This rule sets "firefox" window to be tiled and does not change its virtual desktop.
251 | ```
252 | 
253 | ### 4- Key bindings
254 | 
255 | -   The format for defining key bindings is: `bind = modifier + key -> action`
256 | -   If two modifiers are used, combine them with a pipe (|). For example, alt + shift is written as `alt|shift`.
257 | -   Note: Some functions require additional arguments to specify details of the action.
258 | -   These arguments are provided using a colon syntax, where the function and its argument are separated by a colon.
259 | -   Example: `func(switch_desktop:1)` means "switch to desktop 1".
260 | -   Example: `func(resize:grow)` means "grow the size of the window".
261 | -   Example: `func(layout:master)` means "toggle master layout".
262 | 
263 | #### Available modifires:
264 | 
265 | -   **super (meta)**, **alt**, **shift**, **ctrl**
266 | 
267 | #### Available Actions:
268 | 
269 | -   run(...): Executes a specified process.
270 | 
271 |     -   Example: `bind = super + return -> run("alacritty")`
272 |     -   To run a process with arguments, use a list:
273 |         Example: `bind = super + p -> run(["rofi", "-show", "drun"])`
274 | 
275 | -   func(...): Calls a predefined function. The following functions are available:
276 | 
277 |     -   **kill**: Kills the focused window.
278 |     -   **switch_desktop**: Switches to a specified virtual desktop.
279 |     -   **fullscreen**: Toggles fullscreen mode for the focused window.
280 |     -   **swap**: Swaps the focused window with its sibling.
281 |     -   **transfer_node**: Moves the focused window to another virtual desktop.
282 |     -   **layout**: Toggles the specified layout (master, deafult, stack).
283 |     -   **traverse**: (In stack layout only) Moves focus to the window above or below.
284 |     -   **flip**: Changes the window's orientation; if the window is primarily vertical, it becomes horizontal, and vice versa.
285 |     -   **cycle_window**: Moves focus to the window in the specified direction (up, down, left, right).
286 |     -   **cycle_desktop**: Cycles through the virtual desktops (left, right).
287 |     -   **resize**: Adjusts the size of the focused window (grow, shrink).
288 |     -   **reload_config**: Reloads the configuration file without restarting ZWM.
289 |     -   **shift_window**: Shift the floating window's position to the specified direction by 10px (up, down, left, right).
290 |     -   **gap_handler**: Increase or decrease window gaps (GROW, SHRINK).
291 |     -   **change_state**: Set window state (FLAOTING, TILED).
292 |     -   **grow_floating_window**: Grow floating window (horizontally or vertically).
293 |     -   **shrink_floating_window**: Shrink floating window (horizontally or vertically).
294 |     -   **cycle_monitors**: Cycle between monitors (left or right, relative to the linked-list order not the physical positioning).
295 | 
296 | -   Default keys
297 | 
298 | ```ini
299 | bind = super + return -> run("alacritty")
300 | bind = super + space -> run("dmenu_run")
301 | bind = super + p -> run(["rofi","-show", "drun"])
302 | bind = super + w -> func(kill)
303 | bind = super + 1 -> func(switch_desktop:1)
304 | bind = super + 2 -> func(switch_desktop:2)
305 | bind = super + 3 -> func(switch_desktop:3)
306 | bind = super + 4 -> func(switch_desktop:4)
307 | bind = super + 5 -> func(switch_desktop:5)
308 | bind = super + 6 -> func(switch_desktop:6)
309 | bind = super + 7 -> func(switch_desktop:7)
310 | bind = super + l -> func(resize:grow)
311 | bind = super + h -> func(resize:shrink)
312 | bind = super + i -> func(gap_handler:grow)
313 | bind = super + d -> func(gap_handler:shrink)
314 | bind = super + f -> func(fullscreen)
315 | bind = super + s -> func(swap)
316 | bind = super + up -> func(cycle_window:up)
317 | bind = super + right -> func(cycle_window:right)
318 | bind = super + left -> func(cycle_window:left)
319 | bind = super + down -> func(cycle_window:down)
320 | bind = shift + up -> func(shift_window:up)
321 | bind = shift + right -> func(shift_window:right)
322 | bind = shift + left -> func(shift_window:left)
323 | bind = shift + down -> func(shift_window:down)
324 | bind = shift + f -> func(change_state:float)
325 | bind = shift + t -> func(change_state:tile)
326 | bind = super|shift + t -> func(shrink_floating_window:horizontal)
327 | bind = super|shift + g -> func(shrink_floating_window:vertical)
328 | bind = super|shift + y -> func(grow_floating_window:horizontal)
329 | bind = super|shift + h -> func(grow_floating_window:vertical)
330 | bind = super|shift + left -> func(cycle_desktop:left)
331 | bind = super|shift + right -> func(cycle_desktop:right)
332 | bind = super|ctrl + right -> func(cycle_monitors:next)
333 | bind = super|ctrl + left -> func(cycle_monitors:prev)
334 | bind = super|shift + 1 -> func(transfer_node:1)
335 | bind = super|shift + 2 -> func(transfer_node:2)
336 | bind = super|shift + 3 -> func(transfer_node:3)
337 | bind = super|shift + 4 -> func(transfer_node:4)
338 | bind = super|shift + 5 -> func(transfer_node:5)
339 | bind = super|shift + 6 -> func(transfer_node:6)
340 | bind = super|shift + 7 -> func(transfer_node:7)
341 | bind = super|shift + m -> func(layout:master)
342 | bind = super|shift + s -> func(layout:stack)
343 | bind = super|shift + d -> func(layout:default)
344 | bind = super|shift + k -> func(traverse:up)
345 | bind = super|shift + j -> func(traverse:down)
346 | bind = super|shift + f -> func(flip)
347 | bind = super|shift + r -> func(reload_config)
348 | ```
349 | 
350 | More options will be added in the future as development progresses.
351 | 
352 | ## Default Keybindings
353 | 
354 | | Key                      | Description                          |
355 | | ------------------------ | ------------------------------------ |
356 | | `super + w`              | kill/close window                    |
357 | | `super + return`         | launch a terminal (alacritty)        |
358 | | `super + space`          | launch dmenu                         |
359 | | `super + p `             | launch rofi                          |
360 | | `super + [1..N]`         | switch to desktop                    |
361 | | `super + l`              | resize window (grow/expand)          |
362 | | `super + h`              | resize window (shrink)               |
363 | | `super + f`              | toggle fullscreen                    |
364 | | `super + shift + [1..N]` | transfer window to a diff desktop    |
365 | | `super + shift + m`      | toggle master layout                 |
366 | | `super + shift + s`      | toggle stack layout                  |
367 | | `super + shift + d`      | toggle default layout                |
368 | | `super + shift + j/k`    | traverse the stack                   |
369 | | `super + shift + f`      | flip the window/partion              |
370 | | `super + shift + r`      | hot-reload                           |
371 | | `super + shift + y`      | grow floating windows horizontally   |
372 | | `super + shift + h`      | grow floating windows vertically     |
373 | | `super + shift + t`      | shrink floating windows horizontally |
374 | | `super + shift + g`      | shrink floating windows vertically   |
375 | | `super + ctrl + →`       | focus/change monitor right           |
376 | | `super + ctrl + ←`       | focus/change monitor left            |
377 | | `super + s`              | swap window's orientation            |
378 | | `super + ←`              | focus window on the left             |
379 | | `super + ↑`              | focus window above                   |
380 | | `super + →`              | focus window on the right            |
381 | | `super + ↓`              | focus window below                   |
382 | | `super + shift + →`      | cycle desktop right                  |
383 | | `super + shift + ←`      | cycle desktop left                   |
384 | | `shift + ←`              | shift window to the left by 10px     |
385 | | `shift + ↑`              | shift window up by 10px              |
386 | | `shift + →`              | shift window to the right by 10px    |
387 | | `shift + ↓`              | shift window down by 10px            |
388 | | `super + i`              | increase window gaps by 5px          |
389 | | `super + d`              | decrease window gaps by 5px          |
390 | | `super + t`              | tile window                          |
391 | | `super + f`              | float window                         |
392 | 
393 | ## ewmh specific settings for polyabr
394 | 
395 | ### To display the window name (CLASS_NAME):
396 | 
397 | ```ini
398 | [module/xwindow]
399 | type 			= internal/xwindow
400 | format 			= <label>
401 | ; Available tokens:
402 | ;   %title%
403 | ;   %instance% (first part of the WM_CLASS atom, new in version 3.7.0)
404 | ;   %class%    (second part of the WM_CLASS atom, new in version 3.7.0)
405 | ; Default: %title%
406 | label 		= %title%
407 | label-maxlen 	= 50
408 | label-empty 	= "[null]"
409 | ```
410 | 
411 | ### To display workspaces:
412 | 
413 | ```ini
414 | [module/ewmh]
415 | type = internal/xworkspaces
416 | label-active 			= %index%
417 | label-active-background 	= ${colors.bg}
418 | label-active-underline		= ${colors.blue}
419 | label-active-padding		= 1
420 | label-occupied 			= %index%
421 | label-occupied-padding 		= 1
422 | label-urgent 			= %index%!
423 | label-urgent-background 	= ${colors.red}
424 | label-urgent-padding 		= 1
425 | label-empty 			= %index%
426 | label-empty-foreground 		= ${colors.gray}
427 | label-empty-padding 		= 1
428 | label-separator 		= " "
429 | ```
430 | 
431 | For further custmization please refer to polybar's wiki.
432 | 
433 | ## Contributing
434 | 
435 | If you would like to add a feature or to fix a bug please feel free to submit a PR.
436 | 


--------------------------------------------------------------------------------
/_clang-format:
--------------------------------------------------------------------------------
 1 | TabWidth: 4
 2 | IndentWidth: 4
 3 | UseTab: Always
 4 | ColumnLimit: 80
 5 | AccessModifierOffset: 1
 6 | AlignAfterOpenBracket: Align
 7 | AlignArrayOfStructures: Left
 8 | AlignConsecutiveAssignments:
 9 |  Enabled:         true
10 |  AcrossEmptyLines: true
11 |  AcrossComments:  true
12 |  AlignCompound:   false
13 |  PadOperators:    true
14 | AlignConsecutiveBitFields:
15 |  Enabled:         true
16 |  AcrossEmptyLines: true
17 |  AcrossComments:  true
18 |  AlignCompound:   true
19 |  PadOperators:    true
20 | AlignConsecutiveDeclarations:
21 |  Enabled:         true
22 |  AcrossEmptyLines: true
23 |  AcrossComments:  true
24 |  AlignCompound:   true
25 |  PadOperators:    true
26 | AlignConsecutiveMacros:
27 |  Enabled:         true
28 |  AcrossEmptyLines: true
29 |  AcrossComments:  true
30 |  AlignCompound:   true
31 |  PadOperators:    true
32 | AlignTrailingComments: true
33 | AllowAllArgumentsOnNextLine: true
34 | AllowAllConstructorInitializersOnNextLine: true
35 | AllowAllParametersOfDeclarationOnNextLine: true
36 | AllowShortEnumsOnASingleLine: false
37 | AllowShortBlocksOnASingleLine: Never
38 | AllowShortCaseLabelsOnASingleLine: true
39 | AllowShortFunctionsOnASingleLine: None
40 | AllowShortLambdasOnASingleLine: All
41 | AllowShortIfStatementsOnASingleLine: false
42 | AllowShortLoopsOnASingleLine: true
43 | AlwaysBreakAfterDefinitionReturnType: None
44 | AlwaysBreakAfterReturnType: All
45 | AlwaysBreakBeforeMultilineStrings: false
46 | AlwaysBreakTemplateDeclarations: Yes
47 | BinPackArguments: false
48 | BinPackParameters: false
49 | BreakBeforeBinaryOperators: None
50 | BreakBeforeConceptDeclarations: true
51 | BreakBeforeBraces: Custom
52 | BreakBeforeInheritanceComma: false
53 | BreakInheritanceList: BeforeColon
54 | BreakBeforeTernaryOperators: true
55 | BreakConstructorInitializersBeforeComma: false
56 | BreakConstructorInitializers: BeforeColon
57 | BreakAfterJavaFieldAnnotations: false
58 | BreakStringLiterals: true
59 | ConstructorInitializerAllOnOneLineOrOnePerLine: false
60 | ConstructorInitializerIndentWidth: 4
61 | ContinuationIndentWidth: 4
62 | Cpp11BracedListStyle: true
63 | DeriveLineEnding: true
64 | DerivePointerAlignment: false
65 | DisableFormat:   false
66 | EmptyLineAfterAccessModifier: Never
67 | EmptyLineBeforeAccessModifier: LogicalBlock
68 | ExperimentalAutoDetectBinPacking: false
69 | IndentAccessModifiers: false
70 | IndentCaseLabels: false
71 | IndentCaseBlocks: false
72 | IndentGotoLabels: true
73 | IndentPPDirectives: None
74 | IndentExternBlock: AfterExternBlock
75 | IndentWrappedFunctionNames: false
76 | InsertTrailingCommas: None
77 | JavaScriptQuotes: Leave
78 | JavaScriptWrapImports: true
79 | KeepEmptyLinesAtTheStartOfBlocks: true
80 | LambdaBodyIndentation: Signature
81 | MacroBlockBegin: ''
82 | MacroBlockEnd:   ''
83 | MaxEmptyLinesToKeep: 1
84 | NamespaceIndentation: None
85 | PointerAlignment: Right
86 | ReferenceAlignment: Pointer
87 | ReflowComments:  true
88 | ShortNamespaceLines: 1
89 | SortIncludes:    CaseSensitive
90 | BraceWrapping:
91 |     AfterClass: false
92 |     AfterCaseLabel: false
93 |     # AfterControlStatement: MultiLine
94 |     AfterEnum: false
95 |     AfterFunction: true


--------------------------------------------------------------------------------
/docs/img/img1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yazeed1s/zwm/dd097e86bcb1fe0106794bfa5a38aae83a67c1d0/docs/img/img1.png


--------------------------------------------------------------------------------
/docs/img/img2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yazeed1s/zwm/dd097e86bcb1fe0106794bfa5a38aae83a67c1d0/docs/img/img2.png


--------------------------------------------------------------------------------
/docs/img/img3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yazeed1s/zwm/dd097e86bcb1fe0106794bfa5a38aae83a67c1d0/docs/img/img3.png


--------------------------------------------------------------------------------
/run.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | # this is used for local quick testing
4 | sudo make for_gdb install
5 | startx ./.xinitrc -- /usr/bin/Xephyr -screen 1800x1350 -reset -core
6 | 


--------------------------------------------------------------------------------
/src/config_parser.c:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * BSD 2-Clause License
   3 |  * Copyright (c) 2024, Yazeed Alharthi
   4 |  *
   5 |  * Redistribution and use in source and binary forms, with or without
   6 |  * modification, are permitted provided that the following conditions
   7 |  * are met:
   8 |  *
   9 |  *	  1. Redistributions of source code must retain the above copyright
  10 |  *	  notice, this list of conditions and the following disclaimer.
  11 |  *
  12 |  *	  2. Redistributions in binary form must reproduce the above copyright
  13 |  *	  notice, this list of conditions and the following disclaimer in the
  14 |  *	  documentation and/or other materials provided with the distribution.
  15 |  *
  16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 |  */
  28 | #include "config_parser.h"
  29 | #include "helper.h"
  30 | #include "type.h"
  31 | #include "zwm.h"
  32 | #include <ctype.h>
  33 | #include <stdbool.h>
  34 | #include <stdint.h>
  35 | #include <stdio.h>
  36 | #include <stdlib.h>
  37 | #include <string.h>
  38 | #include <sys/stat.h>
  39 | #include <sys/types.h>
  40 | #include <unistd.h>
  41 | #include <xcb/xproto.h>
  42 | 
  43 | #define MAX_LINE_LENGTH (2 << 9)
  44 | #define MAX_KEYBINDINGS 45
  45 | 
  46 | #ifdef __LTEST__
  47 | #define CONF_PATH "./zwm.conf"
  48 | #else
  49 | #define CONF_PATH ".config/zwm/zwm.conf"
  50 | #endif
  51 | #define ALT	  XCB_MOD_MASK_1
  52 | #define SUPER XCB_MOD_MASK_4
  53 | #define SHIFT XCB_MOD_MASK_SHIFT
  54 | #define CTRL  XCB_MOD_MASK_CONTROL
  55 | 
  56 | typedef enum {
  57 | 	WHITE_SPACE,
  58 | 	CURLY_BRACKET,
  59 | 	PARENTHESIS,
  60 | 	SQUARE_BRACKET,
  61 | 	QUOTATION
  62 | } trim_token_t;
  63 | 
  64 | rule_t	   *rule_head = NULL;
  65 | conf_key_t *key_head  = NULL;
  66 | 
  67 | static void
  68 | free_tokens(char **, int);
  69 | 
  70 | /* clang-format off */
  71 | static const conf_mapper_t _cmapper_[] = {
  72 |     DEFINE_MAPPING("run",            		 exec_process),
  73 |     DEFINE_MAPPING("kill",           		 close_or_kill_wrapper),
  74 |     DEFINE_MAPPING("switch_desktop", 		 switch_desktop_wrapper),
  75 |     DEFINE_MAPPING("resize",         		 dynamic_resize_wrapper),
  76 |     DEFINE_MAPPING("fullscreen",     		 set_fullscreen_wrapper),
  77 |     DEFINE_MAPPING("swap",           		 swap_node_wrapper),
  78 |     DEFINE_MAPPING("transfer_node",  		 transfer_node_wrapper),
  79 |     DEFINE_MAPPING("layout",         		 layout_handler),
  80 |     DEFINE_MAPPING("traverse",       		 traverse_stack_wrapper),
  81 |     DEFINE_MAPPING("flip",           		 flip_node_wrapper),
  82 |     DEFINE_MAPPING("cycle_window",   		 cycle_win_wrapper),
  83 |     DEFINE_MAPPING("reload_config",  		 reload_config_wrapper),
  84 |     DEFINE_MAPPING("cycle_desktop",  		 cycle_desktop_wrapper),
  85 |     DEFINE_MAPPING("cycle_monitors",  		 cycle_monitors),
  86 |     DEFINE_MAPPING("shift_window",   		 shift_floating_window),
  87 |     DEFINE_MAPPING("grow_floating_window",   grow_floating_window),
  88 |     DEFINE_MAPPING("shrink_floating_window", shrink_floating_window),
  89 |     DEFINE_MAPPING("gap_handler",    		 gap_handler),
  90 |     DEFINE_MAPPING("change_state",  		 change_state),
  91 | };
  92 | 
  93 | static key_mapper_t _kmapper_[] = {
  94 |     DEFINE_MAPPING("0",        0x0030), DEFINE_MAPPING("1",        0x0031),
  95 |     DEFINE_MAPPING("2",        0x0032), DEFINE_MAPPING("3",        0x0033),
  96 |     DEFINE_MAPPING("4",        0x0034), DEFINE_MAPPING("5",        0x0035),
  97 |     DEFINE_MAPPING("6",        0x0036), DEFINE_MAPPING("7",        0x0037),
  98 |     DEFINE_MAPPING("8",        0x0038), DEFINE_MAPPING("9",        0x0039),
  99 |     DEFINE_MAPPING("a",        0x0061), DEFINE_MAPPING("b",        0x0062),
 100 |     DEFINE_MAPPING("c",        0x0063), DEFINE_MAPPING("d",        0x0064),
 101 |     DEFINE_MAPPING("e",        0x0065), DEFINE_MAPPING("f",        0x0066),
 102 |     DEFINE_MAPPING("g",        0x0067), DEFINE_MAPPING("h",        0x0068),
 103 |     DEFINE_MAPPING("i",        0x0069), DEFINE_MAPPING("j",        0x006a),
 104 |     DEFINE_MAPPING("k",        0x006b), DEFINE_MAPPING("l",        0x006c),
 105 |     DEFINE_MAPPING("m",        0x006d), DEFINE_MAPPING("n",        0x006e),
 106 |     DEFINE_MAPPING("o",        0x006f), DEFINE_MAPPING("p",        0x0070),
 107 |     DEFINE_MAPPING("q",        0x0071), DEFINE_MAPPING("r",        0x0072),
 108 |     DEFINE_MAPPING("s",        0x0073), DEFINE_MAPPING("t",        0x0074),
 109 |     DEFINE_MAPPING("u",        0x0075), DEFINE_MAPPING("v",        0x0076),
 110 |     DEFINE_MAPPING("w",        0x0077), DEFINE_MAPPING("x",        0x0078),
 111 |     DEFINE_MAPPING("y",        0x0079), DEFINE_MAPPING("z",        0x007a),
 112 |     DEFINE_MAPPING("space",    0x0020), DEFINE_MAPPING("return",   0xff0d),
 113 |     DEFINE_MAPPING("left",     0xff51), DEFINE_MAPPING("up",       0xff52),
 114 |     DEFINE_MAPPING("right",    0xff53), DEFINE_MAPPING("down",     0xff54),
 115 |     DEFINE_MAPPING("super",     SUPER), DEFINE_MAPPING("alt",        ALT ),
 116 |     DEFINE_MAPPING("ctrl",      CTRL ), DEFINE_MAPPING("shift",     SHIFT),
 117 |     DEFINE_MAPPING("sup+sh", SUPER | SHIFT),
 118 | };
 119 | /* clang-format on */
 120 | 
 121 | static int (*str_to_func(char *ch))(arg_t *)
 122 | {
 123 | 	int n = sizeof(_cmapper_) / sizeof(_cmapper_[0]);
 124 | 	for (int i = 0; i < n; i++) {
 125 | 		if (strcmp(_cmapper_[i].func_name, ch) == 0) {
 126 | 			return _cmapper_[i].execute;
 127 | 		}
 128 | 	}
 129 | 	return NULL;
 130 | }
 131 | 
 132 | char *
 133 | func_to_str(int (*ptr)(arg_t *))
 134 | {
 135 | 	int n = sizeof(_cmapper_) / sizeof(_cmapper_[0]);
 136 | 	for (int i = 0; i < n; i++) {
 137 | 		if (_cmapper_[i].execute == ptr) {
 138 | 			return _cmapper_[i].func_name;
 139 | 		}
 140 | 	}
 141 | 	return NULL;
 142 | }
 143 | 
 144 | static uint32_t
 145 | str_to_key(char *ch)
 146 | {
 147 | 	int n = sizeof(_kmapper_) / sizeof(_kmapper_[0]);
 148 | 	for (int i = 0; i < n; i++) {
 149 | 		if (strcmp(_kmapper_[i].key, ch) == 0) {
 150 | 			return _kmapper_[i].keysym;
 151 | 		}
 152 | 	}
 153 | 
 154 | 	return -1;
 155 | }
 156 | 
 157 | static char *
 158 | key_to_str(uint32_t val)
 159 | {
 160 | 	int n = sizeof(_kmapper_) / sizeof(_kmapper_[0]);
 161 | 	for (int i = 0; i < n; i++) {
 162 | 		if (_kmapper_[i].keysym == val) {
 163 | 			return _kmapper_[i].key;
 164 | 		}
 165 | 	}
 166 | 
 167 | 	return NULL;
 168 | }
 169 | 
 170 | static int
 171 | file_exists(const char *filename)
 172 | {
 173 | 	FILE *file = fopen(filename, "r");
 174 | 	if (file) {
 175 | 		fclose(file);
 176 | 		return -1;
 177 | 	}
 178 | 	return 0;
 179 | }
 180 | 
 181 | static void
 182 | print_key_array(void)
 183 | {
 184 | 	conf_key_t *current = key_head;
 185 | 	int			c		= 0;
 186 | 	while (current) {
 187 | 		if (current->arg) {
 188 | 			if (current->arg->cmd) {
 189 | 				for (int j = 0; j < current->arg->argc; ++j) {
 190 | 					_LOG_(DEBUG, "cmd = %s", current->arg->cmd[j]);
 191 | 				}
 192 | 			}
 193 | 			_LOG_(DEBUG,
 194 | 				  "key %d = { \n mod = %s \n keysym = %s, func = %s, "
 195 | 				  "\nargs = {.idx = %d, .d = %d, .r = %d, .t = %d}",
 196 | 				  c,
 197 | 				  key_to_str(current->mod),
 198 | 				  key_to_str(current->keysym),
 199 | 				  func_to_str(current->execute),
 200 | 				  current->arg->idx,
 201 | 				  current->arg->d,
 202 | 				  current->arg->r,
 203 | 				  current->arg->t,
 204 | 				  current->arg->t);
 205 | 		}
 206 | 		c++;
 207 | 		current = current->next;
 208 | 	}
 209 | }
 210 | 
 211 | static int
 212 | write_default_config(const char *filename, config_t *c)
 213 | {
 214 | 	/* clang-format off */
 215 | 	const char *content =
 216 |     "; ----------- ZWM Configuration File -------------\n"
 217 |     ";\n"
 218 |     "; This configuration file is used to customize the Zee Window Manager (ZWM) settings.\n"
 219 |     "; It allows you to define window appearance, behavior, and key bindings for various actions.\n"
 220 |     "\n"
 221 |     "; Command to run on startup\n"
 222 |     "; Use the exec directive to specify programs that should be started when ZWM is launched.\n"
 223 |     "; For single command: use -> exec = \"command\"\n"
 224 |     "; You can also specify additional arguments as a list.\n"
 225 |     "exec = [\"polybar\", \"-c\", \".config/polybar/config.ini\"]\n"
 226 |     "\n"
 227 |     "; Available Variables:\n"
 228 |     "; These variables control the appearance and behavior of the window manager.\n"
 229 |     ";\n"
 230 |     "; - border_width: defines the width of the window borders in pixels.\n"
 231 |     "border_width = 2\n"
 232 |     "; - active_border_color: specifies the color of the border for the active (focused) window.\n"
 233 |     "active_border_color = 0x4a4a48\n"
 234 |     "; - normal_border_color: specifies the color of the border for inactive (unfocused) windows.\n"
 235 |     "normal_border_color = 0x30302f\n"
 236 |     "; - window_gap: sets the gap between windows in pixels.\n"
 237 |     "window_gap = 10\n"
 238 |     "; - virtual_desktops: sets the number of virtual desktops available.\n"
 239 |     "virtual_desktops = 7\n"
 240 |     "; - focus_follow_pointer: If false, the window is focused on click.\n"
 241 |     ";                        If true, the window is focused when the cursor enters it.\n"
 242 |     "focus_follow_pointer = true\n"
 243 |     "\n"
 244 | 	"; Custom window rules\n"
 245 | 	"; Custom window rules allow you to define specific behaviors for windows based on their window class.\n"
 246 | 	";\n"
 247 | 	"; Syntax:\n"
 248 | 	"; rule = wm_class(\"window class name\"), state(tiled|floated), desktop(1..N)\n"
 249 | 	";\n"
 250 | 	"; Explanation:\n"
 251 | 	";  - wm_class: The window class name used to identify the window. Use the 'xprop' tool to find the wm_class of a window.\n"
 252 | 	"; - state: Specifies whether the window should be tiled or floated.\n"
 253 | 	";   - tiled: The window will be tiled, clearly.\n"
 254 | 	";   - floated: The window will be floated, clearly.\n"
 255 | 	"; - desktop: The virtual desktop number where the window should be placed. Use -1 if you do not want to set it to a specific desktop.\n"
 256 | 	";\n"
 257 | 	"; Example:\n"
 258 | 	"; rule = wm_class(\"firefox\"), state(tiled), desktop(-1)\n"
 259 | 	"; This rule sets \"firefox\" window to be tiled and does not change its virtual desktop.\n"
 260 | 	"\n"
 261 | 	"rule = wm_class(\"emacs\"), state(tiled), desktop(-1)\n"
 262 | 	"\n"
 263 |     "; Key Bindings:\n"
 264 |     "; Define keyboard shortcuts to perform various actions.\n"
 265 |     "; The syntax for defining key bindings is:\n"
 266 |     "; bind = modifier + key -> action/function\n"
 267 |     "; If two modifiers are used, combine them with a pipe (|). For example, alt + shift is written as alt|shift.\n"
 268 |     "; Colon Syntax:\n"
 269 |     "; Some functions require additional arguments to specify details of the action.\n"
 270 |     "; These arguments are provided using a colon syntax, where the function and its argument\n"
 271 |     "; are separated by a colon.\n"
 272 |     "; Example: func(switch_desktop:1) means \"switch to desktop 1\".\n"
 273 |     "; Example: func(resize:grow) means \"grow the size of the window\".\n"
 274 |     "; Example: func(layout:master) means \"toggle master layout\".\n"
 275 |     "\n"
 276 |     "; Available Modifiers:\n"
 277 |     "; - super: The \"Windows\" key or \"Command\" key on a Mac.\n"
 278 |     "; - alt: The \"Alt\" key.\n"
 279 |     "; - shift: The \"Shift\" key.\n"
 280 |     "; - ctr: The \"Control\" key.\n"
 281 |     ";\n"
 282 |     "; Available Actions:\n"
 283 |     "; These actions specify what happens when a key binding is triggered.\n"
 284 |     "; - run(...): Executes a specified process.\n"
 285 |     ";   - Example: bind = super + return -> run(\"alacritty\")\n"
 286 |     ";   - To run a process with arguments, use a list:\n"
 287 |     ";     Example: bind = super + p -> run([\"rofi\", \"-show\", \"drun\"])\n"
 288 |     ";\n"
 289 |     "; - func(...): Calls a predefined function. The following functions are available:\n"
 290 |     ";   - kill: Kills the focused window.\n"
 291 |     ";   - switch_desktop: Switches to a specified virtual desktop.\n"
 292 |     ";   - fullscreen: Toggles fullscreen mode for the focused window.\n"
 293 |     ";   - swap: Swaps the focused window with its sibling.\n"
 294 |     ";   - transfer_node: Moves the focused window to another virtual desktop.\n"
 295 |     ";   - layout: Toggles the specified layout (master, default, stack).\n"
 296 |     ";   - traverse: (In stack layout only) Moves focus to the window above or below.\n"
 297 |     ";   - flip: Changes the window's orientation; if the window is primarily vertical, it becomes horizontal, and vice versa.\n"
 298 |     ";   - cycle_window: Moves focus to the window in the specified direction (up, down, left, right).\n"
 299 |     ";   - cycle_desktop: Cycles through the virtual desktops (left, right).\n"
 300 |     ";   - resize: Adjusts the size of the focused window (grow, shrink).\n"
 301 |     ";   - reload_config: Reloads the configuration file without restarting ZWM.\n"
 302 | 	";   - shift_window: Shift floating window position to the specified direction (up, down, left, right).\n"
 303 | 	";   - gap_handler: Increase or decrease window gaps (GROW, SHRINK).\n"
 304 | 	";   - change_state: Set window state (FLAOTING, TILED).\n"
 305 |     "\n"
 306 |     "; Define key bindings\n"
 307 |     "\n"
 308 |     "; run processes on some keys\n"
 309 |     "bind = super + return -> run(\"alacritty\")\n"
 310 |     "bind = super + space -> run(\"dmenu_run\")\n"
 311 |     "bind = super + p -> run([\"rofi\", \"-show\", \"drun\"])\n"
 312 |     "\n"
 313 |     "; kill the focused window\n"
 314 |     "bind = super + w -> func(kill)\n"
 315 |     "\n"
 316 |     "; switch to specific virtual desktops\n"
 317 |     "bind = super + 1 -> func(switch_desktop:1)\n"
 318 |     "bind = super + 2 -> func(switch_desktop:2)\n"
 319 |     "bind = super + 3 -> func(switch_desktop:3)\n"
 320 |     "bind = super + 4 -> func(switch_desktop:4)\n"
 321 |     "bind = super + 5 -> func(switch_desktop:5)\n"
 322 |     "bind = super + 6 -> func(switch_desktop:6)\n"
 323 |     "bind = super + 7 -> func(switch_desktop:7)\n"
 324 |     "\n"
 325 |     "; resize the focused window\n"
 326 |     "bind = super + l -> func(resize:grow)\n"
 327 |     "bind = super + h -> func(resize:shrink)\n"
 328 |     "\n"
 329 |     "; change the gaps between windows\n"
 330 |     "bind = super + i -> func(gap_handler:grow)\n"
 331 |     "bind = super + d -> func(gap_handler:shrink)\n"
 332 |     "\n"
 333 |     "; change window state\n"
 334 |     "bind = shift + t -> func(change_state:tile)\n"
 335 |     "bind = shift + f -> func(change_state:float)\n"
 336 |     "\n"
 337 |     "; toggle fullscreen mode\n"
 338 |     "bind = super + f -> func(fullscreen)\n"
 339 |     "\n"
 340 |     "; swap the focused window with its sibling\n"
 341 |     "bind = super + s -> func(swap)\n"
 342 |     "\n"
 343 |     "; cycle focus between windows\n"
 344 |     "bind = super + up -> func(cycle_window:up)\n"
 345 |     "bind = super + right -> func(cycle_window:right)\n"
 346 |     "bind = super + left -> func(cycle_window:left)\n"
 347 |     "bind = super + down -> func(cycle_window:down)\n"
 348 |     "\n"
 349 |     "; cycle focus between monitors\n"
 350 |     "bind = super|ctrl + right -> func(cycle_monitors:next)\n"
 351 |     "bind = super|ctrl + left -> func(cycle_monitors:prev)\n"
 352 |     "\n"
 353 | 	"; shift floating window position to the specified direction\n"
 354 |     "bind = shift + up -> func(shift_window:up)\n"
 355 |     "bind = shift + right -> func(shift_window:right)\n"
 356 |     "bind = shift + left -> func(shift_window:left)\n"
 357 |     "bind = shift + down -> func(shift_window:down)\n"
 358 |  	"\n"
 359 | 	"; grow floating windows\n"
 360 | 	"bind = super|shift + y -> func(grow_floating_window:horizontal)\n"
 361 |     "bind = super|shift + h -> func(grow_floating_window:vertical)\n"
 362 |     "\n"
 363 | 	"; shrink floating windows\n"
 364 | 	"bind = super|shift + t -> func(shrink_floating_window:horizontal)\n"
 365 | 	"bind = super|shift + g -> func(shrink_floating_window:vertical)\n"
 366 | 	"\n"
 367 | 	"; cycle through virtual desktops\n"
 368 |     "bind = super|shift + left -> func(cycle_desktop:left)\n"
 369 |     "bind = super|shift + right -> func(cycle_desktop:right)\n"
 370 |     "\n"
 371 |     "; transfer the focused window to another virtual desktop\n"
 372 |     "bind = super|shift + 1 -> func(transfer_node:1)\n"
 373 |     "bind = super|shift + 2 -> func(transfer_node:2)\n"
 374 |     "bind = super|shift + 3 -> func(transfer_node:3)\n"
 375 |     "bind = super|shift + 4 -> func(transfer_node:4)\n"
 376 |     "bind = super|shift + 5 -> func(transfer_node:5)\n"
 377 |     "bind = super|shift + 6 -> func(transfer_node:6)\n"
 378 |     "bind = super|shift + 7 -> func(transfer_node:7)\n"
 379 |     "\n"
 380 |     "; change the layout\n"
 381 |     "bind = super|shift + m -> func(layout:master)\n"
 382 |     "bind = super|shift + s -> func(layout:stack)\n"
 383 |     "bind = super|shift + d -> func(layout:default)\n"
 384 |     "\n"
 385 |     "; traverse the stack layout\n"
 386 |     "bind = super|shift + k -> func(traverse:up)\n"
 387 |     "bind = super|shift + j -> func(traverse:down)\n"
 388 |     "\n"
 389 |     "; flip the orientation of the window\n"
 390 |     "bind = super|shift + f -> func(flip)\n"
 391 |     "\n"
 392 |     "; reload the configuration file\n"
 393 |     "bind = super|shift + r -> func(reload_config)\n"
 394 |     "\n";
 395 | 	/* clang-format on */
 396 | 
 397 | 	char dir_path[strlen(filename) + 1];
 398 | 	strcpy(dir_path, filename);
 399 | 	char *last_slash = strrchr(dir_path, '/');
 400 | 	if (last_slash) {
 401 | 		*last_slash = '\0';
 402 | 		struct stat st;
 403 | 		if (stat(dir_path, &st) == -1) {
 404 | 			if (mkdir(dir_path, 0777) == -1) {
 405 | 				_LOG_(ERROR, "failed to create directory: %s", dir_path);
 406 | 				return -1;
 407 | 			}
 408 | 		}
 409 | 	}
 410 | 
 411 | 	FILE *file = fopen(filename, "w");
 412 | 	if (file == NULL) {
 413 | 		_LOG_(ERROR, "failed to create config file: %s", filename);
 414 | 		return -1;
 415 | 	}
 416 | 
 417 | 	size_t len	   = strlen(content);
 418 | 	size_t written = fwrite(content, 1, len, file);
 419 | 	if (written != len) {
 420 | 		fclose(file);
 421 | 		_LOG_(ERROR, "error writing to file: %s", filename);
 422 | 		return -1;
 423 | 	}
 424 | 
 425 | 	c->active_border_color	= 0x4a4a48;
 426 | 	c->normal_border_color	= 0x30302f;
 427 | 	c->border_width			= 2;
 428 | 	c->window_gap			= 10;
 429 | 	c->virtual_desktops		= 7;
 430 | 	c->focus_follow_pointer = true;
 431 | 
 432 | 	fclose(file);
 433 | 	return 0;
 434 | }
 435 | 
 436 | static void
 437 | trim(char *str, trim_token_t t)
 438 | {
 439 | 	if (str == NULL) {
 440 | 		return;
 441 | 	}
 442 | 
 443 | 	char *end	= str + strlen(str) - 1;
 444 | 	char *start = str;
 445 | 	char  start_token, end_token;
 446 | 
 447 | 	switch (t) {
 448 | 	case WHITE_SPACE: {
 449 | 		start_token = ' ';
 450 | 		end_token	= ' ';
 451 | 		break;
 452 | 	}
 453 | 	case CURLY_BRACKET: {
 454 | 		start_token = '{';
 455 | 		end_token	= '}';
 456 | 		break;
 457 | 	}
 458 | 	case PARENTHESIS: {
 459 | 		start_token = '(';
 460 | 		end_token	= ')';
 461 | 		break;
 462 | 	}
 463 | 	case SQUARE_BRACKET: {
 464 | 		start_token = '[';
 465 | 		end_token	= ']';
 466 | 		break;
 467 | 	}
 468 | 	case QUOTATION: {
 469 | 		start_token = '"';
 470 | 		end_token	= '"';
 471 | 		break;
 472 | 	}
 473 | 	default: return;
 474 | 	}
 475 | 
 476 | 	while (end >= str &&
 477 | 		   (*end == end_token || (t == WHITE_SPACE && isspace(*end)))) {
 478 | 		*end = '\0';
 479 | 		end--;
 480 | 	}
 481 | 
 482 | 	while (*start == start_token || (t == WHITE_SPACE && isspace(*start))) {
 483 | 		start++;
 484 | 	}
 485 | 
 486 | 	if (start != str) {
 487 | 		memmove(str, start, strlen(start) + 1);
 488 | 	}
 489 | }
 490 | 
 491 | /* caller must free using free_tokens(...) */
 492 | static char **
 493 | split_string(const char *str, char delimiter, int *count)
 494 | {
 495 | 	int i		   = 0;
 496 | 	int num_tokens = 1;
 497 | 	for (i = 0; str[i] != '\0'; i++) {
 498 | 		if (str[i] == delimiter) {
 499 | 			num_tokens++;
 500 | 		}
 501 | 	}
 502 | 
 503 | 	char **tokens = (char **)malloc((num_tokens + 1) * sizeof(char *));
 504 | 	if (tokens == NULL) {
 505 | 		_LOG_(ERROR, "failed to allocate memory");
 506 | 		return NULL;
 507 | 	}
 508 | 
 509 | 	char *str_copy = strdup(str);
 510 | 	if (str_copy == NULL) {
 511 | 		_LOG_(ERROR, "failed to duplicate string");
 512 | 		_FREE_(tokens);
 513 | 		return NULL;
 514 | 	}
 515 | 
 516 | 	char  delim_str[2] = {delimiter, '\0'};
 517 | 	char *token		   = strtok(str_copy, delim_str);
 518 | 	i				   = 0;
 519 | 	while (token && i < num_tokens) {
 520 | 		tokens[i] = strdup(token);
 521 | 		if (tokens[i] == NULL) {
 522 | 			_LOG_(ERROR, "failed to duplicate token");
 523 | 			_FREE_(str_copy);
 524 | 			free_tokens(tokens, i);
 525 | 			return NULL;
 526 | 		}
 527 | 		i++;
 528 | 		token = strtok(NULL, delim_str);
 529 | 	}
 530 | 	tokens[i] = NULL;
 531 | 
 532 | 	*count	  = i;
 533 | 	_FREE_(str_copy);
 534 | 	return tokens;
 535 | }
 536 | 
 537 | static void
 538 | free_tokens(char **tokens, int count)
 539 | {
 540 | 	if (tokens) {
 541 | 		for (int i = 0; i < count; i++) {
 542 | 			if (tokens[i]) {
 543 | 				_FREE_(tokens[i]);
 544 | 			}
 545 | 		}
 546 | 	}
 547 | 	_FREE_(tokens);
 548 | }
 549 | 
 550 | static bool
 551 | key_exist(conf_key_t *key)
 552 | {
 553 | 	conf_key_t *current = key_head;
 554 | 	while (current) {
 555 | 		if (current->execute == key->execute &&
 556 | 			current->keysym == key->keysym) {
 557 | 			return true;
 558 | 		}
 559 | 		current = current->next;
 560 | 	}
 561 | 
 562 | 	return false;
 563 | }
 564 | 
 565 | /* caller must free */
 566 | static char *
 567 | extract_body(const char *str)
 568 | {
 569 | 	const char *start = strchr(str, '(');
 570 | 	if (start == NULL) {
 571 | 		return NULL;
 572 | 	}
 573 | 
 574 | 	const char *end = strchr(start, ')');
 575 | 	if (end == NULL) {
 576 | 		return NULL;
 577 | 	}
 578 | 	size_t length = end - start + 1;
 579 | 	char  *result = (char *)malloc(length + 1);
 580 | 	if (result == NULL) {
 581 | 		_LOG_(ERROR, "failed to allocate memory");
 582 | 		return NULL;
 583 | 	}
 584 | 
 585 | 	strncpy(result, start, length);
 586 | 	result[length] = '\0';
 587 | 	return result;
 588 | }
 589 | 
 590 | static uint32_t
 591 | parse_mod_key(char *mod)
 592 | {
 593 | #ifdef _DEBUG__
 594 | 	_LOG_(DEBUG, "recieved mod key = (%s)", mod);
 595 | #endif
 596 | 	uint32_t _mod = str_to_key(mod);
 597 | 	uint32_t mask = -1;
 598 | 	if ((int)_mod == -1) {
 599 | 		int	   count;
 600 | 		char **mods = split_string(mod, '|', &count);
 601 | 		if (mods == NULL) {
 602 | 			_LOG_(ERROR, "failed to split string %s", mod);
 603 | 			return -1;
 604 | 		}
 605 | 		uint32_t mask1 = str_to_key(mods[0]);
 606 | 		if ((int)mask1 == -1) {
 607 | 			_LOG_(ERROR, "failed to find key (%s)", mods[0]);
 608 | 		}
 609 | 		uint32_t mask2 = str_to_key(mods[1]);
 610 | 		if ((int)mask2 == -1) {
 611 | 			_LOG_(ERROR, "failed to find key (%s)", mods[1]);
 612 | 		}
 613 | 		mask = mask1 | mask2;
 614 | 		free_tokens(mods, count);
 615 | 	} else {
 616 | 		mask = _mod;
 617 | 	}
 618 | 	return mask;
 619 | }
 620 | 
 621 | static uint32_t
 622 | parse_keysym(char *keysym)
 623 | {
 624 | 	uint32_t keysym_ = str_to_key(keysym);
 625 | 	if ((int)keysym_ == -1) {
 626 | 		_LOG_(ERROR, "failed to find keysym %s", keysym);
 627 | 		return -1;
 628 | 	}
 629 | 
 630 | 	return keysym_;
 631 | }
 632 | 
 633 | static void
 634 | err_cleanup(conf_key_t *k)
 635 | {
 636 | 	if (k) {
 637 | 		if (k->arg) {
 638 | 			if (k->arg->cmd) {
 639 | 				for (int i = 0; i < k->arg->argc; i++) {
 640 | 					_FREE_(k->arg->cmd[i]);
 641 | 				}
 642 | 				_FREE_(k->arg->cmd);
 643 | 			}
 644 | 			_FREE_(k->arg);
 645 | 		}
 646 | 		_FREE_(k);
 647 | 	}
 648 | }
 649 | 
 650 | static void
 651 | build_run_func(char *func_param, conf_key_t *key, uint32_t mod, uint32_t keysym)
 652 | {
 653 | 	key->mod	= mod;
 654 | 	key->keysym = (xcb_keysym_t)keysym;
 655 | 	if (strchr(func_param, '[')) {
 656 | 		trim(func_param, SQUARE_BRACKET);
 657 | 		int	   count = 0;
 658 | 		char **args	 = split_string(func_param, ',', &count);
 659 | 		if (args == NULL) {
 660 | 			_LOG_(ERROR, "failed to split string %s", func_param);
 661 | 			return;
 662 | 		}
 663 | 		key->arg->cmd = (char **)malloc((count + 1) * sizeof(char *));
 664 | 		if (key->arg->cmd == NULL) {
 665 | 			_LOG_(ERROR, "failed to allocate memory for cmd array");
 666 | 			free_tokens(args, count);
 667 | 			return;
 668 | 		}
 669 | 		key->arg->argc = count;
 670 | 		for (int i = 0; i < key->arg->argc; i++) {
 671 | 			trim(args[i], WHITE_SPACE);
 672 | 			trim(args[i], QUOTATION);
 673 | 			key->arg->cmd[i] = strdup(args[i]);
 674 | 			if (key->arg->cmd[i] == NULL) {
 675 | 				_LOG_(ERROR, "failed to duplicate token");
 676 | 				free_tokens(args, count);
 677 | 				return;
 678 | 			}
 679 | 		}
 680 | 		free_tokens(args, count);
 681 | 	} else {
 682 | 		trim(func_param, WHITE_SPACE);
 683 | 		trim(func_param, QUOTATION);
 684 | 		key->arg->cmd = (char **)malloc(1 * sizeof(char *));
 685 | 		if (key->arg->cmd == NULL) {
 686 | 			_LOG_(ERROR, "failed to allocate memory for cmd array");
 687 | 			return;
 688 | 		}
 689 | 		key->arg->cmd[0] = strdup(func_param);
 690 | 		if (key->arg->cmd[0] == NULL) {
 691 | 			_LOG_(ERROR, "failed to duplicate token");
 692 | 			key->arg->cmd = NULL;
 693 | 			return;
 694 | 		}
 695 | 		key->arg->argc = 1;
 696 | 	}
 697 | }
 698 | 
 699 | static void
 700 | set_key_args(conf_key_t *key, char *func, char *arg)
 701 | {
 702 | 	if (strcmp(func, "cycle_window") == 0) {
 703 | 		if (strcmp(arg, "up") == 0) {
 704 | 			key->arg->d = UP;
 705 | 		} else if (strcmp(arg, "right") == 0) {
 706 | 			key->arg->d = RIGHT;
 707 | 		} else if (strcmp(arg, "left") == 0) {
 708 | 			key->arg->d = LEFT;
 709 | 		} else if (strcmp(arg, "down") == 0) {
 710 | 			key->arg->d = DOWN;
 711 | 		}
 712 | 	} else if (strcmp(func, "shift_window") == 0) {
 713 | 		if (strcmp(arg, "up") == 0) {
 714 | 			key->arg->d = UP;
 715 | 		} else if (strcmp(arg, "right") == 0) {
 716 | 			key->arg->d = RIGHT;
 717 | 		} else if (strcmp(arg, "left") == 0) {
 718 | 			key->arg->d = LEFT;
 719 | 		} else if (strcmp(arg, "down") == 0) {
 720 | 			key->arg->d = DOWN;
 721 | 		}
 722 | 	} else if (strcmp(func, "layout") == 0) {
 723 | 		if (strcmp(arg, "master") == 0) {
 724 | 			key->arg->t = MASTER;
 725 | 		} else if (strcmp(arg, "default") == 0) {
 726 | 			key->arg->t = DEFAULT;
 727 | 		} else if (strcmp(arg, "grid") == 0) {
 728 | 			key->arg->t = GRID;
 729 | 		} else if (strcmp(arg, "stack") == 0) {
 730 | 			key->arg->t = STACK;
 731 | 		}
 732 | 	} else if (strcmp(func, "cycle_desktop") == 0) {
 733 | 		if (strcmp(arg, "left") == 0) {
 734 | 			key->arg->d = LEFT;
 735 | 		} else if (strcmp(arg, "right") == 0) {
 736 | 			key->arg->d = RIGHT;
 737 | 		}
 738 | 	} else if (strcmp(func, "resize") == 0) {
 739 | 		if (strcmp(arg, "grow") == 0) {
 740 | 			key->arg->r = GROW;
 741 | 		} else if (strcmp(arg, "shrink") == 0) {
 742 | 			key->arg->r = SHRINK;
 743 | 		}
 744 | 	} else if (strcmp(func, "gap_handler") == 0) {
 745 | 		if (strcmp(arg, "grow") == 0) {
 746 | 			key->arg->r = GROW;
 747 | 		} else if (strcmp(arg, "shrink") == 0) {
 748 | 			key->arg->r = SHRINK;
 749 | 		}
 750 | 	} else if (strcmp(func, "switch_desktop") == 0) {
 751 | 		char *_num = key_to_str(key->keysym);
 752 | 		int	  idx  = atoi(_num);
 753 | 		idx--;
 754 | 		key->arg->idx = idx;
 755 | 	} else if (strcmp(func, "transfer_node") == 0) {
 756 | 		char *_num = key_to_str(key->keysym);
 757 | 		int	  idx  = atoi(_num);
 758 | 		idx--;
 759 | 		key->arg->idx = idx;
 760 | 	} else if (strcmp(func, "traverse") == 0) {
 761 | 		if (strcmp(arg, "up") == 0) {
 762 | 			key->arg->d = UP;
 763 | 		} else if (strcmp(arg, "down") == 0) {
 764 | 			key->arg->d = DOWN;
 765 | 		}
 766 | 	} else if (strcmp(func, "change_state") == 0) {
 767 | 		if (strcmp(arg, "float") == 0) {
 768 | 			key->arg->s = FLOATING;
 769 | 		} else if (strcmp(arg, "tile") == 0) {
 770 | 			key->arg->s = TILED;
 771 | 		}
 772 | 	} else if (strcmp(func, "shrink_floating_window") == 0) {
 773 | 		if (strcmp(arg, "horizontal") == 0) {
 774 | 			key->arg->rd = HORIZONTAL_DIR;
 775 | 		} else if (strcmp(arg, "vertical") == 0) {
 776 | 			key->arg->rd = VERTICAL_DIR;
 777 | 		}
 778 | 	} else if (strcmp(func, "grow_floating_window") == 0) {
 779 | 		if (strcmp(arg, "horizontal") == 0) {
 780 | 			key->arg->rd = HORIZONTAL_DIR;
 781 | 		} else if (strcmp(arg, "vertical") == 0) {
 782 | 			key->arg->rd = VERTICAL_DIR;
 783 | 		}
 784 | 	} else if (strcmp(func, "cycle_monitors") == 0) {
 785 | 		if (strcmp(arg, "next") == 0) {
 786 | 			key->arg->tr = NEXT;
 787 | 		} else if (strcmp(arg, "prev") == 0) {
 788 | 			key->arg->tr = PREV;
 789 | 		}
 790 | 	}
 791 | }
 792 | 
 793 | static int
 794 | construct_key(char *mod, char *keysym, char *func, conf_key_t *key)
 795 | {
 796 | 	bool	 run_func	= false;
 797 | 	uint32_t _keysym	= -1;
 798 | 	uint32_t _mod		= -1;
 799 | 	int (*ptr)(arg_t *) = NULL;
 800 | 
 801 | 	/* parse mod key */
 802 | 	_mod				= parse_mod_key(mod);
 803 | 	if ((int)_mod == -1) {
 804 | 		_LOG_(ERROR, "failed to parse mod key for %s, func %s", mod, func);
 805 | 		return -1;
 806 | 	}
 807 | 
 808 | 	/* parse keysym if not null */
 809 | 	if (keysym) {
 810 | 		_keysym = parse_keysym(keysym);
 811 | 		if ((int)_keysym == -1) {
 812 | 			_LOG_(ERROR, "failed to parse keysym for %s", keysym);
 813 | 			return -1;
 814 | 		}
 815 | 	} else {
 816 | 		_LOG_(INFO, "keysym is null, func must be switch or transfer %s", func);
 817 | 	}
 818 | 
 819 | 	if (strncmp(func, "run", 3) == 0) {
 820 | 		run_func = true;
 821 | #ifdef _DEBUG__
 822 | 		_LOG_(INFO, "found run func %s, ...", func);
 823 | #endif
 824 | 	}
 825 | 
 826 | 	char *func_param = extract_body(func);
 827 | 	if (func_param == NULL) {
 828 | 		_LOG_(ERROR, "failed to extract func body for %s", func);
 829 | 		return -1;
 830 | 	}
 831 | 
 832 | 	trim(func_param, PARENTHESIS);
 833 | 
 834 | 	if (strchr(func_param, ':')) {
 835 | 		int	   count = 0;
 836 | 		char **s	 = split_string(func_param, ':', &count);
 837 | 		if (s == NULL || count != 2) {
 838 | 			_LOG_(ERROR,
 839 | 				  "failed to split string or incorrect count for %s",
 840 | 				  func_param);
 841 | 			_FREE_(func_param);
 842 | 			if (s)
 843 | 				_FREE_(s);
 844 | 			return -1;
 845 | 		}
 846 | 
 847 | 		char *f = strdup(s[0]);
 848 | 		char *a = strdup(s[1]);
 849 | 		ptr		= str_to_func(f);
 850 | 		if (ptr == NULL) {
 851 | 			_LOG_(ERROR, "failed to find function pointer for %s", f);
 852 | 			_FREE_(func_param);
 853 | 			_FREE_(s);
 854 | 			return -1;
 855 | 		}
 856 | 		key->mod	 = _mod;
 857 | 		key->keysym	 = _keysym;
 858 | 		key->execute = ptr;
 859 | 
 860 | 		set_key_args(key, f, a);
 861 | 		free_tokens(s, count);
 862 | 		_FREE_(f);
 863 | 		_FREE_(a);
 864 | 		_FREE_(func_param);
 865 | 		return 0;
 866 | 	}
 867 | 
 868 | 	/* handle "run" functions */
 869 | 	if (run_func) {
 870 | 		ptr = str_to_func("run");
 871 | 		if (ptr == NULL) {
 872 | 			_LOG_(ERROR, "failed to find run func pointer for %s", func_param);
 873 | 			_FREE_(func_param);
 874 | 			return -1;
 875 | 		}
 876 | 		build_run_func(func_param, key, _mod, _keysym);
 877 | 		key->execute = ptr;
 878 | 		_FREE_(func_param);
 879 | 		return 0;
 880 | 	}
 881 | 
 882 | 	/* handle other functions */
 883 | 	ptr = str_to_func(func_param);
 884 | 	if (ptr == NULL) {
 885 | 		_LOG_(ERROR, "failed to find function pointer for %s", func_param);
 886 | 		_FREE_(func_param);
 887 | 		return -1;
 888 | 	}
 889 | 
 890 | 	key->mod	 = _mod;
 891 | 	key->keysym	 = _keysym;
 892 | 	key->execute = ptr;
 893 | 	_FREE_(func_param);
 894 | 	return 0;
 895 | }
 896 | 
 897 | static int
 898 | parse_keybinding(char *str, conf_key_t *key)
 899 | {
 900 | 	if (strstr(str, "->") == NULL) {
 901 | 		_LOG_(ERROR, "invalide key format %s ", str);
 902 | 		return -1;
 903 | 	}
 904 | 
 905 | 	char plus		   = '+';
 906 | 	bool keysym_exists = false;
 907 | 	int	 i			   = 0;
 908 | 	while (str[i] != '\0') {
 909 | 		if (str[i] == plus) {
 910 | 			keysym_exists = !keysym_exists;
 911 | 			break;
 912 | 		}
 913 | 		i++;
 914 | 	}
 915 | 
 916 | 	char *mod	 = NULL;
 917 | 	char *keysym = NULL;
 918 | 	char *func	 = NULL;
 919 | 
 920 | 	if (keysym_exists) {
 921 | 		char *plus_token = strtok(str, "+");
 922 | 		mod				 = plus_token ? plus_token : NULL;
 923 | 		plus_token		 = strtok(NULL, "->");
 924 | 		keysym			 = plus_token ? plus_token : NULL;
 925 | 		func			 = strtok(NULL, "");
 926 | 		if (mod)
 927 | 			trim(mod, WHITE_SPACE);
 928 | 		if (keysym)
 929 | 			trim(keysym, WHITE_SPACE);
 930 | 		if (func) {
 931 | 			func++;
 932 | 			trim(func, WHITE_SPACE);
 933 | 		}
 934 | 	} else {
 935 | 		char *arrow_token = strtok(str, "->");
 936 | 		mod				  = arrow_token ? arrow_token : NULL;
 937 | 		func			  = strtok(NULL, "");
 938 | 		if (mod)
 939 | 			trim(mod, WHITE_SPACE);
 940 | 		if (func) {
 941 | 			func++;
 942 | 			trim(func, WHITE_SPACE);
 943 | 		}
 944 | 	}
 945 | 	return construct_key(mod, keysym, func, key);
 946 | }
 947 | 
 948 | static conf_key_t *
 949 | init_key(void)
 950 | {
 951 | 	conf_key_t *key = (conf_key_t *)calloc(1, sizeof(conf_key_t));
 952 | 	key->arg		= (arg_t *)calloc(1, sizeof(arg_t));
 953 | 
 954 | 	if (key->arg == NULL || key == NULL) {
 955 | 		_LOG_(ERROR, "failed to calloc _key__t or arg_t");
 956 | 		return NULL;
 957 | 	}
 958 | 
 959 | 	key->arg->cmd  = NULL;
 960 | 	key->arg->argc = 0;
 961 | 	key->next	   = NULL;
 962 | 
 963 | 	return key;
 964 | }
 965 | 
 966 | static void
 967 | add_key(conf_key_t **head, conf_key_t *k)
 968 | {
 969 | 	if (*head == NULL) {
 970 | 		*head = k;
 971 | 		return;
 972 | 	}
 973 | 	conf_key_t *current = *head;
 974 | 	while (current->next) {
 975 | 		current = current->next;
 976 | 	}
 977 | 	current->next = k;
 978 | }
 979 | 
 980 | static rule_t *
 981 | init_rule(void)
 982 | {
 983 | 	rule_t *rule = (rule_t *)calloc(1, sizeof(rule_t));
 984 | 
 985 | 	if (rule == NULL) {
 986 | 		_LOG_(ERROR, "failed to calloc rule_t");
 987 | 		return NULL;
 988 | 	}
 989 | 	rule->next = NULL;
 990 | 	return rule;
 991 | }
 992 | 
 993 | static void
 994 | add_rule(rule_t **head, rule_t *r)
 995 | {
 996 | 	if (*head == NULL) {
 997 | 		*head = r;
 998 | 		return;
 999 | 	}
1000 | 	rule_t *current = *head;
1001 | 	while (current->next) {
1002 | 		current = current->next;
1003 | 	}
1004 | 	current->next = r;
1005 | }
1006 | 
1007 | static void
1008 | handle_exec_cmd(char *cmd)
1009 | {
1010 | #ifdef _DEBUG__
1011 | 	_LOG_(DEBUG, "exec command = (%s)", cmd);
1012 | #endif
1013 | 
1014 | 	pid_t pid = fork();
1015 | 
1016 | 	if (pid == 0) {
1017 | 		if (strchr(cmd, ',')) {
1018 | 			trim(cmd, SQUARE_BRACKET);
1019 | 			int	   count = 0;
1020 | 			char **s	 = split_string(cmd, ',', &count);
1021 | 			if (s == NULL)
1022 | 				_exit(EXIT_FAILURE);
1023 | 			const char *args[count + 1];
1024 | 			for (int i = 0; i < count; ++i) {
1025 | 				trim(s[i], WHITE_SPACE);
1026 | 				trim(s[i], QUOTATION);
1027 | 				args[i] = s[i];
1028 | #ifdef _DEBUG__
1029 | 				_LOG_(INFO, "arg exec = %s", s[i]);
1030 | #endif
1031 | 			}
1032 | 			args[count] = NULL;
1033 | 			execvp(args[0], (char *const *)args);
1034 | 			free_tokens(s, count);
1035 | 			_LOG_(ERROR, "execvp failed");
1036 | 			_exit(EXIT_FAILURE);
1037 | 		} else {
1038 | 			trim(cmd, QUOTATION);
1039 | 			execlp(cmd, cmd, (char *)NULL);
1040 | 			_LOG_(ERROR, "execlp failed");
1041 | 			_exit(EXIT_FAILURE);
1042 | 		}
1043 | 	} else if (pid < 0) {
1044 | 		_LOG_(ERROR, "fork failed");
1045 | 		_exit(EXIT_FAILURE);
1046 | 	}
1047 | }
1048 | 
1049 | static int
1050 | construct_rule(char *class, char *state, char *desktop_number, rule_t *rule)
1051 | {
1052 | 	if (class == NULL || state == NULL || desktop_number == NULL) {
1053 | 		_LOG_(ERROR, "rules are empty");
1054 | 		return -1;
1055 | 	}
1056 | 
1057 | 	/* wm_class */
1058 | 	char *c = extract_body(class);
1059 | 	if (c == NULL) {
1060 | 		_LOG_(ERROR, "while extracting class rule body (%s)", class);
1061 | 		return -1;
1062 | 	}
1063 | 
1064 | 	trim(c, PARENTHESIS);
1065 | 	trim(c, QUOTATION);
1066 | 	uint32_t c_len = strlen(c);
1067 | 	strncpy(rule->win_name, c, c_len);
1068 | 
1069 | 	/* w_state */
1070 | 	char *s = extract_body(state);
1071 | 	if (s == NULL) {
1072 | 		_LOG_(ERROR, "while extracting state rule body");
1073 | 		return -1;
1074 | 	}
1075 | 	state_t enum_state = -1;
1076 | 	trim(s, PARENTHESIS);
1077 | 	if (strcmp(s, "tiled") == 0) {
1078 | 		enum_state = TILED;
1079 | 	} else if (strcmp(s, "floated") == 0) {
1080 | 		enum_state = FLOATING;
1081 | 	}
1082 | 	rule->state = enum_state;
1083 | 
1084 | 	/* w_desktop */
1085 | 	char *d		= extract_body(desktop_number);
1086 | 	if (d == NULL) {
1087 | 		_LOG_(ERROR, "while extracting desktop rule body");
1088 | 		return -1;
1089 | 	}
1090 | 
1091 | 	trim(d, PARENTHESIS);
1092 | 	rule->desktop_id = atoi(d);
1093 | 
1094 | 	_LOG_(INFO,
1095 | 		  "constructed rule = win name = (%s), state = (%s), desktop = (%d)",
1096 | 		  rule->win_name,
1097 | 		  rule->state == TILED ? "TILED" : "FLOATED",
1098 | 		  rule->desktop_id);
1099 | 	_FREE_(c);
1100 | 	_FREE_(s);
1101 | 	_FREE_(d);
1102 | 
1103 | 	return 0;
1104 | }
1105 | 
1106 | rule_t *
1107 | get_window_rule(xcb_window_t win)
1108 | {
1109 | 	xcb_icccm_get_wm_class_reply_t t_reply;
1110 | 	xcb_get_property_cookie_t cn = xcb_icccm_get_wm_class(wm->connection, win);
1111 | 	const uint8_t			  wr =
1112 | 		xcb_icccm_get_wm_class_reply(wm->connection, cn, &t_reply, NULL);
1113 | 	if (wr == 1) {
1114 | 		rule_t *current = rule_head;
1115 | 		while (current) {
1116 | 			if (strcasecmp(current->win_name, t_reply.class_name) == 0) {
1117 | 				xcb_icccm_get_wm_class_reply_wipe(&t_reply);
1118 | 				return current;
1119 | 			}
1120 | 			current = current->next;
1121 | 		}
1122 | 		xcb_icccm_get_wm_class_reply_wipe(&t_reply);
1123 | 	}
1124 | 	return NULL;
1125 | }
1126 | 
1127 | static int
1128 | parse_rule(char *value, rule_t *rule)
1129 | {
1130 | 	if (value == NULL) {
1131 | 		return -1;
1132 | 	}
1133 | 
1134 | 	trim(value, WHITE_SPACE);
1135 | 	int	   count = 0;
1136 | 	char **rules = split_string(value, ',', &count);
1137 | 	if (rules == NULL)
1138 | 		return -1;
1139 | 
1140 | 	if (count != 3) {
1141 | 		_LOG_(ERROR, "while splitting window rule");
1142 | 		free_tokens(rules, count);
1143 | 		return -1;
1144 | 	}
1145 | 
1146 | 	char *win_name	  = rules[0];
1147 | 	char *win_state	  = rules[1];
1148 | 	char *win_desktop = rules[2];
1149 | 
1150 | 	int	  result	  = construct_rule(win_name, win_state, win_desktop, rule);
1151 | 
1152 | 	free_tokens(rules, count);
1153 | 
1154 | 	return result;
1155 | }
1156 | 
1157 | static int
1158 | parse_config_line(char *key, char *value, config_t *c, bool reload)
1159 | {
1160 | 	if (strcmp(key, "exec") == 0) {
1161 | 		if (!reload)
1162 | 			handle_exec_cmd(value);
1163 | 	} else if (strcmp(key, "border_width") == 0) {
1164 | 		c->border_width = atoi(value);
1165 | 	} else if (strcmp(key, "active_border_color") == 0) {
1166 | 		c->active_border_color = (unsigned int)strtoul(value, NULL, 16);
1167 | 	} else if (strcmp(key, "normal_border_color") == 0) {
1168 | 		c->normal_border_color = (unsigned int)strtoul(value, NULL, 16);
1169 | 	} else if (strcmp(key, "window_gap") == 0) {
1170 | 		c->window_gap = atoi(value);
1171 | 	} else if (strcmp(key, "virtual_desktops") == 0) {
1172 | 		c->virtual_desktops = atoi(value);
1173 | 	} else if (strcmp(key, "focus_follow_pointer") == 0) {
1174 | 		if (strcmp(value, "true") == 0) {
1175 | 			c->focus_follow_pointer = true;
1176 | 		} else if (strcmp(value, "false") == 0) {
1177 | 			c->focus_follow_pointer = false;
1178 | 		} else {
1179 | 			_LOG_(ERROR, "invalid value for focus_follow_pointer: %s", value);
1180 | 			return -1;
1181 | 		}
1182 | 	} else if (strcmp(key, "rule") == 0) {
1183 | 		rule_t *rule = init_rule();
1184 | 		if (rule == NULL) {
1185 | 			_LOG_(ERROR, "failed to allocate memory for rule_t");
1186 | 			return -1;
1187 | 		}
1188 | 		if (parse_rule(value, rule) != 0) {
1189 | 			_FREE_(rule);
1190 | 			_LOG_(ERROR, "error while parsing rule %s", value);
1191 | 			return -1;
1192 | 		}
1193 | 		add_rule(&rule_head, rule);
1194 | 	} else if (strcmp(key, "bind") == 0) {
1195 | 		conf_key_t *k = init_key();
1196 | 		if (k == NULL) {
1197 | 			_LOG_(ERROR, "failed to allocate memory for _key__t");
1198 | 			return -1;
1199 | 		}
1200 | 		if (parse_keybinding(value, k) != 0) {
1201 | 			err_cleanup(k);
1202 | 			_LOG_(ERROR, "error while parsing keys");
1203 | 			return -1;
1204 | 		}
1205 | 		add_key(&key_head, k);
1206 | 	} else {
1207 | 		_LOG_(WARNING, "unknown config key: %s", key);
1208 | 	}
1209 | 	return 0;
1210 | }
1211 | 
1212 | static int
1213 | parse_config(const char *filename, config_t *c, bool reload)
1214 | {
1215 | 	FILE *file = fopen(filename, "r");
1216 | 	if (file == NULL) {
1217 | 		_LOG_(ERROR, "error: could not open file '%s'", filename);
1218 | 		return -1;
1219 | 	}
1220 | 
1221 | 	char line[MAX_LINE_LENGTH];
1222 | 	while (fgets(line, MAX_LINE_LENGTH, file)) {
1223 | 		if (line[0] == ' ' || line[0] == '\t' || line[0] == '\n' ||
1224 | 			line[0] == '\v' || line[0] == '\f' || line[0] == '\r' ||
1225 | 			line[0] == ';') {
1226 | 			continue;
1227 | 		}
1228 | 		char *key	= strtok(line, "=");
1229 | 		char *value = strtok(NULL, "\n");
1230 | 
1231 | 		if (key == NULL || value == NULL) {
1232 | 			continue;
1233 | 		}
1234 | 
1235 | 		trim(key, WHITE_SPACE);
1236 | 		trim(value, WHITE_SPACE);
1237 | 
1238 | #ifdef _DEBUG__
1239 | 		_LOG_(DEBUG,
1240 | 			  "config line = (%s) key = (%s) value = (%s)",
1241 | 			  line,
1242 | 			  key,
1243 | 			  value);
1244 | #endif
1245 | 
1246 | 		if (parse_config_line(key, value, c, reload) != 0) {
1247 | 			fclose(file);
1248 | 			return -1;
1249 | 		}
1250 | 	}
1251 | 
1252 | 	fclose(file);
1253 | 	return 0;
1254 | }
1255 | 
1256 | void
1257 | free_rules(void)
1258 | {
1259 | 	rule_t *current = rule_head;
1260 | 	while (current) {
1261 | 		rule_t *next = current->next;
1262 | 		_FREE_(current);
1263 | 		current = next;
1264 | 	}
1265 | 	rule_head = NULL;
1266 | }
1267 | 
1268 | void
1269 | free_keys(void)
1270 | {
1271 | 	conf_key_t *current = key_head;
1272 | 	while (current) {
1273 | 		conf_key_t *next = current->next;
1274 | 		if (!current->arg) {
1275 | 			current = next;
1276 | 			continue;
1277 | 		}
1278 | 		if (!current->arg->cmd) {
1279 | 			current = next;
1280 | 			continue;
1281 | 		}
1282 | 		for (int j = 0; j < current->arg->argc; j++) {
1283 | 			if (current->arg->cmd && current->arg->cmd[j]) {
1284 | 				_FREE_(current->arg->cmd[j]);
1285 | 			}
1286 | 		}
1287 | 		_FREE_(current->arg->cmd);
1288 | 		_FREE_(current->arg);
1289 | 		_FREE_(current);
1290 | 		current = next;
1291 | 	}
1292 | 	key_head = NULL;
1293 | }
1294 | 
1295 | int
1296 | reload_config(config_t *c)
1297 | {
1298 | 	const char *filename = CONF_PATH;
1299 | 	return parse_config(filename, c, true);
1300 | }
1301 | 
1302 | int
1303 | load_config(config_t *c)
1304 | {
1305 | 	const char *filename = CONF_PATH;
1306 | 	if (!file_exists(filename)) {
1307 | 		write_default_config(filename, c);
1308 | 	}
1309 | 	return parse_config(filename, c, false);
1310 | }
1311 | 


--------------------------------------------------------------------------------
/src/config_parser.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | 
29 | #ifndef ZWM_CONFIG_PARSER_H
30 | #define ZWM_CONFIG_PARSER_H
31 | 
32 | #include "type.h"
33 | 
34 | #define MAX_RULES (2 << 2)
35 | 
36 | extern rule_t	  *rule_head;
37 | extern conf_key_t *key_head;
38 | 
39 | /* clang-format off */
40 | rule_t *get_window_rule(xcb_window_t win);
41 | int load_config(config_t *c);
42 | void free_keys(void);
43 | void free_rules(void);
44 | int reload_config(config_t *c);
45 | /* clang-format on */
46 | 
47 | #endif /* ZWM_CONFIG_PARSER_H */
48 | 


--------------------------------------------------------------------------------
/src/helper.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | #ifndef ZWM_HELPER_H
29 | #define ZWM_HELPER_H
30 | 
31 | #include "logger.h"
32 | 
33 | #define LEN(x)								   (sizeof(x) / sizeof(*x))
34 | #define CLEANMASK(mask)						   (mask & ~(0 | XCB_MOD_MASK_LOCK))
35 | #define IS_TILED(c)							   (c->state == TILED)
36 | #define IS_FLOATING(c)						   (c->state == FLOATING)
37 | #define IS_FULLSCREEN(c)					   (c->state == FULLSCREEN)
38 | #define IS_EXTERNAL(n)						   (n->node_type == EXTERNAL_NODE)
39 | #define IS_INTERNAL(n)						   (n->node_type == INTERNAL_NODE)
40 | #define IS_ROOT(n)							   (n->node_type == ROOT_NODE)
41 | 
42 | #define DEFINE_KEY(mask, keysym, handler, arg) {mask, keysym, handler, arg}
43 | #define DEFINE_MAPPING(name, value)			   {name, value}
44 | #define _KEY(k)								   XK_##k
45 | 
46 | /* spent way too many hours hunting double-free bugs. This should handle it. */
47 | #define _FREE_(ptr)                                                            \
48 | 	do {                                                                       \
49 | 		if (ptr) {                                                             \
50 | 			free(ptr);                                                         \
51 | 			ptr = NULL;                                                        \
52 | 		}                                                                      \
53 | 	} while (0)
54 | 
55 | #define _LOG_(level, format, ...)                                              \
56 | 	do {                                                                       \
57 | 		log_message(level,                                                     \
58 | 					"[%s:%s():%d] " format,                                    \
59 | 					__FILE__,                                                  \
60 | 					__func__,                                                  \
61 | 					__LINE__,                                                  \
62 | 					##__VA_ARGS__);                                            \
63 | 	} while (0)
64 | 
65 | #define MAX(a, b)                                                              \
66 | 	({                                                                         \
67 | 		__typeof__(a) _a = (a);                                                \
68 | 		__typeof__(b) _b = (b);                                                \
69 | 		_a > _b ? _a : _b;                                                     \
70 | 	})
71 | 
72 | #endif /* ZWM_HELPER_H */
73 | 


--------------------------------------------------------------------------------
/src/logger.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * BSD 2-Clause License
  3 |  * Copyright (c) 2024, Yazeed Alharthi
  4 |  *
  5 |  * Redistribution and use in source and binary forms, with or without
  6 |  * modification, are permitted provided that the following conditions
  7 |  * are met:
  8 |  *
  9 |  *	  1. Redistributions of source code must retain the above copyright
 10 |  *	  notice, this list of conditions and the following disclaimer.
 11 |  *
 12 |  *	  2. Redistributions in binary form must reproduce the above copyright
 13 |  *	  notice, this list of conditions and the following disclaimer in the
 14 |  *	  documentation and/or other materials provided with the distribution.
 15 |  *
 16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27 |  */
 28 | 
 29 | #include "type.h"
 30 | #include <pwd.h>
 31 | #include <stdarg.h>
 32 | #include <stdbool.h>
 33 | #include <stdio.h>
 34 | #include <sys/stat.h>
 35 | #include <time.h>
 36 | #include <unistd.h>
 37 | #include <xcb/xcb.h>
 38 | 
 39 | #define LOG_DIR		 "/.local/share/xorg"
 40 | #define LOG_FILE	 "zwm.log"
 41 | #define MAX_PATH_LEN (2 << 7)
 42 | #ifdef _DEBUG__
 43 | #define MAX_LOG_SIZE (2 << 15) // ~64kb
 44 | #else
 45 | #define MAX_LOG_SIZE (2 << 12) // ~8kb
 46 | #endif
 47 | 
 48 | 
 49 | void
 50 | log_message(log_level_t level, const char *format, ...)
 51 | {
 52 | 	static char full_path[MAX_PATH_LEN] = {0};
 53 | 	static int	initialized				= false;
 54 | 
 55 | 	if (!initialized) {
 56 | 		const char *homedir;
 57 | 		if ((homedir = getenv("HOME")) == NULL) {
 58 | 			__uid_t		   id = getuid();
 59 | 			struct passwd *pw = getpwuid(id);
 60 | 			if (pw == NULL) {
 61 | 				fprintf(stderr, "Failed to get home directory\n");
 62 | 				return;
 63 | 			}
 64 | 			homedir = pw->pw_dir;
 65 | 		}
 66 | 
 67 | 		snprintf(full_path,
 68 | 				 sizeof(full_path),
 69 | 				 "%s%s/%s",
 70 | 				 homedir,
 71 | 				 LOG_DIR,
 72 | 				 LOG_FILE);
 73 | 		initialized = true;
 74 | 	}
 75 | 
 76 | 	time_t	   t   = time(NULL);
 77 | 	struct tm *ptr = localtime(&t);
 78 | 	va_list	   args;
 79 | 	char	   buf[100];
 80 | 
 81 | 	strftime(buf, sizeof(buf), "%F/%I:%M:%S %p", ptr);
 82 | 
 83 | 	struct stat st;
 84 | 	FILE	   *log_file;
 85 | 	if (stat(full_path, &st) == 0) {
 86 | 		if (st.st_size >= MAX_LOG_SIZE) {
 87 | 			log_file = fopen(full_path, "w");
 88 | 		} else {
 89 | 			log_file = fopen(full_path, "a");
 90 | 		}
 91 | 	} else {
 92 | 		log_file = fopen(full_path, "a");
 93 | 	}
 94 | 
 95 | 	if (log_file == NULL) {
 96 | 		fprintf(stderr, "Failed to open log file for writing\n");
 97 | 		return;
 98 | 	}
 99 | 
100 | 	fprintf(log_file, "%s ", buf);
101 | 	switch (level) {
102 | 	case ERROR: fprintf(log_file, "[ERROR] "); break;
103 | 	case INFO: fprintf(log_file, "[INFO] "); break;
104 | 	case DEBUG: fprintf(log_file, "[DEBUG] "); break;
105 | 	case WARNING: fprintf(log_file, "[WARNING] "); break;
106 | 	default: break;
107 | 	}
108 | 
109 | 	va_start(args, format);
110 | 	vfprintf(log_file, format, args);
111 | 	va_end(args);
112 | 
113 | 	fprintf(log_file, "\n");
114 | 	fclose(log_file);
115 | }
116 | 


--------------------------------------------------------------------------------
/src/logger.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | 
29 | #ifndef ZWM_LOGGER_H
30 | #define ZWM_LOGGER_H
31 | 
32 | #include "type.h"
33 | /* clang-format off */
34 | void log_message(log_level_t level, const char *format, ...);
35 | void log_window_id(xcb_window_t window, const char *message);
36 | /* clang-format on */
37 | #endif /* ZWM_LOGGER_H */
38 | 


--------------------------------------------------------------------------------
/src/queue.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | 
29 | #include "queue.h"
30 | #include "type.h"
31 | #include <stdio.h>
32 | #include <stdlib.h>
33 | #include <xcb/xcb_icccm.h>
34 | 
35 | queue_t *
36 | create_queue(void)
37 | {
38 | 	queue_t *q = (queue_t *)malloc(sizeof(queue_t));
39 | 	if (!q)
40 | 		return NULL;
41 | 	q->front = q->rear = NULL;
42 | 	return q;
43 | }
44 | 
45 | void
46 | enqueue(queue_t *q, node_t *n)
47 | {
48 | 	queue_node_t *nnode = (queue_node_t *)malloc(sizeof(queue_node_t));
49 | 	if (!nnode)
50 | 		return;
51 | 	nnode->tree_node = n;
52 | 	nnode->next		 = NULL;
53 | 	if (!q->rear) {
54 | 		q->front = q->rear = nnode;
55 | 		return;
56 | 	}
57 | 	q->rear->next = nnode;
58 | 	q->rear		  = nnode;
59 | }
60 | 
61 | node_t *
62 | dequeue(queue_t *q)
63 | {
64 | 	if (!q->front)
65 | 		return NULL;
66 | 	queue_node_t *temp = q->front;
67 | 	node_t		 *node = temp->tree_node;
68 | 	q->front		   = q->front->next;
69 | 	if (!q->front)
70 | 		q->rear = NULL;
71 | 	free(temp);
72 | 	return node;
73 | }
74 | 
75 | bool
76 | is_queue_empty(queue_t *q)
77 | {
78 | 	return q->front == NULL;
79 | }
80 | 
81 | void
82 | free_queue(queue_t *q)
83 | {
84 | 	while (q->front) {
85 | 		queue_node_t *temp = q->front;
86 | 		q->front		   = q->front->next;
87 | 		free(temp);
88 | 	}
89 | 	free(q);
90 | }
91 | 


--------------------------------------------------------------------------------
/src/queue.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | 
29 | #ifndef ZWM_QUEUE_H
30 | #define ZWM_QUEUE_H
31 | 
32 | #include "type.h"
33 | 
34 | /* clang-format off */
35 | queue_t *create_queue(void);
36 | void enqueue(queue_t *q, node_t *n);
37 | node_t *dequeue(queue_t *q);
38 | bool is_queue_empty(queue_t *q);
39 | void free_queue(queue_t *q);
40 | /* clang-format on */
41 | 
42 | #endif /* ZWM_QUEUE_H */
43 | 


--------------------------------------------------------------------------------
/src/tree.c:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * BSD 2-Clause License
   3 |  * Copyright (c) 2024, Yazeed Alharthi
   4 |  *
   5 |  * Redistribution and use in source and binary forms, with or without
   6 |  * modification, are permitted provided that the following conditions
   7 |  * are met:
   8 |  *
   9 |  *	1. Redistributions of source code must retain the above
  10 |  *  copyright notice, this list of conditions and the following
  11 |  *  disclaimer.
  12 |  *
  13 |  *	2. Redistributions in binary form must reproduce the above
  14 |  *  copyright notice, this list of conditions and the following
  15 |  *  disclaimer in the documentation and/or other materials provided
  16 |  *  with the distribution.
  17 |  *
  18 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21 |  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  22 |  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  23 |  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24 |  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25 |  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26 |  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27 |  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28 |  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  29 |  * OF THE POSSIBILITY OF SUCH DAMAGE.
  30 |  */
  31 | 
  32 | #include "tree.h"
  33 | 
  34 | #include <assert.h>
  35 | #include <stdbool.h>
  36 | #include <stdint.h>
  37 | #include <stdio.h>
  38 | #include <stdlib.h>
  39 | #include <xcb/xcb.h>
  40 | #include <xcb/xcb_icccm.h>
  41 | 
  42 | #include "helper.h"
  43 | #include "queue.h"
  44 | #include "type.h"
  45 | #include "zwm.h"
  46 | 
  47 | /* clang-format off */
  48 | static void master_layout(node_t *parent, node_t *);
  49 | static void stack_layout(node_t *parent);
  50 | static void default_layout(node_t *parent);
  51 | static node_t *find_tree_root(node_t *);
  52 | static bool is_parent_null(const node_t *node);
  53 | /* clang-format on */
  54 | 
  55 | node_t *
  56 | create_node(client_t *c)
  57 | {
  58 | 	if (c == 0x00)
  59 | 		return NULL;
  60 | 
  61 | 	node_t *node = (node_t *)malloc(sizeof(node_t));
  62 | 	if (node == 0x00) {
  63 | 		_FREE_(c);
  64 | 		return NULL;
  65 | 	}
  66 | 
  67 | 	node->rectangle			 = (rectangle_t){0};
  68 | 	node->floating_rectangle = (rectangle_t){0};
  69 | 	node->client			 = c;
  70 | 	node->parent			 = NULL;
  71 | 	node->first_child		 = NULL;
  72 | 	node->second_child		 = NULL;
  73 | 	node->is_master			 = false;
  74 | 	node->is_focused		 = false;
  75 | 
  76 | 	return node;
  77 | }
  78 | 
  79 | node_t *
  80 | init_root(void)
  81 | {
  82 | 	node_t *node = (node_t *)malloc(sizeof(node_t));
  83 | 	if (node == 0x00)
  84 | 		return NULL;
  85 | 
  86 | 	node->rectangle			 = (rectangle_t){0};
  87 | 	node->floating_rectangle = (rectangle_t){0};
  88 | 	node->client			 = NULL;
  89 | 	node->parent			 = NULL;
  90 | 	node->first_child		 = NULL;
  91 | 	node->second_child		 = NULL;
  92 | 	node->node_type			 = ROOT_NODE;
  93 | 	node->is_master			 = false;
  94 | 	node->is_focused		 = false;
  95 | 
  96 | 	return node;
  97 | }
  98 | 
  99 | /* render tree - apply visual changes to the screen.
 100 |  * It's called whenever a window maps/unmaps, or when a layout changes or visual
 101 |  * effects need to take place.
 102 |  * It is being used extensively in this code base.
 103 |  * Note: this function assumes rectangles and positions to be pre-calculated.
 104 |  */
 105 | int
 106 | render_tree(node_t *node)
 107 | {
 108 | 	if (!node)
 109 | 		return 0;
 110 | 
 111 | 	queue_t *q = create_queue();
 112 | 	if (!q) {
 113 | 		_LOG_(ERROR, "queue creation failed");
 114 | 		return -1;
 115 | 	}
 116 | 
 117 | 	enqueue(q, node);
 118 | 	while (q->front) {
 119 | 		node_t *current = dequeue(q);
 120 | 		if (!IS_INTERNAL(current) && current->client) {
 121 | 			if (!IS_FULLSCREEN(current->client)) {
 122 | 				if (tile(current) != 0) {
 123 | 					_LOG_(ERROR,
 124 | 						  "error tiling window %d",
 125 | 						  current->client->window);
 126 | 					free_queue(q);
 127 | 					return -1;
 128 | 				}
 129 | 			}
 130 | 			continue;
 131 | 		}
 132 | 		if (current->first_child)
 133 | 			enqueue(q, current->first_child);
 134 | 		if (current->second_child)
 135 | 			enqueue(q, current->second_child);
 136 | 	}
 137 | 	free_queue(q);
 138 | 	return 0;
 139 | }
 140 | 
 141 | static int
 142 | get_tree_level(node_t *node)
 143 | {
 144 | 	if (node == NULL)
 145 | 		return 0;
 146 | 
 147 | 	int level_first_child  = get_tree_level(node->first_child);
 148 | 	int level_second_child = get_tree_level(node->second_child);
 149 | 	return 1 + MAX(level_first_child, level_second_child);
 150 | }
 151 | 
 152 | static bool
 153 | has_floating_children(const node_t *parent)
 154 | {
 155 | 	return (parent->first_child && parent->first_child->client &&
 156 | 			IS_FLOATING(parent->first_child->client)) ||
 157 | 		   (parent->second_child && parent->second_child->client &&
 158 | 			IS_FLOATING(parent->second_child->client));
 159 | }
 160 | 
 161 | static node_t *
 162 | get_floating_child(const node_t *parent)
 163 | {
 164 | 	if (parent->first_child && parent->first_child->client &&
 165 | 		IS_FLOATING(parent->first_child->client)) {
 166 | 		return parent->first_child;
 167 | 	}
 168 | 
 169 | 	if (parent->second_child && parent->second_child->client &&
 170 | 		IS_FLOATING(parent->second_child->client)) {
 171 | 		return parent->second_child;
 172 | 	}
 173 | 
 174 | 	return NULL;
 175 | }
 176 | 
 177 | static void
 178 | insert_floating_node(node_t *node, desktop_t *d)
 179 | {
 180 | 	assert(IS_FLOATING(node->client));
 181 | 	node_t *n = find_any_leaf(d->tree);
 182 | 	if (n == NULL)
 183 | 		return;
 184 | 
 185 | 	if (n->first_child == NULL) {
 186 | 		n->first_child = node;
 187 | 	} else {
 188 | 		n->second_child = node;
 189 | 	}
 190 | 	node->node_type = EXTERNAL_NODE;
 191 | }
 192 | 
 193 | static void
 194 | split_rect(node_t *n, split_type_t s)
 195 | {
 196 | 	const int16_t gap		  = conf.window_gap - conf.border_width;
 197 | 	const int16_t pgap		  = conf.window_gap + conf.border_width;
 198 | 	const int16_t half_width  = (n->rectangle.width - gap) / 2;
 199 | 	const int16_t half_height = (n->rectangle.height - gap) / 2;
 200 | 	node_t		 *n1		  = n->first_child;
 201 | 	node_t		 *n2		  = n->second_child;
 202 | 	rectangle_t	 *fr		  = &n1->rectangle;
 203 | 	rectangle_t	 *sr		  = &n2->rectangle;
 204 | 	rectangle_t	  nr		  = n->rectangle;
 205 | 	bool		  h			  = (s == HORIZONTAL_TYPE);
 206 | 	node_t		 *nc		  = (h) ? n1 : n2;
 207 | 
 208 | 	fr->x					  = nr.x;
 209 | 	fr->y					  = nr.y;
 210 | 	fr->width				  = (h) ? half_width : nr.width;
 211 | 	fr->height				  = (h) ? nr.height : half_height;
 212 | 
 213 | 	sr->x					  = (h) ? nr.x + fr->width + pgap : nr.x;
 214 | 	sr->y					  = (h) ? nr.y : nr.y + fr->height + pgap;
 215 | 	sr->width				  = (h) ? nr.width - fr->width - gap : nr.width;
 216 | 	sr->height				  = (h) ? nr.height : nr.height - fr->height - gap;
 217 | 
 218 | 	if (IS_EXTERNAL(nc) && IS_FLOATING(nc->client)) {
 219 | 		*sr = nr;
 220 | 	}
 221 | }
 222 | 
 223 | /* split_node - splits a node's rectangle in half, the split could be
 224 |  * vertical or horizontal depending on (width > height)? */
 225 | static void
 226 | split_node(node_t *n, node_t *nd)
 227 | {
 228 | 	if (IS_FLOATING(nd->client)) {
 229 | 		n->first_child->rectangle = n->floating_rectangle = n->rectangle;
 230 | 		return;
 231 | 	}
 232 | 	if (n->rectangle.width >= n->rectangle.height) {
 233 | 		/* horizontal split */
 234 | 		split_rect(n, HORIZONTAL_TYPE);
 235 | 	} else {
 236 | 		/* verticall split */
 237 | 		split_rect(n, VERTICAL_TYPE);
 238 | 	}
 239 | }
 240 | 
 241 | /* insert_node - change the given focused node type to be internal, and then
 242 |  * inserts a new node as its child, along with the current node's client as
 243 |  * another child. Both children share the parent node's rectangle. */
 244 | void
 245 | insert_node(node_t *node, node_t *new_node, layout_t layout)
 246 | {
 247 | #ifdef _DEBUG__
 248 | 	_LOG_(DEBUG,
 249 | 		  "node to split %d, node to insert %d",
 250 | 		  node->client->window,
 251 | 		  new_node->client->window);
 252 | #endif
 253 | 
 254 | 	if (node == NULL) {
 255 | 		_LOG_(ERROR, "node is null");
 256 | 		return;
 257 | 	}
 258 | 
 259 | 	if (node->client == NULL) {
 260 | 		_LOG_(ERROR, "client is null in node");
 261 | 		return;
 262 | 	}
 263 | 
 264 | 	/* change the node type to INTERNAL if it isn't ROOT */
 265 | 	if (!IS_ROOT(node))
 266 | 		node->node_type = INTERNAL_NODE;
 267 | 
 268 | 	/* check if the node is floating and should retain its rectangle*/
 269 | 	bool move_rect = false;
 270 | 	if (IS_FLOATING(node->client)) {
 271 | 		move_rect = true;
 272 | 	}
 273 | 
 274 | 	node->first_child = create_node(node->client);
 275 | 	if (node->first_child == NULL)
 276 | 		return;
 277 | 
 278 | 	if (node->is_master) {
 279 | 		node->is_master				 = false;
 280 | 		node->first_child->is_master = true;
 281 | 	}
 282 | 	if (node->is_focused) {
 283 | 		node->is_focused			  = false;
 284 | 		node->first_child->is_focused = true;
 285 | 	}
 286 | 
 287 | 	node->first_child->parent	 = node;
 288 | 	node->first_child->node_type = EXTERNAL_NODE;
 289 | 	node->client				 = NULL;
 290 | 
 291 | 	if (move_rect) {
 292 | 		node->first_child->floating_rectangle = node->floating_rectangle;
 293 | 	}
 294 | 
 295 | 	node->second_child = new_node;
 296 | 	if (node->second_child == NULL)
 297 | 		return;
 298 | 
 299 | 	node->second_child->parent	  = node;
 300 | 	node->second_child->node_type = EXTERNAL_NODE;
 301 | 
 302 | 	if (layout == DEFAULT) {
 303 | 		split_node(node, new_node);
 304 | 	} else if (layout == STACK) {
 305 | 		node->second_child->rectangle = node->first_child->rectangle =
 306 | 			node->rectangle;
 307 | 
 308 | 	} else if (layout == MASTER) {
 309 | 		// todo
 310 | 		node_t *p = find_tree_root(node);
 311 | 		node_t *m = find_master_node(p);
 312 | 		master_layout(p, m);
 313 | 	}
 314 | }
 315 | 
 316 | /* arrange_tree - applies layout changes to a given tree */
 317 | void
 318 | arrange_tree(node_t *tree, layout_t l)
 319 | {
 320 | 	if (!tree) {
 321 | 		return;
 322 | 	}
 323 | 
 324 | 	switch (l) {
 325 | 	case DEFAULT: {
 326 | 		default_layout(tree);
 327 | 		break;
 328 | 	}
 329 | 	case MASTER: {
 330 | 		node_t *m = find_master_node(tree);
 331 | 		master_layout(tree, m);
 332 | 		break;
 333 | 	}
 334 | 	case STACK: {
 335 | 		stack_layout(tree);
 336 | 		break;
 337 | 	}
 338 | 	case GRID: break;
 339 | 	}
 340 | }
 341 | 
 342 | node_t *
 343 | find_node_by_window_id(node_t *root, xcb_window_t win)
 344 | {
 345 | 	if (root == NULL)
 346 | 		return NULL;
 347 | 
 348 | 	if (root->client && root->client->window == win) {
 349 | 		return root;
 350 | 	}
 351 | 
 352 | 	node_t *l = find_node_by_window_id(root->first_child, win);
 353 | 	if (l)
 354 | 		return l;
 355 | 
 356 | 	node_t *r = find_node_by_window_id(root->second_child, win);
 357 | 	if (r)
 358 | 		return r;
 359 | 
 360 | 	return NULL;
 361 | }
 362 | 
 363 | void
 364 | free_tree(node_t *root)
 365 | {
 366 | 	if (root == NULL) {
 367 | 		return;
 368 | 	}
 369 | 	free_tree(root->first_child);
 370 | 	free_tree(root->second_child);
 371 | 	_FREE_(root->client);
 372 | 	_FREE_(root);
 373 | }
 374 | 
 375 | /* resize_subtree - recursively resizes the subtree of a given parent node based
 376 |  * on the parent's rectangle dimensions. */
 377 | void
 378 | resize_subtree(node_t *parent)
 379 | {
 380 | 	if (parent == NULL)
 381 | 		return;
 382 | 
 383 | 	if (parent->rectangle.width >= parent->rectangle.height) {
 384 | 		split_rect(parent, HORIZONTAL_TYPE);
 385 | 	} else {
 386 | 		split_rect(parent, VERTICAL_TYPE);
 387 | 	}
 388 | 
 389 | 	if (parent->first_child) {
 390 | 		if (IS_INTERNAL(parent->first_child)) {
 391 | 			resize_subtree(parent->first_child);
 392 | 		}
 393 | 	}
 394 | 	if (parent->second_child) {
 395 | 		if (IS_INTERNAL(parent->second_child)) {
 396 | 			resize_subtree(parent->second_child);
 397 | 		}
 398 | 	}
 399 | }
 400 | 
 401 | node_t *
 402 | find_master_node(node_t *root)
 403 | {
 404 | 	if (root == NULL)
 405 | 		return NULL;
 406 | 
 407 | 	if (root->is_master)
 408 | 		return root;
 409 | 
 410 | 	node_t *l = find_master_node(root->first_child);
 411 | 	if (l)
 412 | 		return l;
 413 | 
 414 | 	node_t *r = find_master_node(root->second_child);
 415 | 	if (r)
 416 | 		return r;
 417 | 
 418 | 	return NULL;
 419 | }
 420 | 
 421 | static node_t *
 422 | find_floating_node(node_t *root)
 423 | {
 424 | 	if (root == NULL)
 425 | 		return NULL;
 426 | 
 427 | 	if (IS_FLOATING(root->client))
 428 | 		return root;
 429 | 
 430 | 	node_t *l = find_floating_node(root->first_child);
 431 | 	if (l)
 432 | 		return l;
 433 | 
 434 | 	node_t *r = find_floating_node(root->second_child);
 435 | 	if (r)
 436 | 		return r;
 437 | 
 438 | 	return NULL;
 439 | }
 440 | 
 441 | static bool
 442 | is_sibling_floating(node_t *node)
 443 | {
 444 | 	if (node == NULL || node->parent == NULL) {
 445 | 		return false;
 446 | 	}
 447 | 	node_t		 *parent  = node->parent;
 448 | 	const node_t *sibling = (parent->first_child == node) ? parent->second_child
 449 | 														  : parent->first_child;
 450 | 	return (sibling && sibling->client && IS_FLOATING(sibling->client));
 451 | }
 452 | 
 453 | static void
 454 | populate_win_array(node_t *root, xcb_window_t *arr, size_t *index)
 455 | {
 456 | 	if (root == NULL)
 457 | 		return;
 458 | 
 459 | 	if (root->client && root->client->window != XCB_NONE) {
 460 | 		arr[*index] = root->client->window;
 461 | 		(*index)++;
 462 | 	}
 463 | 	populate_win_array(root->first_child, arr, index);
 464 | 	populate_win_array(root->second_child, arr, index);
 465 | }
 466 | 
 467 | /* stack_and_lower - collects floating windows and optionally lowers
 468 |  * non-floating ones.
 469 |  *
 470 |  * goes through the tree and:
 471 |  * - adds floating windows to a stack, and resize the stack if it fills up.
 472 |  * - lowers non-floating windows unless the layout is stacked.
 473 |  * - calls itself on each child node to cover the whole tree. */
 474 | static void
 475 | stack_and_lower(
 476 | 	node_t *root, node_t **stack, int *top, int max_size, bool is_stacked)
 477 | {
 478 | 	if (root == NULL)
 479 | 		return;
 480 | 	if (root->client && !IS_INTERNAL(root) && IS_FLOATING(root->client)) {
 481 | 		if (*top < max_size - 1) {
 482 | 			stack[++(*top)] = root;
 483 | 		} else {
 484 | 			int		 size = max_size * 2;
 485 | 			node_t **s	  = realloc(stack, sizeof(node_t *) * size);
 486 | 			if (s == NULL) {
 487 | 				_LOG_(ERROR, "cannot reallocate stack");
 488 | 				return;
 489 | 			}
 490 | 			stack			= s;
 491 | 			max_size		= size;
 492 | 			stack[++(*top)] = root;
 493 | 		}
 494 | 	} else if (root->client && !IS_INTERNAL(root) &&
 495 | 			   !IS_FLOATING(root->client)) { // non floating
 496 | 		if (!is_stacked)
 497 | 			lower_window(root->client->window);
 498 | 	}
 499 | 	stack_and_lower(root->first_child, stack, top, max_size, is_stacked);
 500 | 	stack_and_lower(root->second_child, stack, top, max_size, is_stacked);
 501 | }
 502 | 
 503 | /* sort - sorts floating windows by size (largest first).
 504 |  *
 505 |  * Sorts floating windows based on their size (width * height).
 506 |  * Biggest windows go first, smallest last.
 507 |  *
 508 |  * Uses a bubble sort */
 509 | static void
 510 | sort(node_t **s, int n)
 511 | {
 512 | 	for (int i = 0; i <= n; i++) {
 513 | 		for (int j = i + 1; j <= n; j++) {
 514 | 			int32_t area_i = s[i]->rectangle.height * s[i]->rectangle.width;
 515 | 			int32_t area_j = s[j]->rectangle.height * s[j]->rectangle.width;
 516 | 			if (area_j > area_i) {
 517 | 				// swap
 518 | 				node_t *temp = s[i];
 519 | 				s[i]		 = s[j];
 520 | 				s[j]		 = temp;
 521 | 			}
 522 | 		}
 523 | 	}
 524 | }
 525 | 
 526 | /* restack - keeps floating windows above everything else. */
 527 | void
 528 | restack(void)
 529 | {
 530 | 	node_t *root = curr_monitor->desk->tree;
 531 | 	if (root == NULL)
 532 | 		return;
 533 | 
 534 | 	int		 stack_size = 5;
 535 | 	int		 top		= -1;
 536 | 	node_t **stack		= (node_t **)malloc(sizeof(node_t *) * stack_size);
 537 | 	if (stack == NULL) {
 538 | 		_LOG_(ERROR, "cannot allocate stack");
 539 | 		return;
 540 | 	}
 541 | 	stack_and_lower(
 542 | 		root, stack, &top, stack_size, curr_monitor->desk->layout == STACK);
 543 | 	if (top == 0) {
 544 | 		if (stack[0]->client)
 545 | 			raise_window(stack[0]->client->window);
 546 | 	} else if (top > 0) {
 547 | 		sort(stack, top);
 548 | 		for (int i = 1; i <= top; i++) {
 549 | 			if (stack[i]->client && stack[i]->client->window &&
 550 | 				stack[i - 1]->client && stack[i - 1]->client->window) {
 551 | 				window_above(stack[i]->client->window,
 552 | 							 stack[i - 1]->client->window);
 553 | 			}
 554 | 		}
 555 | 
 556 | #ifdef _DEBUG__
 557 | 		char *s	 = win_name(stack[0]->client->window);
 558 | 		char *ss = win_name(stack[top]->client->window);
 559 | 		_LOG_(DEBUG,
 560 | 			  "largest floating window: %s, smallest floating window: %s",
 561 | 			  s,
 562 | 			  ss);
 563 | 		_FREE_(s);
 564 | 		_FREE_(ss);
 565 | #endif
 566 | 	}
 567 | 	_FREE_(stack);
 568 | }
 569 | 
 570 | void
 571 | restackv2(node_t *root)
 572 | {
 573 | 	if (root == NULL) {
 574 | 		return;
 575 | 	}
 576 | 	if (root->first_child && root->first_child->client &&
 577 | 		IS_EXTERNAL(root->first_child)) {
 578 | 		if (IS_FLOATING(root->first_child->client)) {
 579 | 			if (root->second_child && root->second_child->client &&
 580 | 				IS_EXTERNAL(root->second_child) &&
 581 | 				IS_FLOATING(root->second_child->client)) {
 582 | 				window_below(root->first_child->client->window,
 583 | 							 root->second_child->client->window);
 584 | 			} else {
 585 | 				raise_window(root->first_child->client->window);
 586 | 			}
 587 | 		} else {
 588 | 			lower_window(root->first_child->client->window);
 589 | 		}
 590 | 	}
 591 | 	if (root->second_child && root->second_child->client &&
 592 | 		IS_EXTERNAL(root->second_child)) {
 593 | 		if (IS_FLOATING(root->second_child->client)) {
 594 | 			if (root->first_child == NULL ||
 595 | 				root->first_child->client == NULL ||
 596 | 				!IS_EXTERNAL(root->first_child) ||
 597 | 				!IS_FLOATING(root->first_child->client)) {
 598 | 				raise_window(root->second_child->client->window);
 599 | 			}
 600 | 		} else {
 601 | 			lower_window(root->second_child->client->window);
 602 | 		}
 603 | 	}
 604 | 	restackv2(root->first_child);
 605 | 	restackv2(root->second_child);
 606 | }
 607 | 
 608 | static bool
 609 | has_sibling(const node_t *node)
 610 | {
 611 | 	if (node == NULL || node->parent == NULL) {
 612 | 		return false;
 613 | 	}
 614 | 	const node_t *parent = node->parent;
 615 | 	return (parent->first_child && parent->second_child);
 616 | }
 617 | 
 618 | static bool
 619 | has_internal_sibling(const node_t *node)
 620 | {
 621 | 	if (node == NULL || node->parent == NULL) {
 622 | 		return false;
 623 | 	}
 624 | 	const node_t *parent = node->parent;
 625 | 	return (parent->first_child && parent->second_child) &&
 626 | 		   ((IS_INTERNAL(parent->first_child)) ||
 627 | 			(IS_INTERNAL(parent->second_child)));
 628 | }
 629 | 
 630 | static bool
 631 | is_sibling_external(node_t *node)
 632 | {
 633 | 	if (node == NULL || node->parent == NULL) {
 634 | 		return false;
 635 | 	}
 636 | 	node_t *parent	= node->parent;
 637 | 	node_t *sibling = (parent->first_child == node) ? parent->second_child
 638 | 													: parent->first_child;
 639 | 	return (sibling && IS_EXTERNAL(sibling));
 640 | }
 641 | 
 642 | static node_t *
 643 | get_external_sibling(const node_t *node)
 644 | {
 645 | 	if (node == NULL || node->parent == NULL) {
 646 | 		return NULL;
 647 | 	}
 648 | 
 649 | 	const node_t *parent  = node->parent;
 650 | 	node_t		 *sibling = (parent->first_child == node) ? parent->second_child
 651 | 														  : parent->first_child;
 652 | 
 653 | 	return (sibling && IS_EXTERNAL(sibling)) ? sibling : NULL;
 654 | }
 655 | 
 656 | static bool
 657 | is_sibling_internal(const node_t *node)
 658 | {
 659 | 	if (node == NULL || node->parent == NULL) {
 660 | 		return false;
 661 | 	}
 662 | 
 663 | 	node_t		 *parent  = node->parent;
 664 | 	const node_t *sibling = (parent->first_child == node) ? parent->second_child
 665 | 														  : parent->first_child;
 666 | 
 667 | 	return (sibling && IS_INTERNAL(sibling));
 668 | }
 669 | 
 670 | static node_t *
 671 | get_internal_sibling(node_t *node)
 672 | {
 673 | 	if (node == NULL || node->parent == NULL) {
 674 | 		return NULL;
 675 | 	}
 676 | 
 677 | 	node_t *parent	= node->parent;
 678 | 	node_t *sibling = (parent->first_child == node) ? parent->second_child
 679 | 													: parent->first_child;
 680 | 
 681 | 	return (sibling && IS_INTERNAL(sibling)) ? sibling : NULL;
 682 | }
 683 | 
 684 | node_t *
 685 | get_sibling(node_t *n)
 686 | {
 687 | 	if (n == NULL || n->parent == NULL) {
 688 | 		return NULL;
 689 | 	}
 690 | 	node_t *parent = n->parent;
 691 | 	node_t *sibling =
 692 | 		(parent->first_child == n) ? parent->second_child : parent->first_child;
 693 | 	return sibling;
 694 | }
 695 | 
 696 | static node_t *
 697 | get_sibling_by_type(node_t *node, node_type_t *type)
 698 | {
 699 | 	if (node == NULL || node->parent == NULL) {
 700 | 		return NULL;
 701 | 	}
 702 | 
 703 | 	node_t *parent	= node->parent;
 704 | 	node_t *sibling = (parent->first_child == node) ? parent->second_child
 705 | 													: parent->first_child;
 706 | 
 707 | 	switch (*type) {
 708 | 	case INTERNAL_NODE: {
 709 | 		return (sibling && IS_INTERNAL(sibling)) ? sibling : NULL;
 710 | 	}
 711 | 	case EXTERNAL_NODE: {
 712 | 		return (sibling && IS_EXTERNAL(sibling)) ? sibling : NULL;
 713 | 	}
 714 | 	case ROOT_NODE: break;
 715 | 	}
 716 | 	return NULL;
 717 | }
 718 | 
 719 | static bool
 720 | has_external_children(const node_t *parent)
 721 | {
 722 | 	return (parent->first_child && IS_EXTERNAL(parent->first_child)) &&
 723 | 		   (parent->second_child && IS_EXTERNAL(parent->second_child));
 724 | }
 725 | 
 726 | static node_t *
 727 | find_tree_root(node_t *node)
 728 | {
 729 | 	if (IS_ROOT(node)) {
 730 | 		return node;
 731 | 	}
 732 | 	return find_tree_root(node->parent);
 733 | }
 734 | 
 735 | static bool
 736 | has_single_external_child(const node_t *parent)
 737 | {
 738 | 	if (parent == NULL)
 739 | 		return false;
 740 | 
 741 | 	return ((parent->first_child && parent->second_child) &&
 742 | 			(IS_EXTERNAL(parent->first_child) &&
 743 | 			 !IS_EXTERNAL(parent->second_child))) ||
 744 | 		   ((parent->first_child && parent->second_child) &&
 745 | 			(IS_EXTERNAL(parent->second_child) &&
 746 | 			 !IS_EXTERNAL(parent->first_child)));
 747 | }
 748 | 
 749 | static client_t *
 750 | find_client_by_window_id(node_t *root, xcb_window_t win)
 751 | {
 752 | 	if (root == NULL)
 753 | 		return NULL;
 754 | 
 755 | 	if (root->client && root->client->window == win) {
 756 | 		return root->client;
 757 | 	}
 758 | 
 759 | 	node_t *l = find_node_by_window_id(root->first_child, win);
 760 | 	if (l == NULL)
 761 | 		return NULL;
 762 | 
 763 | 	if (l->client) {
 764 | 		return l->client;
 765 | 	}
 766 | 
 767 | 	node_t *r = find_node_by_window_id(root->second_child, win);
 768 | 	if (r == NULL)
 769 | 		return NULL;
 770 | 
 771 | 	if (r->client) {
 772 | 		return r->client;
 773 | 	}
 774 | 
 775 | 	return NULL;
 776 | }
 777 | 
 778 | /* apply_default_layout - applies the default tiling layout to a given tree
 779 |  *
 780 |  * recursively applies the default tiling layout to a node and its
 781 |  * descendants in the tree. The default layout splits nodes either
 782 |  * vertically or horizontally based on their dimensions. */
 783 | void
 784 | apply_default_layout(node_t *root)
 785 | {
 786 | 	if (root == NULL)
 787 | 		return;
 788 | 
 789 | 	if (root->first_child == NULL && root->second_child == NULL) {
 790 | 		return;
 791 | 	}
 792 | 
 793 | 	rectangle_t r, r2 = {0};
 794 | 	/* determine split orientation based on node dimensions */
 795 | 	if (root->rectangle.width >= root->rectangle.height) {
 796 | 		/* vertical split (side by side) */
 797 | 		r.x = root->rectangle.x;
 798 | 		r.y = root->rectangle.y;
 799 | 		r.width =
 800 | 			(root->rectangle.width - (conf.window_gap - conf.border_width)) / 2;
 801 | 		r.height = root->rectangle.height;
 802 | 		r2.x	 = (int16_t)(root->rectangle.x + r.width + conf.window_gap +
 803 | 						 conf.border_width);
 804 | 		r2.y	 = root->rectangle.y;
 805 | 		r2.width = root->rectangle.width - r.width - conf.window_gap -
 806 | 				   conf.border_width;
 807 | 		r2.height = root->rectangle.height;
 808 | 	} else {
 809 | 		/* horizontal split (top and bottom) */
 810 | 		r.x		= root->rectangle.x;
 811 | 		r.y		= root->rectangle.y;
 812 | 		r.width = root->rectangle.width;
 813 | 		r.height =
 814 | 			(root->rectangle.height - (conf.window_gap - conf.border_width)) /
 815 | 			2;
 816 | 		r2.x	  = root->rectangle.x;
 817 | 		r2.y	  = (int16_t)(root->rectangle.y + r.height + conf.window_gap +
 818 | 						  conf.border_width);
 819 | 		r2.width  = root->rectangle.width;
 820 | 		r2.height = root->rectangle.height - r.height - conf.window_gap -
 821 | 					conf.border_width;
 822 | 	}
 823 | 
 824 | 	/* this nested unreadable ternary code basically forces floating windows
 825 | 	 * to retain their floating rectangle and give the full parent's
 826 | 	 * rectangle to the other child. In some rare cases, this does not work
 827 | 	 * as expected , I am still looking into it */
 828 | 	if (root->first_child) {
 829 | 		root->first_child->rectangle =
 830 | 			((root->second_child->client) &&
 831 | 			 IS_FLOATING(root->second_child->client))
 832 | 				? root->rectangle
 833 | 			: ((root->first_child->client) &&
 834 | 			   IS_FLOATING(root->first_child->client))
 835 | 				? root->first_child->floating_rectangle
 836 | 				: r;
 837 | 		if (IS_INTERNAL(root->first_child)) {
 838 | 			apply_default_layout(root->first_child);
 839 | 		}
 840 | 	}
 841 | 
 842 | 	/* same as above */
 843 | 	if (root->second_child) {
 844 | 		root->second_child->rectangle =
 845 | 			((root->first_child->client) &&
 846 | 			 IS_FLOATING(root->first_child->client))
 847 | 				? root->rectangle
 848 | 			: ((root->second_child->client) &&
 849 | 			   IS_FLOATING(root->second_child->client))
 850 | 				? root->second_child->floating_rectangle
 851 | 				: r2;
 852 | 		if (IS_INTERNAL(root->second_child)) {
 853 | 			apply_default_layout(root->second_child);
 854 | 		}
 855 | 	}
 856 | }
 857 | 
 858 | static void
 859 | calculate_base_rect(rectangle_t *r, monitor_t *m)
 860 | {
 861 | 	uint16_t w = m->rectangle.width;
 862 | 	uint16_t h = m->rectangle.height;
 863 | 	uint16_t x = m->rectangle.x;
 864 | 	uint16_t y = m->rectangle.y;
 865 | 	if (wm->bar && m == prim_monitor) {
 866 | 		r->x	  = (int16_t)(x + conf.window_gap);
 867 | 		r->y	  = (int16_t)(y + wm->bar->rectangle.height + conf.window_gap);
 868 | 		r->width  = (uint16_t)(w - 2 * conf.window_gap - 2 * conf.border_width);
 869 | 		r->height = (uint16_t)(h - wm->bar->rectangle.height -
 870 | 							   2 * conf.window_gap - 2 * conf.border_width);
 871 | 	} else {
 872 | 		r->x	  = (int16_t)(x + conf.window_gap);
 873 | 		r->y	  = (int16_t)(y + conf.window_gap);
 874 | 		r->width  = (uint16_t)(w - 2 * conf.window_gap - 2 * conf.border_width);
 875 | 		r->height = (uint16_t)(h - 2 * conf.window_gap - 2 * conf.border_width);
 876 | 	}
 877 | }
 878 | 
 879 | /* default_layout - applies the default layout to the tree.
 880 |  *
 881 |  * initializes the default layout for the entire screen or
 882 |  * monitor. It sets up the initial rectangle for the root node with window
 883 |  * gaps and border widths in mind, then calls apply_default_layout to
 884 |  * recursively layout child nodes. */
 885 | static void
 886 | default_layout(node_t *root)
 887 | {
 888 | 	if (root == NULL)
 889 | 		return;
 890 | 	rectangle_t r = {0};
 891 | 	calculate_base_rect(&r, curr_monitor);
 892 | 	root->rectangle = r;
 893 | 	apply_default_layout(root);
 894 | }
 895 | 
 896 | /* apply_master_layout - applies the master layout to a tree.
 897 |  *
 898 |  * implements a master-stack layout, where one window (the master)
 899 |  * takes up a larger portion of the screen (70%), and the rest are stacked.
 900 |  * TODO: use next_node() to implement this
 901 |  */
 902 | void
 903 | apply_master_layout(node_t *parent)
 904 | {
 905 | 	if (parent == NULL)
 906 | 		return;
 907 | 
 908 | 	if (parent->first_child->is_master) {
 909 | 		parent->second_child->rectangle = parent->rectangle;
 910 | 	} else if (parent->second_child->is_master) {
 911 | 		parent->first_child->rectangle = parent->rectangle;
 912 | 	} else {
 913 | 		rectangle_t r, r2 = {0};
 914 | 		r.x		  = parent->rectangle.x;
 915 | 		r.y		  = parent->rectangle.y;
 916 | 		r.width	  = parent->rectangle.width;
 917 | 		r.height  = (uint16_t)((parent->rectangle.height -
 918 | 								(conf.window_gap - conf.border_width)) /
 919 | 							   2);
 920 | 
 921 | 		r2.x	  = parent->rectangle.x;
 922 | 		r2.y	  = (int16_t)(parent->rectangle.y + r.height + conf.window_gap +
 923 | 						  conf.border_width);
 924 | 		r2.width  = parent->rectangle.width;
 925 | 		r2.height = (uint16_t)(parent->rectangle.height - r.height -
 926 | 							   conf.window_gap - conf.border_width);
 927 | 		parent->first_child->rectangle	= r;
 928 | 		parent->second_child->rectangle = r2;
 929 | 	}
 930 | 
 931 | 	if (IS_INTERNAL(parent->first_child)) {
 932 | 		apply_master_layout(parent->first_child);
 933 | 	}
 934 | 
 935 | 	if (IS_INTERNAL(parent->second_child)) {
 936 | 		apply_master_layout(parent->second_child);
 937 | 	}
 938 | }
 939 | 
 940 | /* master_layout - initializes and applies the master layout to the tree.
 941 |  *
 942 |  * This func sets up the initial rectangles for the master and stack areas,
 943 |  * marks the appropriate node as the master, and then calls
 944 |  * apply_master_layout to recursively apply the layout to the entire tree.
 945 |  */
 946 | static void
 947 | master_layout(node_t *root, node_t *n)
 948 | {
 949 | 	const double   ratio		= 0.70;
 950 | 	const uint16_t w			= curr_monitor->rectangle.width;
 951 | 	const uint16_t h			= curr_monitor->rectangle.height;
 952 | 	const uint16_t x			= curr_monitor->rectangle.x;
 953 | 	const uint16_t y			= curr_monitor->rectangle.y;
 954 | 	const uint16_t master_width = (uint16_t)(w * ratio);
 955 | 	const uint16_t r_width		= (uint16_t)(w * (1 - ratio));
 956 | 	const uint16_t bar_height = wm->bar == NULL ? 0 : wm->bar->rectangle.height;
 957 | 
 958 | 	/* find a node to be master if not provided */
 959 | 	if (n == NULL) {
 960 | 		n = find_any_leaf(root);
 961 | 		if (n == NULL) {
 962 | 			return;
 963 | 		}
 964 | 	}
 965 | 
 966 | 	n->is_master		 = true;
 967 | 
 968 | 	/* master rectangle */
 969 | 	const rectangle_t r1 = {
 970 | 		.x		= (int16_t)(x + conf.window_gap),
 971 | 		.y		= (int16_t)(y + bar_height + conf.window_gap),
 972 | 		.width	= (uint16_t)(master_width - 2 * conf.window_gap),
 973 | 		.height = (uint16_t)(h - 2 * conf.window_gap - bar_height),
 974 | 	};
 975 | 
 976 | 	/* stack rectangle */
 977 | 	const rectangle_t r2 = {
 978 | 		.x		= (int16_t)(x + master_width),
 979 | 		.y		= (int16_t)(y + bar_height + conf.window_gap),
 980 | 		.width	= (uint16_t)(r_width - (1 * conf.window_gap)),
 981 | 		.height = (uint16_t)(h - 2 * conf.window_gap - bar_height),
 982 | 	};
 983 | 
 984 | 	/* if node is a root, give it full screen rectangle and ignore this
 985 | 	 * requests. Note, this happens when a user keeps deleting windows in a
 986 | 	 * master layout till single window is mapped, which is the root window
 987 | 	 */
 988 | 	if (n->node_type == ROOT_NODE && n->first_child == NULL &&
 989 | 		n->second_child == NULL) {
 990 | 		n->rectangle = (rectangle_t){
 991 | 			.x		= (int16_t)(x + conf.window_gap),
 992 | 			.y		= (int16_t)(y + bar_height + conf.window_gap),
 993 | 			.width	= (uint16_t)(w - 2 * conf.window_gap),
 994 | 			.height = (uint16_t)(h - 2 * conf.window_gap - bar_height),
 995 | 		};
 996 | 		return;
 997 | 	}
 998 | 
 999 | 	n->rectangle	= r1;
1000 | 	root->rectangle = r2;
1001 | 	apply_master_layout(root);
1002 | }
1003 | 
1004 | /* recursively traverses the tree and sets the is_master flag
1005 |  * to false for all nodes. It's typically called before applying a new
1006 |  * layout to ensure a clean slate. */
1007 | static void
1008 | master_clean_up(node_t *root)
1009 | {
1010 | 	if (root == NULL)
1011 | 		return;
1012 | 
1013 | 	if (root->is_master)
1014 | 		root->is_master = false;
1015 | 	master_clean_up(root->first_child);
1016 | 	master_clean_up(root->second_child);
1017 | }
1018 | 
1019 | /* apply_stack_layout - applies the stack layout to a given tree .
1020 |  *
1021 |  * recursively applies the stack layout to a node and its
1022 |  * children in the tree. In a stack layout, all windows occupy
1023 |  * the same space, effectively stacking on top of each other. */
1024 | void
1025 | apply_stack_layout(node_t *root)
1026 | {
1027 | 	if (root == NULL)
1028 | 		return;
1029 | 
1030 | 	if (root->first_child == NULL && root->second_child == NULL) {
1031 | 		return;
1032 | 	}
1033 | 
1034 | 	if (root->first_child) {
1035 | 		root->first_child->rectangle = root->rectangle;
1036 | 		if (IS_INTERNAL(root->first_child)) {
1037 | 			apply_stack_layout(root->first_child);
1038 | 		}
1039 | 	}
1040 | 
1041 | 	if (root->second_child) {
1042 | 		root->second_child->rectangle = root->rectangle;
1043 | 		if (IS_INTERNAL(root->second_child)) {
1044 | 			apply_stack_layout(root->second_child);
1045 | 		}
1046 | 	}
1047 | }
1048 | 
1049 | /**
1050 |  * stack_layout - initializes and applies the stack layout to the tree.
1051 |  *
1052 |  * sets up the initial rectangle for the entire stack.
1053 |  * It then calls apply_stack_layout to recursively apply the layout
1054 |  * to all nodes in the tree. */
1055 | static void
1056 | stack_layout(node_t *root)
1057 | {
1058 | 	rectangle_t r = {0};
1059 | 	calculate_base_rect(&r, curr_monitor);
1060 | 	root->rectangle = r;
1061 | 	apply_stack_layout(root);
1062 | }
1063 | 
1064 | // void grid_layout(node_t *root) {
1065 | // }
1066 | 
1067 | /* apply_layout - applies the specified layout to the given tree.
1068 |  *
1069 |  * responsible for switching between different layout
1070 |  * types (DEFAULT, MASTER, STACK) and applying the chosen layout
1071 |  * to the desktop's tree. */
1072 | void
1073 | apply_layout(desktop_t *d, layout_t t)
1074 | {
1075 | 	d->layout	 = t;
1076 | 	node_t *root = d->tree;
1077 | 	master_clean_up(root);
1078 | 	switch (t) {
1079 | 	case DEFAULT: {
1080 | 		default_layout(root);
1081 | 		break;
1082 | 	}
1083 | 	case MASTER: {
1084 | 		xcb_window_t win =
1085 | 			get_window_under_cursor(wm->connection, wm->root_window);
1086 | 		if (win == XCB_NONE || win == wm->root_window) {
1087 | 			return;
1088 | 		}
1089 | 		node_t *n = find_node_by_window_id(root, win);
1090 | 		if (n == NULL) {
1091 | 			return;
1092 | 		}
1093 | 		master_layout(root, n);
1094 | 		break;
1095 | 	}
1096 | 	case STACK: {
1097 | 		xcb_window_t win =
1098 | 			get_window_under_cursor(wm->connection, wm->root_window);
1099 | 
1100 | 		if (win == XCB_NONE || win == wm->root_window) {
1101 | 			return;
1102 | 		}
1103 | 		node_t *n = find_node_by_window_id(root, win);
1104 | 		if (n == NULL) {
1105 | 			return;
1106 | 		}
1107 | 		stack_layout(root);
1108 | 		set_focus(n, true);
1109 | 		break;
1110 | 	}
1111 | 	case GRID: {
1112 | 		break;
1113 | 	}
1114 | 	}
1115 | }
1116 | 
1117 | static int
1118 | delete_node_with_external_sibling(node_t *node)
1119 | {
1120 | 	/* node to delete = N, internal node = I, external node = E
1121 | 	 *         I
1122 | 	 *    	 /   \
1123 | 	 *     N||E   N||E
1124 | 	 *
1125 | 	 * logic:
1126 | 	 * just delete N and replace E with I and give it full I's
1127 | 	 * rectangle
1128 | 	 */
1129 | 	node_t *external_node = NULL;
1130 | 	assert(is_sibling_external(node));
1131 | 	external_node = get_external_sibling(node);
1132 | 
1133 | 	if (external_node == NULL) {
1134 | 		_LOG_(ERROR, "external node is null");
1135 | 		return -1;
1136 | 	}
1137 | 
1138 | 	/* if 'I' has no parent */
1139 | 	if (node->parent->parent == NULL) {
1140 | 		node->parent->node_type	   = ROOT_NODE;
1141 | 		node->parent->client	   = external_node->client;
1142 | 		node->parent->first_child  = NULL;
1143 | 		node->parent->second_child = NULL;
1144 | 	} else {
1145 | 		/* if 'I' has a parent */
1146 | 		/*
1147 | 		 *         I
1148 | 		 *    	 /   \
1149 | 		 *   	E     I
1150 | 		 *    	 	/   \
1151 | 		 *   	   N     E
1152 | 		 */
1153 | 		node_t *grandparent = node->parent->parent;
1154 | 		if (grandparent->first_child == node->parent) {
1155 | 			grandparent->first_child->node_type	   = EXTERNAL_NODE;
1156 | 			grandparent->first_child->client	   = external_node->client;
1157 | 			grandparent->first_child->first_child  = NULL;
1158 | 			grandparent->first_child->second_child = NULL;
1159 | 		} else {
1160 | 			grandparent->second_child->node_type	= EXTERNAL_NODE;
1161 | 			grandparent->second_child->client		= external_node->client;
1162 | 			grandparent->second_child->first_child	= NULL;
1163 | 			grandparent->second_child->second_child = NULL;
1164 | 		}
1165 | 	}
1166 | 	_FREE_(external_node);
1167 | 	_FREE_(node->client);
1168 | 	_FREE_(node);
1169 | 	return 0;
1170 | }
1171 | 
1172 | static int
1173 | delete_node_with_internal_sibling(node_t *node, desktop_t *d)
1174 | {
1175 | 	if (d == NULL) {
1176 | 		return -1;
1177 | 	}
1178 | 	/* node to delete = N
1179 | 	 * internal node (parent of N) = IN
1180 | 	 * external node 1 = E1, external node 2 = E2
1181 | 	 * internal node (parent of Es) = IE
1182 | 	 *             IN
1183 | 	 *       	 /   \
1184 | 	 *          N     IE
1185 | 	 *                / \
1186 | 	 *              E1   E2
1187 | 	 *
1188 | 	 * logic: IN->IE = NULL, IN->N = NULL then link IN with E1,E2.
1189 | 	 * lastly unlink IE->IN, IE->E1, IE->E2, N->IN and free N & IE
1190 | 	 */
1191 | 	node_t *internal_sibling = NULL;
1192 | 	/* if IN has no parent */
1193 | 	if (node->parent->parent == NULL) {
1194 | 		if (is_sibling_internal(node)) {
1195 | 			internal_sibling = get_internal_sibling(node);
1196 | 		}
1197 | 
1198 | 		if (internal_sibling == NULL) {
1199 | 			_LOG_(ERROR, "internal node is null");
1200 | 			return -1;
1201 | 		}
1202 | 
1203 | 		internal_sibling->rectangle = node->parent->rectangle;
1204 | 		internal_sibling->parent	= NULL;
1205 | 		internal_sibling->node_type = ROOT_NODE;
1206 | 		if (d->tree == node->parent) {
1207 | 			node->parent = NULL;
1208 | 			if (d->tree->first_child == node) {
1209 | 				d->tree->first_child = internal_sibling->first_child;
1210 | 				internal_sibling->first_child->parent = d->tree;
1211 | 				d->tree->second_child = internal_sibling->second_child;
1212 | 				internal_sibling->second_child->parent = d->tree;
1213 | 			} else {
1214 | 				d->tree->second_child = internal_sibling->first_child;
1215 | 				internal_sibling->first_child->parent = d->tree;
1216 | 				d->tree->first_child = internal_sibling->second_child;
1217 | 				internal_sibling->second_child->parent = d->tree;
1218 | 			}
1219 | 		}
1220 | 
1221 | 		if (d->layout == DEFAULT) {
1222 | 			apply_default_layout(d->tree);
1223 | 		} else if (d->layout == STACK) {
1224 | 			apply_stack_layout(d->tree);
1225 | 		}
1226 | 
1227 | 	} else {
1228 | 		/* if IN has a parent */
1229 | 		/*            ...
1230 | 		 *              \
1231 | 		 *              IN
1232 | 		 *       	  /   \
1233 | 		 *           N     IE
1234 | 		 *                 / \
1235 | 		 *               E1   E2
1236 | 		 */
1237 | 		if (is_sibling_internal(node)) {
1238 | 			internal_sibling = get_internal_sibling(node);
1239 | 		} else {
1240 | 			_LOG_(ERROR, "internal node is null");
1241 | 			return -1;
1242 | 		}
1243 | 		if (internal_sibling == NULL) {
1244 | 			_LOG_(ERROR, "internal node is null");
1245 | 			return -1;
1246 | 		}
1247 | 		internal_sibling->parent = NULL;
1248 | 		if (node->parent->first_child == node) {
1249 | 			node->parent->first_child = internal_sibling->first_child;
1250 | 			internal_sibling->first_child->parent = node->parent;
1251 | 			node->parent->second_child = internal_sibling->second_child;
1252 | 			internal_sibling->second_child->parent = node->parent;
1253 | 		} else {
1254 | 			node->parent->second_child = internal_sibling->first_child;
1255 | 			internal_sibling->first_child->parent = node->parent;
1256 | 			node->parent->first_child = internal_sibling->second_child;
1257 | 			internal_sibling->second_child->parent = node->parent;
1258 | 		}
1259 | 		resize_subtree(node->parent);
1260 | 		if (d->layout == DEFAULT) {
1261 | 			apply_default_layout(node->parent);
1262 | 		} else if (d->layout == STACK) {
1263 | 			apply_stack_layout(node->parent);
1264 | 		}
1265 | 	}
1266 | 
1267 | 	_FREE_(internal_sibling);
1268 | 	_FREE_(node->client);
1269 | 	_FREE_(node);
1270 | 	return 0;
1271 | }
1272 | 
1273 | static void
1274 | delete_floating_node(node_t *node, desktop_t *d)
1275 | {
1276 | 	if (node == NULL || node->client == NULL || d == NULL) {
1277 | 		_LOG_(ERROR, "node to be deleted is null");
1278 | 		return;
1279 | 	}
1280 | 
1281 | 	assert(node->client->state == FLOATING);
1282 | #ifdef _DEBUG__
1283 | 	_LOG_(DEBUG, "DELETE floating window %d", node->client->window);
1284 | #endif
1285 | 	node_t *p = node->parent;
1286 | 	if (p->first_child == node) {
1287 | 		p->first_child = NULL;
1288 | 	} else {
1289 | 		p->second_child = NULL;
1290 | 	}
1291 | 	node->parent = NULL;
1292 | 	_FREE_(node->client);
1293 | 	_FREE_(node);
1294 | 	assert(p->first_child == NULL);
1295 | 	assert(p->second_child == NULL);
1296 | #ifdef _DEBUG__
1297 | 	_LOG_(DEBUG, "DELETE floating window success");
1298 | #endif
1299 | 	d->n_count -= 1;
1300 | }
1301 | 
1302 | /* delete_node - removes a node (and its client) from the tree.
1303 |  *
1304 |  * - It unlinks the node from the tree using `unlink_node`.
1305 |  * - Frees the memory for the node and its client.
1306 |  * - Updates the desktop's node count.
1307 |  * - Rearranges the tree if it’s not empty after deletion.
1308 |  *
1309 |  * checks for invalid or edge cases:
1310 |  * - If the node or its client is null.
1311 |  * - If the node isn’t an external node.
1312 |  * - If the parent of the node is null (but not for the root).
1313 |  *
1314 |  * TODO: Implement deletion logic for `MASTER` and `STACK` layouts.*/
1315 | void
1316 | delete_node(node_t *node, desktop_t *d)
1317 | {
1318 | 	if (node == NULL || node->client == NULL || d->tree == NULL) {
1319 | 		_LOG_(ERROR, "node to be deleted is null");
1320 | 		return;
1321 | 	}
1322 | 	/*bool swap = node == d->node;*/
1323 | 	if (IS_INTERNAL(node)) {
1324 | 		_LOG_(ERROR,
1325 | 			  "node to be deleted is not an external node type: %d",
1326 | 			  node->node_type);
1327 | 		return;
1328 | 	}
1329 | 
1330 | 	if (is_parent_null(node) && node != d->tree) {
1331 | 		_LOG_(ERROR, "parent of node is null");
1332 | 		return;
1333 | 	}
1334 | 
1335 | 	bool check = false;
1336 | 	if (node == d->tree) {
1337 | 		check = true;
1338 | 	}
1339 | 
1340 | 	/*node_t *n = prev_node(node);
1341 | 	if (!n) {
1342 | 		n = next_node(node);
1343 | 	}*/
1344 | 
1345 | 	if (!unlink_node(node, d)) {
1346 | 		_LOG_(ERROR, "could not unlink node.. abort");
1347 | 		return;
1348 | 	}
1349 | 
1350 | 	if (check) {
1351 | 		assert(!d->tree);
1352 | 		/*d->node = NULL;*/
1353 | 	}
1354 | 
1355 | 	_FREE_(node->client);
1356 | 	_FREE_(node);
1357 | 
1358 | 	/*if (!check) {
1359 | 		d->node = n;
1360 | 	}*/
1361 | 
1362 | 	d->n_count -= 1;
1363 | 	if (!is_tree_empty(d->tree)) {
1364 | 		arrange_tree(d->tree, d->layout);
1365 | 	}
1366 | }
1367 | 
1368 | static bool
1369 | has_first_child(const node_t *parent)
1370 | {
1371 | 	return parent->first_child;
1372 | }
1373 | 
1374 | static bool
1375 | has_second_child(const node_t *parent)
1376 | {
1377 | 	return parent->second_child;
1378 | }
1379 | 
1380 | bool
1381 | is_tree_empty(const node_t *root)
1382 | {
1383 | 	return root == NULL;
1384 | }
1385 | 
1386 | static bool
1387 | is_parent_null(const node_t *node)
1388 | {
1389 | 	return node->parent == NULL;
1390 | }
1391 | 
1392 | static bool
1393 | is_parent_internal(const node_t *node)
1394 | {
1395 | 	return node->parent->node_type == INTERNAL_NODE;
1396 | }
1397 | 
1398 | void
1399 | log_tree_nodes(node_t *node)
1400 | {
1401 | 	if (!node) {
1402 | 		return;
1403 | 	}
1404 | 
1405 | 	if (node->client) {
1406 | 		xcb_icccm_get_text_property_reply_t t_reply;
1407 | 		xcb_get_property_cookie_t			cn =
1408 | 			xcb_icccm_get_wm_name(wm->connection, node->client->window);
1409 | 		uint8_t wr =
1410 | 			xcb_icccm_get_wm_name_reply(wm->connection, cn, &t_reply, NULL);
1411 | 		char name[256];
1412 | 		if (wr == 1) {
1413 | 			snprintf(name, sizeof(name), "%s", t_reply.name);
1414 | 			xcb_icccm_get_text_property_reply_wipe(&t_reply);
1415 | 		}
1416 | 		_LOG_(DEBUG,
1417 | 			  "node Type: %d, client Window ID: %u, name: %s, "
1418 | 			  "is_focused %s",
1419 | 			  node->node_type,
1420 | 			  node->client->window,
1421 | 			  name,
1422 | 			  node->is_focused ? "true" : "false");
1423 | 	} else {
1424 | 		_LOG_(DEBUG, "node Type: %d", node->node_type);
1425 | 	}
1426 | 
1427 | 	log_tree_nodes(node->first_child);
1428 | 	log_tree_nodes(node->second_child);
1429 | }
1430 | 
1431 | int
1432 | hide_windows(node_t *cn)
1433 | {
1434 | 	if (cn == NULL)
1435 | 		return 0;
1436 | 
1437 | 	if (!IS_INTERNAL(cn) && cn->client) {
1438 | 		if (set_visibility(cn->client->window, false) != 0) {
1439 | 			return -1;
1440 | 		}
1441 | 
1442 | 		if (set_focus(cn, false) != 0) {
1443 | 			return -1;
1444 | 		}
1445 | 
1446 | 		if (!conf.focus_follow_pointer) {
1447 | 			window_grab_buttons(cn->client->window);
1448 | 		}
1449 | 	}
1450 | 
1451 | 	hide_windows(cn->first_child);
1452 | 	hide_windows(cn->second_child);
1453 | 
1454 | 	return 0;
1455 | }
1456 | 
1457 | int
1458 | show_windows(node_t *cn)
1459 | {
1460 | 	if (cn == NULL)
1461 | 		return 0;
1462 | 
1463 | 	if (!IS_INTERNAL(cn) && cn->client) {
1464 | 		if (set_visibility(cn->client->window, true) != 0) {
1465 | 			return -1;
1466 | 		}
1467 | 	}
1468 | 
1469 | 	show_windows(cn->first_child);
1470 | 	show_windows(cn->second_child);
1471 | 
1472 | 	return 0;
1473 | }
1474 | 
1475 | bool
1476 | client_exist(node_t *cn, xcb_window_t win)
1477 | {
1478 | 	if (cn == NULL)
1479 | 		return false;
1480 | 
1481 | 	if (cn->client) {
1482 | 		if (cn->client->window == win) {
1483 | 			return true;
1484 | 		}
1485 | 	}
1486 | 
1487 | 	if (client_exist(cn->first_child, win)) {
1488 | 		return true;
1489 | 	}
1490 | 
1491 | 	if (client_exist(cn->second_child, win)) {
1492 | 		return true;
1493 | 	}
1494 | 
1495 | 	return false;
1496 | }
1497 | 
1498 | static bool
1499 | in_left_subtree(node_t *lc, node_t *n)
1500 | {
1501 | 	if (lc == NULL)
1502 | 		return false;
1503 | 
1504 | 	if (lc == n || lc->first_child == n || lc->second_child == n) {
1505 | 		return true;
1506 | 	}
1507 | 
1508 | 	if (in_left_subtree(lc->first_child, n)) {
1509 | 		return true;
1510 | 	}
1511 | 
1512 | 	if (in_left_subtree(lc->second_child, n)) {
1513 | 		return true;
1514 | 	}
1515 | 
1516 | 	return false;
1517 | }
1518 | 
1519 | static bool
1520 | in_right_subtree(node_t *rc, node_t *n)
1521 | {
1522 | 	if (rc == NULL)
1523 | 		return false;
1524 | 
1525 | 	if (rc == n || rc->first_child == n || rc->second_child == n) {
1526 | 		return true;
1527 | 	}
1528 | 
1529 | 	if (in_right_subtree(rc->first_child, n)) {
1530 | 		return true;
1531 | 	}
1532 | 
1533 | 	if (in_right_subtree(rc->second_child, n)) {
1534 | 		return true;
1535 | 	}
1536 | 
1537 | 	return false;
1538 | }
1539 | 
1540 | void
1541 | dynamic_resize(node_t *n, resize_t t)
1542 | {
1543 | 	const int16_t step = 5;
1544 | 	if (n == NULL || n->parent == NULL || IS_ROOT(n)) {
1545 | 		return;
1546 | 	}
1547 | 
1548 | 	/* get the sibling node */
1549 | 	node_t *s = (n->parent->first_child == n) ? n->parent->second_child
1550 | 											  : n->parent->first_child;
1551 | 	if (s == NULL) {
1552 | 		return;
1553 | 	}
1554 | 
1555 | 	rectangle_t *nr = &n->rectangle;
1556 | 	rectangle_t *sr = &s->rectangle;
1557 | 
1558 | 	/* find the split orientation dynamically */
1559 | 	bool		 vs = (nr->x == sr->x); /* nodes are stacked vertically */
1560 | 	bool		 hs = (nr->y == sr->y); /* nodes are side-by-side */
1561 | 
1562 | 	if (vs) {
1563 | 		/* vertical resize */
1564 | 		bool up = (nr->y < sr->y); /* `n` is above `s`? */
1565 | 
1566 | 		if (t == GROW) {
1567 | 			if (up) {
1568 | 				if (sr->height > step) {
1569 | 					nr->height += step;
1570 | 					sr->y += step;
1571 | 					sr->height -= step;
1572 | 				}
1573 | 			} else {
1574 | 				if (sr->height > step) {
1575 | 					nr->height += step;
1576 | 					nr->y -= step;
1577 | 					sr->height -= step;
1578 | 				}
1579 | 			}
1580 | 		} else { /* SHRINK */
1581 | 			if (nr->height > step) {
1582 | 				nr->height -= step;
1583 | 				if (up) {
1584 | 					sr->y -= step;
1585 | 				} else {
1586 | 					nr->y += step;
1587 | 				}
1588 | 				sr->height += step;
1589 | 			}
1590 | 		}
1591 | 	} else if (hs) {
1592 | 		/* horizontal resize */
1593 | 		bool left = (nr->x < sr->x); /* `n` is left of `s`? */
1594 | 		if (t == GROW) {
1595 | 			if (left) {
1596 | 				if (sr->width > step) {
1597 | 					nr->width += step;
1598 | 					sr->x += step;
1599 | 					sr->width -= step;
1600 | 				}
1601 | 			} else {
1602 | 				if (sr->width > step) {
1603 | 					nr->width += step;
1604 | 					nr->x -= step;
1605 | 					sr->width -= step;
1606 | 				}
1607 | 			}
1608 | 		} else { /* SHRINK */
1609 | 			if (nr->width > step) {
1610 | 				nr->width -= step;
1611 | 				if (left) {
1612 | 					sr->x -= step;
1613 | 				} else {
1614 | 					nr->x += step;
1615 | 				}
1616 | 				sr->width += step;
1617 | 			}
1618 | 		}
1619 | 	}
1620 | 	if (IS_INTERNAL(s)) {
1621 | 		resize_subtree(s);
1622 | 	}
1623 | }
1624 | 
1625 | node_t *
1626 | find_left_leaf(node_t *root)
1627 | {
1628 | 	if (root == NULL)
1629 | 		return NULL;
1630 | 
1631 | 	if ((root->node_type != INTERNAL_NODE || root->parent == NULL) &&
1632 | 		root->client) {
1633 | 		return root;
1634 | 	}
1635 | 
1636 | 	node_t *left_leaf = find_left_leaf(root->first_child);
1637 | 	if ((left_leaf && left_leaf->client) &&
1638 | 		(IS_EXTERNAL(left_leaf) || IS_ROOT(left_leaf))) {
1639 | 		return left_leaf;
1640 | 	}
1641 | 
1642 | 	return find_left_leaf(root->second_child);
1643 | }
1644 | 
1645 | node_t *
1646 | find_any_leaf(node_t *root)
1647 | {
1648 | 	if (root == NULL)
1649 | 		return NULL;
1650 | 
1651 | 	if ((root->node_type != INTERNAL_NODE || root->parent == NULL) &&
1652 | 		root->client && !IS_FLOATING(root->client)) {
1653 | 		return root;
1654 | 	}
1655 | 
1656 | 	node_t *f = find_any_leaf(root->first_child);
1657 | 	if (f && f->client && !IS_FLOATING(f->client)) {
1658 | 		return f;
1659 | 	}
1660 | 
1661 | 	node_t *s = find_any_leaf(root->second_child);
1662 | 	if (s && s->client && !IS_FLOATING(s->client)) {
1663 | 		return s;
1664 | 	}
1665 | 
1666 | 	return NULL;
1667 | }
1668 | 
1669 | /* unlink_node - removes a node from the tree while keeping the structure
1670 |  * intact.
1671 |  *
1672 |  * disconnects a node from the tree without freeing its
1673 |  * memory. It tweaks the parent and sibling relationships to keep the tree
1674 |  * intact.
1675 |  *
1676 |  * Note: this function does not free the memory of the unlinked node.
1677 |  * The caller is responsible for freeing the memory of the unlinked node if
1678 |  * it's no longer needed.
1679 |  */
1680 | bool
1681 | unlink_node(node_t *n, desktop_t *d)
1682 | {
1683 | 	if (d == NULL || n == NULL) {
1684 | 		return false;
1685 | 	}
1686 | 
1687 | 	/* If the node `n` is the root, the tree becomes NULL */
1688 | 	if (is_parent_null(n)) {
1689 | 		d->tree = NULL;
1690 | 		return true;
1691 | 	}
1692 | 
1693 | 	node_t *parent	= n->parent;
1694 | 	node_t *sibling = NULL;
1695 | 	if ((sibling = get_sibling(n)) == NULL) {
1696 | 		_LOG_(ERROR, "could not get sibling of n");
1697 | 		return false;
1698 | 	}
1699 | 
1700 | 	node_t *grandparent = parent->parent;
1701 | 
1702 | 	sibling->parent		= grandparent;
1703 | 	if (grandparent) {
1704 | 		if (grandparent->first_child == parent) {
1705 | 			grandparent->first_child = sibling;
1706 | 		} else {
1707 | 			grandparent->second_child = sibling;
1708 | 		}
1709 | 	} else {
1710 | 		sibling->node_type = ROOT_NODE;
1711 | 		d->tree			   = sibling;
1712 | 	}
1713 | 
1714 | 	parent->second_child = NULL;
1715 | 	parent->first_child	 = NULL;
1716 | 	_FREE_(parent);
1717 | 	n->parent = NULL;
1718 | 	return true;
1719 | }
1720 | 
1721 | /* transfer_node - moves a node to a new desktop's tree.
1722 |  *
1723 |  * takes a node and places it into the tree of the target desktop.
1724 |  * It handles three main scenarios:
1725 |  * 1. If the target tree is empty:
1726 |  *   - The node becomes the root of the tree.
1727 |  * 2. If the tree has just one node:
1728 |  *   - Splits the root into two external nodes under a new internal root.
1729 |  * 3. Otherwise:
1730 |  *   - Finds a spot in the tree (a leaf), converts it into an internal node,
1731 |  *		and then insert the node in there.
1732 |  * Note:
1733 |  * - Doesn't touch visibility or focus; that's handled outside. */
1734 | bool
1735 | transfer_node(node_t *node, desktop_t *d)
1736 | {
1737 | 	if (node == NULL || d == NULL) {
1738 | 		return false;
1739 | 	}
1740 | 
1741 | 	if (node->client == NULL) {
1742 | 		return false;
1743 | 	}
1744 | 
1745 | 	assert(node->parent == NULL);
1746 | 
1747 | 	if (is_tree_empty(d->tree)) {
1748 | 		rectangle_t r = {0};
1749 | 		calculate_base_rect(&r, curr_monitor);
1750 | 		node->node_type	   = ROOT_NODE;
1751 | 		d->tree			   = node;
1752 | 		d->tree->rectangle = r;
1753 | 		d->tree->node_type = ROOT_NODE;
1754 | 	} else if (d->tree->first_child == NULL && d->tree->second_child == NULL) {
1755 | 		client_t *c = d->tree->client;
1756 | 		if ((d->tree->first_child = create_node(c)) == NULL) {
1757 | 			return false;
1758 | 		}
1759 | 		d->tree->first_child->node_type	 = EXTERNAL_NODE;
1760 | 		d->tree->second_child			 = node;
1761 | 		d->tree->second_child->node_type = EXTERNAL_NODE;
1762 | 		d->tree->client					 = NULL;
1763 | 		d->tree->first_child->parent = d->tree->second_child->parent = d->tree;
1764 | 	} else {
1765 | 		node_t *leaf = find_any_leaf(d->tree);
1766 | 		if (leaf == NULL) {
1767 | 			return false;
1768 | 		}
1769 | 		if (!IS_ROOT(leaf)) {
1770 | 			leaf->node_type = INTERNAL_NODE;
1771 | 		}
1772 | 		if ((leaf->first_child = create_node(leaf->client)) == NULL) {
1773 | 			return false;
1774 | 		}
1775 | 		leaf->first_child->parent	 = leaf;
1776 | 		leaf->first_child->node_type = EXTERNAL_NODE;
1777 | 		leaf->client				 = NULL;
1778 | 		leaf->second_child			 = node;
1779 | 		if (leaf->second_child == NULL) {
1780 | 			return false;
1781 | 		}
1782 | 		leaf->second_child->parent	  = leaf;
1783 | 		leaf->second_child->node_type = EXTERNAL_NODE;
1784 | 	}
1785 | 	return true;
1786 | }
1787 | 
1788 | bool
1789 | has_floating_window(node_t *root)
1790 | {
1791 | 	if (root == NULL)
1792 | 		return false;
1793 | 
1794 | 	if (root->client && IS_FLOATING(root->client)) {
1795 | 		return true;
1796 | 	}
1797 | 
1798 | 	if (has_floating_window(root->first_child)) {
1799 | 		return true;
1800 | 	}
1801 | 
1802 | 	if (has_floating_window(root->second_child)) {
1803 | 		return true;
1804 | 	}
1805 | 
1806 | 	return false;
1807 | }
1808 | 
1809 | /* next_node - get the next external node in the tree, starting from the
1810 |  * given node. It is used to traverse nodes in stack layout */
1811 | node_t *
1812 | next_node(node_t *n)
1813 | {
1814 | 	if (n == NULL)
1815 | 		return NULL;
1816 | 
1817 | 	if (n->parent && n->parent->second_child != n) {
1818 | 		node_t *l = n->parent->second_child;
1819 | 		while (!IS_EXTERNAL(l)) {
1820 | 			l = l->first_child;
1821 | 		}
1822 | 		return l;
1823 | 	}
1824 | 
1825 | 	node_t *c = n;
1826 | 	node_t *p = c->parent;
1827 | 	while (p && p->second_child == c) {
1828 | 		c = p;
1829 | 		p = c->parent;
1830 | 	}
1831 | 
1832 | 	if (p == NULL)
1833 | 		return NULL;
1834 | 
1835 | 	node_t *r = p->second_child;
1836 | 	while (!IS_EXTERNAL(r)) {
1837 | 		r = r->first_child;
1838 | 	}
1839 | 	return r;
1840 | }
1841 | 
1842 | /* prev_node - get the previous external node in the tree, starting from the
1843 |  * given node. It is used to traverse nodes in stack layout */
1844 | node_t *
1845 | prev_node(node_t *n)
1846 | {
1847 | 	if (n == NULL)
1848 | 		return NULL;
1849 | 
1850 | 	if (n->parent && n->parent->first_child != n) {
1851 | 		node_t *l = n->parent->first_child;
1852 | 		while (!IS_EXTERNAL(l)) {
1853 | 			if (l->second_child) {
1854 | 				l = l->second_child;
1855 | 			} else {
1856 | 				l = l->first_child;
1857 | 			}
1858 | 		}
1859 | 		return l;
1860 | 	}
1861 | 
1862 | 	node_t *c = n;
1863 | 	node_t *p = c->parent;
1864 | 	while (p && p->first_child == c) {
1865 | 		c = p;
1866 | 		p = c->parent;
1867 | 	}
1868 | 
1869 | 	if (p == NULL)
1870 | 		return NULL;
1871 | 
1872 | 	node_t *l = p->first_child;
1873 | 	while (!IS_EXTERNAL(l)) {
1874 | 		if (l->second_child) {
1875 | 			l = l->second_child;
1876 | 		} else {
1877 | 			l = l->first_child;
1878 | 		}
1879 | 	}
1880 | 	return l;
1881 | }
1882 | 
1883 | /* flip_node - flips the node's orientation within its parent.
1884 |  * It only works if the node has a parent and a sibling. */
1885 | void
1886 | flip_node(node_t *node)
1887 | {
1888 | 	if (node->parent == NULL) {
1889 | 		return;
1890 | 	}
1891 | 	bool	vflip = (node->rectangle.width >= node->rectangle.height);
1892 | 	node_t *p	  = node->parent;
1893 | 	node_t *s	  = (p->first_child == node) ? p->second_child : p->first_child;
1894 | 	if (s == NULL)
1895 | 		return;
1896 | 	rectangle_t *nr = &node->rectangle;
1897 | 	rectangle_t *sr = &s->rectangle;
1898 | 	rectangle_t	 pr = p->rectangle;
1899 | 	nr->x			= pr.x;
1900 | 	nr->y			= pr.y;
1901 | 	if (vflip) {
1902 | 		nr->width  = (pr.width - conf.window_gap) / 2;
1903 | 		nr->height = pr.height;
1904 | 		sr->x	   = pr.x + nr->width + conf.window_gap;
1905 | 		sr->y	   = pr.y;
1906 | 		sr->width  = pr.width - nr->width - conf.window_gap;
1907 | 		sr->height = pr.height;
1908 | 	} else {
1909 | 		nr->width  = pr.width;
1910 | 		nr->height = (pr.height - conf.window_gap) / 2;
1911 | 		sr->x	   = pr.x;
1912 | 		sr->y	   = pr.y + nr->height + conf.window_gap;
1913 | 		sr->width  = pr.width;
1914 | 		sr->height = pr.height - nr->height - conf.window_gap;
1915 | 	}
1916 | 
1917 | 	if (IS_INTERNAL(s)) {
1918 | 		resize_subtree(s);
1919 | 	}
1920 | }
1921 | 
1922 | void
1923 | update_focus(node_t *root, node_t *n)
1924 | {
1925 | 	if (root == NULL)
1926 | 		return;
1927 | 
1928 | 	bool flag = !IS_INTERNAL(root) && root->client;
1929 | 	if (flag && root != n) {
1930 | 		set_focus(root, false);
1931 | 		if (!conf.focus_follow_pointer)
1932 | 			window_grab_buttons(root->client->window);
1933 | 		root->is_focused = false;
1934 | 	}
1935 | 	update_focus(root->first_child, n);
1936 | 	update_focus(root->second_child, n);
1937 | }
1938 | 
1939 | void
1940 | update_focus_all(node_t *root)
1941 | {
1942 | 	if (root == NULL)
1943 | 		return;
1944 | 
1945 | 	bool flag = !IS_INTERNAL(root) && root->client;
1946 | 	if (flag) {
1947 | 		set_focus(root, false);
1948 | 		if (!conf.focus_follow_pointer)
1949 | 			window_grab_buttons(root->client->window);
1950 | 		root->is_focused = false;
1951 | 	}
1952 | 	update_focus_all(root->first_child);
1953 | 	update_focus_all(root->second_child);
1954 | }
1955 | 
1956 | node_t *
1957 | get_focused_node(node_t *n)
1958 | {
1959 | 	if (n == NULL)
1960 | 		return NULL;
1961 | 	if (!IS_INTERNAL(n) && n->client && n->is_focused) {
1962 | 		return n;
1963 | 	}
1964 | 	node_t *l = get_focused_node(n->first_child);
1965 | 	if (l) {
1966 | 		return l;
1967 | 	}
1968 | 	node_t *s = get_focused_node(n->second_child);
1969 | 	if (s) {
1970 | 		return s;
1971 | 	}
1972 | 	return NULL;
1973 | }
1974 | 
1975 | /* swap_node - swap the positions of two nodes */
1976 | int
1977 | swap_node(node_t *n)
1978 | {
1979 | 	if (n->parent == NULL)
1980 | 		return -1;
1981 | 
1982 | 	node_t	   *p  = n->parent;
1983 | 	node_t	   *s  = (p->first_child == n) ? p->second_child : p->first_child;
1984 | 	rectangle_t sr = s->rectangle;
1985 | 	rectangle_t nr = n->rectangle;
1986 | 
1987 | 	if (p->first_child == n) {
1988 | 		p->first_child	= s;
1989 | 		p->second_child = n;
1990 | 	} else {
1991 | 		p->first_child	= n;
1992 | 		p->second_child = s;
1993 | 	}
1994 | 
1995 | 	n->rectangle = sr;
1996 | 	s->rectangle = nr;
1997 | 
1998 | 	if (IS_INTERNAL(s)) {
1999 | 		resize_subtree(s);
2000 | 	}
2001 | 	return 0;
2002 | }
2003 | 
2004 | /* is_within_range - checks if one rectangle is within a certain range
2005 |  * of another rectangle */
2006 | static bool
2007 | is_within_range(rectangle_t *rect1, rectangle_t *rect2, direction_t d)
2008 | {
2009 | 	switch (d) {
2010 | 	case LEFT:
2011 | 		return rect2->x + rect2->width <= rect1->x &&
2012 | 			   rect1->y < rect2->y + rect2->height &&
2013 | 			   rect1->y + rect1->height > rect2->y;
2014 | 	case RIGHT:
2015 | 		return rect2->x >= rect1->x + rect1->width &&
2016 | 			   rect1->y < rect2->y + rect2->height &&
2017 | 			   rect1->y + rect1->height > rect2->y;
2018 | 	case UP:
2019 | 		return rect2->y + rect2->height <= rect1->y &&
2020 | 			   rect1->x < rect2->x + rect2->width &&
2021 | 			   rect1->x + rect1->width > rect2->x;
2022 | 	case DOWN:
2023 | 		return rect2->y >= rect1->y + rect1->height &&
2024 | 			   rect1->x < rect2->x + rect2->width &&
2025 | 			   rect1->x + rect1->width > rect2->x;
2026 | 	default: return false;
2027 | 	}
2028 | }
2029 | 
2030 | /* find_closest_neighbor - find the closest neighbor node to a given node in
2031 |  * a specific direction. It is used to move focus to another node using the
2032 |  * keyboard
2033 |  *
2034 |  * searches through the tree (using a bfs) to
2035 |  * find the closest external node (a leaf node with a client) that is within
2036 |  * a certain range of the given node in the specified direction. It keeps
2037 |  * track of the closest node found and returns it.
2038 |  *
2039 |  * If no closest node is found, it returns NULL */
2040 | static node_t *
2041 | find_closest_neighbor(node_t *root, node_t *node, direction_t d)
2042 | {
2043 | 	if (root == NULL)
2044 | 		return NULL;
2045 | 
2046 | 	node_t *closest			 = NULL;
2047 | 	int		closest_distance = INT16_MAX;
2048 | 
2049 | 	node_t *queue[50];
2050 | 	int		front = 0, rear = 0;
2051 | 	queue[rear++] = root;
2052 | 
2053 | 	while (front < rear) {
2054 | 		node_t *current = queue[front++];
2055 | 		if (current == node)
2056 | 			continue;
2057 | 		if (IS_EXTERNAL(current) && current->client &&
2058 | 			is_within_range(&node->rectangle, &current->rectangle, d)) {
2059 | 			int distance;
2060 | 			switch (d) {
2061 | 			case LEFT:
2062 | 				distance = node->rectangle.x -
2063 | 						   (current->rectangle.x + current->rectangle.width);
2064 | 				break;
2065 | 			case RIGHT:
2066 | 				distance = current->rectangle.x -
2067 | 						   (node->rectangle.x + node->rectangle.width);
2068 | 				break;
2069 | 			case UP:
2070 | 				distance = node->rectangle.y -
2071 | 						   (current->rectangle.y + current->rectangle.height);
2072 | 				break;
2073 | 			case DOWN:
2074 | 				distance = current->rectangle.y -
2075 | 						   (node->rectangle.y + node->rectangle.height);
2076 | 				break;
2077 | 			default: distance = INT16_MAX; break;
2078 | 			}
2079 | 			if (distance < closest_distance) {
2080 | 				closest_distance = distance;
2081 | 				closest			 = current;
2082 | 			}
2083 | 		}
2084 | 		if (current->first_child)
2085 | 			queue[rear++] = current->first_child;
2086 | 		if (current->second_child)
2087 | 			queue[rear++] = current->second_child;
2088 | 	}
2089 | 	return closest;
2090 | }
2091 | 
2092 | /* cycle_win - cycles focus to the nearest window in a specified direction.
2093 |  *
2094 |  * calls find_closest_neighbor` to get the closest node in the
2095 |  * specified direction.
2096 |  *
2097 |  * If either the root or the neighbor can't be found, it logs an error and
2098 |  * returns `NULL`. */
2099 | node_t *
2100 | cycle_win(node_t *node, direction_t d)
2101 | {
2102 | 	node_t *root = find_tree_root(node);
2103 | 	if (root == NULL) {
2104 | 		_LOG_(ERROR, "could not find root of tree");
2105 | 		return NULL;
2106 | 	}
2107 | 	node_t *neighbor = find_closest_neighbor(root, node, d);
2108 | 	if (neighbor == NULL) {
2109 | 		_LOG_(ERROR, "could not find neighbor node");
2110 | 		return NULL;
2111 | 	}
2112 | 	return neighbor;
2113 | }
2114 | 
2115 | /* is_closer_node - check if a new node is closer to the target node than
2116 |  * the current node in the specified direction. */
2117 | static bool
2118 | is_closer_node(node_t *current, node_t *new_node, node_t *node, direction_t d)
2119 | {
2120 | 	if (current == NULL)
2121 | 		return true;
2122 | 
2123 | 	switch (d) {
2124 | 	case LEFT:
2125 | 		return new_node->rectangle.x > current->rectangle.x &&
2126 | 			   new_node->rectangle.x < node->rectangle.x;
2127 | 	case RIGHT:
2128 | 		return new_node->rectangle.x < current->rectangle.x &&
2129 | 			   new_node->rectangle.x > node->rectangle.x;
2130 | 	case UP:
2131 | 		return new_node->rectangle.y > current->rectangle.y &&
2132 | 			   new_node->rectangle.y < node->rectangle.y;
2133 | 	case DOWN:
2134 | 		return new_node->rectangle.y < current->rectangle.y &&
2135 | 			   new_node->rectangle.y > node->rectangle.y;
2136 | 	default: return false;
2137 | 	}
2138 | }
2139 | 
2140 | static node_t *
2141 | find_neighbor(node_t *root, node_t *node, direction_t d)
2142 | {
2143 | 	if (root == NULL || root == node)
2144 | 		return NULL;
2145 | 
2146 | 	node_t *best_node = NULL;
2147 | 	if (root->client) {
2148 | 		switch (d) {
2149 | 		case LEFT:
2150 | 			if (root->rectangle.x < node->rectangle.x &&
2151 | 				root->rectangle.x + root->rectangle.width <=
2152 | 					node->rectangle.x &&
2153 | 				(node->rectangle.y <
2154 | 					 root->rectangle.y + root->rectangle.height &&
2155 | 				 node->rectangle.y + node->rectangle.height >
2156 | 					 root->rectangle.y)) {
2157 | 				if (is_closer_node(best_node, root, node, d)) {
2158 | 					best_node = root;
2159 | 				}
2160 | 			}
2161 | 			break;
2162 | 		case RIGHT:
2163 | 			if (root->rectangle.x > node->rectangle.x + node->rectangle.width &&
2164 | 				(node->rectangle.y <
2165 | 					 root->rectangle.y + root->rectangle.height &&
2166 | 				 node->rectangle.y + node->rectangle.height >
2167 | 					 root->rectangle.y)) {
2168 | 				if (is_closer_node(best_node, root, node, d)) {
2169 | 					best_node = root;
2170 | 				}
2171 | 			}
2172 | 			break;
2173 | 		case UP:
2174 | 			if (root->rectangle.y < node->rectangle.y &&
2175 | 				root->rectangle.y + root->rectangle.height <=
2176 | 					node->rectangle.y &&
2177 | 				(node->rectangle.x <
2178 | 					 root->rectangle.x + root->rectangle.width &&
2179 | 				 node->rectangle.x + node->rectangle.width >
2180 | 					 root->rectangle.x)) {
2181 | 				if (is_closer_node(best_node, root, node, d)) {
2182 | 					best_node = root;
2183 | 				}
2184 | 			}
2185 | 			break;
2186 | 		case DOWN:
2187 | 			if (root->rectangle.y >
2188 | 					node->rectangle.y + node->rectangle.height &&
2189 | 				(node->rectangle.x <
2190 | 					 root->rectangle.x + root->rectangle.width &&
2191 | 				 node->rectangle.x + node->rectangle.width >
2192 | 					 root->rectangle.x)) {
2193 | 				if (is_closer_node(best_node, root, node, d)) {
2194 | 					best_node = root;
2195 | 				}
2196 | 			}
2197 | 			break;
2198 | 		default: break;
2199 | 		}
2200 | 	}
2201 | 	if (root->first_child) {
2202 | 		node_t *child_result = find_neighbor(root->first_child, node, d);
2203 | 		if (child_result && is_closer_node(best_node, child_result, node, d)) {
2204 | 			best_node = child_result;
2205 | 		}
2206 | 	}
2207 | 	if (root->second_child) {
2208 | 		node_t *child_result = find_neighbor(root->second_child, node, d);
2209 | 		if (child_result && is_closer_node(best_node, child_result, node, d)) {
2210 | 			best_node = child_result;
2211 | 		}
2212 | 	}
2213 | 	return best_node;
2214 | }
2215 | 


--------------------------------------------------------------------------------
/src/tree.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | 
29 | #ifndef ZWM_TREE_H
30 | #define ZWM_TREE_H
31 | 
32 | #include "type.h"
33 | /* clang-format off */
34 | node_t *create_node(client_t *c);
35 | node_t *init_root(void);
36 | node_t *find_node_by_window_id(node_t *root, xcb_window_t window_id);
37 | node_t *find_master_node(node_t *root);
38 | node_t *prev_node(node_t *current);
39 | node_t *next_node(node_t *current);
40 | node_t *cycle_win(node_t *node, direction_t);
41 | node_t *find_left_leaf(node_t *root);
42 | node_t *find_any_leaf(node_t *root);
43 | node_t *get_focused_node(node_t *n);
44 | bool unlink_node(node_t *node, desktop_t *d);
45 | void dynamic_resize(node_t *n, resize_t t);
46 | void apply_master_layout(node_t *parent);
47 | void apply_default_layout(node_t *root);
48 | void apply_stack_layout(node_t *root);
49 | void update_focus(node_t *root, node_t *n);
50 | void flip_node(node_t *node);
51 | void resize_subtree(node_t *parent);
52 | void apply_layout(desktop_t *d, layout_t t);
53 | void free_tree(node_t *root);
54 | void restack(void);
55 | void restackv2(node_t *root);
56 | void delete_node(node_t *node, desktop_t *d);
57 | void insert_node(node_t *current_node, node_t *new_node, layout_t layout);
58 | void arrange_tree(node_t *tree, layout_t l);
59 | void log_tree_nodes(node_t *node);
60 | bool transfer_node(node_t *, desktop_t *);
61 | bool is_tree_empty(const node_t *root);
62 | bool client_exist(node_t *cn, xcb_window_t id);
63 | bool has_floating_window(node_t *root);
64 | int render_tree(node_t *current_node);
65 | int hide_windows(node_t *tree);
66 | int show_windows(node_t *tree);
67 | int swap_node(node_t *root);
68 | /* clang-format off */
69 | #endif /* ZWM_TREE_H */
70 | 


--------------------------------------------------------------------------------
/src/type.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * BSD 2-Clause License
  3 |  * Copyright (c) 2024, Yazeed Alharthi
  4 |  *
  5 |  * Redistribution and use in source and binary forms, with or without
  6 |  * modification, are permitted provided that the following conditions
  7 |  * are met:
  8 |  *
  9 |  *	  1. Redistributions of source code must retain the above copyright
 10 |  *	  notice, this list of conditions and the following disclaimer.
 11 |  *
 12 |  *	  2. Redistributions in binary form must reproduce the above copyright
 13 |  *	  notice, this list of conditions and the following disclaimer in the
 14 |  *	  documentation and/or other materials provided with the distribution.
 15 |  *
 16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27 |  */
 28 | 
 29 | #ifndef ZWM_TYPE_H
 30 | #define ZWM_TYPE_H
 31 | 
 32 | #include <stdbool.h>
 33 | #include <stdint.h>
 34 | #include <sys/types.h>
 35 | #include <xcb/randr.h>
 36 | #include <xcb/xcb.h>
 37 | #include <xcb/xcb_event.h>
 38 | #include <xcb/xcb_ewmh.h>
 39 | #include <xcb/xcb_icccm.h>
 40 | 
 41 | #define CAP					 3
 42 | #define MAXLEN				 (2 << 7)
 43 | #define DLEN				 (2 << 4)
 44 | #define NULL_STR			 "N/A"		   /* default null string value */
 45 | #define MONITOR_NAME		 "DEF_MONITOR" /* default monitor name */
 46 | #define ROOT_WINDOW			 "root ZWM"	   /* root window name */
 47 | #define W_GAP				 10			   /* default window gap */
 48 | #define NORMAL_BORDER_COLOR	 0x30302f	   /* default inactive border color */
 49 | #define ACTIVE_BORDER_COLOR	 0x83a598	   /* default active border color */
 50 | #define BORDER_WIDTH		 2			   /* default border width */
 51 | #define FOCUS_FOLLOW_POINTER true		   /* default focus follows mouse */
 52 | 
 53 | /* type aliases */
 54 | typedef xcb_connection_t	  xcb_conn_t;
 55 | typedef xcb_generic_error_t	  xcb_error_t;
 56 | typedef xcb_void_cookie_t	  xcb_cookie_t;
 57 | typedef xcb_ewmh_connection_t xcb_ewmh_conn_t;
 58 | typedef xcb_generic_event_t	  xcb_event_t;
 59 | 
 60 | typedef enum {
 61 | 	HORIZONTAL_TYPE,
 62 | 	VERTICAL_TYPE,
 63 | 	DYNAMIC_TYPE
 64 | } split_type_t;
 65 | 
 66 | typedef enum {
 67 | 	HORIZONTAL_FLIP,
 68 | 	VERTICAL_FLIP
 69 | } flip_t;
 70 | 
 71 | typedef enum {
 72 | 	GROW = 1, /* increase window size */
 73 | 	SHRINK	  /* decrease window size */
 74 | } resize_t;
 75 | 
 76 | typedef enum {
 77 | 	HORIZONTAL_DIR = 1,
 78 | 	VERTICAL_DIR,
 79 | } resize_dir_t;
 80 | 
 81 | typedef enum {
 82 | 	LEFT = 1, /* move left */
 83 | 	RIGHT,	  /* move right */
 84 | 	UP,		  /* move up */
 85 | 	DOWN,	  /* move down */
 86 | 	NONE	  /* no direction */
 87 | } direction_t;
 88 | 
 89 | typedef enum {
 90 | 	NEXT = 1,
 91 | 	PREV
 92 | } traversal_t;
 93 | 
 94 | typedef enum {
 95 | 	ERROR,
 96 | 	INFO,
 97 | 	DEBUG,
 98 | 	WARNING
 99 | } log_level_t;
100 | 
101 | /* predefined cursor types */
102 | typedef enum {
103 | 	CURSOR_POINTER = 0, /* standard pointer */
104 | 	CURSOR_WATCH,		/* busy/wait cursor */
105 | 	CURSOR_MOVE,		/* move window cursor */
106 | 	CURSOR_XTERM,		/* text selection cursor, i think */
107 | 	CURSOR_NOT_ALLOWED, /* action not permitted */
108 | 	CURSOR_HAND2,		/* clickable item cursor */
109 | 	CURSOR_MAX			/* maximum cursor types */
110 | } cursor_t;
111 | 
112 | /* bit flags to determine the change in monitors' state */
113 | typedef enum {
114 | 	_NONE		 = (1 << 0), /* 00000001  no state change */
115 | 	CONNECTED	 = (1 << 1), /* 00000010  monitor connected */
116 | 	DISCONNECTED = (1 << 2), /* 00000100  monitor disconnected */
117 | 	LAYOUT		 = (1 << 3), /* 00001000  layout changed */
118 | 	/* note: layout also indcates changes in resoltuions, positions, or scale
119 | 	 * and oreintation */
120 | } monitor_state_t;
121 | 
122 | typedef struct {
123 | 	uint16_t previous_x, previous_y;
124 | 	uint16_t current_x, current_y;
125 | } posxy_t;
126 | 
127 | /* defines a rectangle (the window area or the tile/section area).
128 |  * note: x and y can be signed (negative or positive), for example when a
129 |  * portion of a window goes out of the visible area of the screen.
130 |  */
131 | typedef struct {
132 | 	int16_t	 x;
133 | 	int16_t	 y;
134 | 	uint16_t width;
135 | 	uint16_t height;
136 | } rectangle_t;
137 | 
138 | typedef enum {
139 | 	TILED,	   /* automatically tiled */
140 | 	FLOATING,  /* freely movable */
141 | 	FULLSCREEN /* occupies entire screen */
142 | } state_t;
143 | 
144 | typedef enum {
145 | 	DEFAULT = 1, /* standard manual tiling */
146 | 	MASTER,		 /* master-stack layout */
147 | 	STACK,		 /* stacked windows */
148 | 	GRID		 /* grid-based layout */
149 | } layout_t;
150 | 
151 | typedef enum {
152 | 	WINDOW_TYPE_NORMAL		 = 1,
153 | 	WINDOW_TYPE_DOCK		 = 2,
154 | 	WINDOW_TYPE_TOOLBAR_MENU = 3,
155 | 	WINDOW_TYPE_UTILITY		 = 4,
156 | 	WINDOW_TYPE_SPLASH		 = 5,
157 | 	WINDOW_TYPE_DIALOG		 = 6,
158 | 	WINDOW_TYPE_NOTIFICATION = 7,
159 | 	WINDOW_TYPE_UNKNOWN		 = -1
160 | } ewmh_window_type_t;
161 | 
162 | typedef enum {
163 | 	STATE_UNSUPPORTED = 0,
164 | 	STATE_FULLSCREEN,
165 | 	STATE_BELOW,
166 | 	STATE_ABOVE,
167 | 	STATE_HIDDEN,
168 | 	STATE_STICKY,
169 | 	STATE_DEMANDS_ATTENTION
170 | } window_state_type_t;
171 | 
172 | typedef enum {
173 | 	STATE_ACTION_INVALID = 0,
174 | 	STATE_ACTION_REMOVE,
175 | 	STATE_ACTION_ADD,
176 | 	STATE_ACTION_TOGGLE
177 | } window_state_action_t;
178 | 
179 | typedef enum {
180 | 	CLIENT_MESSAGE_UNSUPPORTED = 0,
181 | 	CLIENT_MESSAGE_CURRENT_DESKTOP,
182 | 	CLIENT_MESSAGE_WINDOW_STATE,
183 | 	CLIENT_MESSAGE_ACTIVE_WINDOW,
184 | 	CLIENT_MESSAGE_WINDOW_DESKTOP,
185 | 	CLIENT_MESSAGE_CLOSE_WINDOW
186 | } client_message_type_t;
187 | 
188 | typedef struct icccm_props_t icccm_props_t;
189 | struct icccm_props_t {
190 | 	bool take_focus;
191 | 	bool input_hint;
192 | 	bool delete_window;
193 | };
194 | 
195 | /* defines the client, like an opened application like firefox of a text editor.
196 |  * every leaf node in the tree contains a non-null client, internal nodes ALWAYS
197 |  * have null clients.
198 |  */
199 | typedef struct {
200 |     /*char			 class_name[MAXLEN];*/
201 |     /*char			 wm_name[MAXLEN];*/
202 | 	uint32_t		 border_width;
203 | 	xcb_window_t	 window;
204 | 	xcb_atom_t		 type;
205 | 	state_t			 state;
206 | 	icccm_props_t	 props;
207 | 	xcb_size_hints_t size_hints;
208 | } client_t;
209 | 
210 | /* types for tree nodes */
211 | typedef enum {
212 | 	ROOT_NODE = 1, /* root usually holds the full rectangle of the screen */
213 | 	INTERNAL_NODE, /* internal nodes hold screen sections/tiles only */
214 | 	EXTERNAL_NODE  /* external nodes hold the actual windows */
215 | } node_type_t;
216 | 
217 | /* the definition of the tree node */
218 | typedef struct node_t node_t;
219 | struct node_t {
220 | 	node_t	   *parent; /* a pointer to the parent, needed when traversing up */
221 | 	node_t	   *first_child;
222 | 	node_t	   *second_child;
223 | 	client_t   *client; /* the actual window this node hold, if it's a leaf */
224 | 	node_type_t node_type; /* node type */
225 | 	rectangle_t rectangle; /* the position and size for this node */
226 | 	rectangle_t floating_rectangle;
227 | 	bool		is_focused; /* whether or not this guy is focused */
228 | 	bool		is_master;	/* whether this node is the master node */
229 | };
230 | 
231 | /* the defintion of a desktop.
232 |  * each desktop has its own tree and layout.
233 |  * the wm could have up to 10 desktops.
234 |  */
235 | typedef struct {
236 | 	node_t	*tree; /* the tree in this desktop */
237 | 	/* node_t	*node;		 focused node */
238 | 	char	 name[DLEN]; /* the name, it stringfeis the index of this desktop */
239 | 	uint16_t id;		 /* the number of this desktop */
240 | 	uint16_t n_count;	 /* the number of active windows/external nodes */
241 | 	layout_t layout;	 /* the layout (master, default, stack) */
242 | 	bool	 is_focused; /* whether this is focused, only focused desktops
243 | 						  * are rendered */
244 | } desktop_t;
245 | 
246 | /* monitor representation (also a linked list of monitors).
247 |  * It is a physical output on your graphics driver, and it usually corresponds
248 |  * to one connected screen.
249 |  * Each monitore has its own virtual desktops by default */
250 | typedef struct monitor_t monitor_t;
251 | struct monitor_t {
252 | 	desktop_t		 **desktops;	/* array of desktops */
253 | 	desktop_t		  *desk;		/* focused desktop */
254 | 	monitor_t		  *next;		/* next monitor in list */
255 | 	char			   name[DLEN];	/* monitor name (e.g. HDMI or eDP) */
256 | 	uint32_t		   id;			/* monitor identifier, used with xinerama */
257 | 	xcb_randr_output_t randr_id;	/* randr output id, used with xrnadr */
258 | 	xcb_window_t	   root;		/* the root window on this monitor */
259 | 	rectangle_t		   rectangle;	/* monitor dimensions */
260 | 	bool			   is_wired;	/* connection status */
261 | 	bool			   is_focused;	/* focus status */
262 | 	bool			   is_occupied; /* window presence */
263 | 	bool			   is_primary;	/* primary monitor */
264 | 	uint16_t		   n_of_desktops; /* total desktops, defined in
265 | 									   * the config file  */
266 | };
267 | 
268 | /* status bar representation */
269 | typedef struct {
270 | 	uint32_t	 id;		/* bar identifier */
271 | 	xcb_window_t window;	/* xcb window reference */
272 | 	rectangle_t	 rectangle; /* bar dimensions */
273 | } bar_t;
274 | 
275 | /* window manager global state */
276 | typedef struct {
277 | 	xcb_connection_t	  *connection; /* xcb connection */
278 | 	xcb_ewmh_connection_t *ewmh;	   /* ewmh connection */
279 | 	xcb_screen_t		  *screen;	   /* global screen */
280 | 	bar_t				  *bar;		   /* status bar, should be moved (FIXME) */
281 | 	xcb_window_t		   root_window; /* root window */
282 | 	split_type_t		   split_type;	/* current split type */
283 | 	uint8_t				   screen_nbr;	/* screen number */
284 | } wm_t;
285 | 
286 | /* argument structure for key bindings */
287 | typedef struct {
288 | 	char	   **cmd;  /* command arguments, used for execp family actions */
289 | 	uint8_t		 argc; /* argument count */
290 | 	uint8_t		 idx;  /* target index, used for desktop switching */
291 | 	resize_t	 r;	   /* resize operation */
292 | 	resize_dir_t rd;   /* resize direction */
293 | 	layout_t	 t;	   /* layout type */
294 | 	traversal_t	 tr;   /* traversal direction */
295 | 	direction_t	 d;	   /* movement direction */
296 | 	state_t		 s;	   /* window state, used to change window state */
297 | } arg_t;
298 | 
299 | /* key binding structure. used for the global fallback array in zwm.c */
300 | typedef struct {
301 | 	uint32_t	 mod;		 /* modifier key */
302 | 	xcb_keysym_t keysym;	 /* key symbol */
303 | 	int (*execute)(arg_t *); /* action function */
304 | 	arg_t *arg;				 /* function arguments */
305 | } _key__t;
306 | 
307 | /* config key structure (linked list),
308 |  * represents the keys in the config file
309 |  */
310 | typedef struct conf_key_t conf_key_t;
311 | struct conf_key_t {
312 | 	uint32_t	 mod;		 /* modifier key */
313 | 	xcb_keysym_t keysym;	 /* key symbol */
314 | 	int (*execute)(arg_t *); /* action function */
315 | 	arg_t	   *arg;		 /* function arguments */
316 | 	conf_key_t *next;		 /* next key */
317 | };
318 | 
319 | /* function mapping structure */
320 | typedef struct {
321 | 	char *func_name;		 /* function name */
322 | 	int (*execute)(arg_t *); /* function pointer */
323 | } conf_mapper_t;
324 | 
325 | /* key mapping structure */
326 | typedef struct {
327 | 	char		 key[6]; /* key representation */
328 | 	xcb_keysym_t keysym; /* key symbol */
329 | } key_mapper_t;
330 | 
331 | /* window manager configuration */
332 | typedef struct {
333 | 	uint16_t border_width;		   /* window border width */
334 | 	uint16_t window_gap;		   /* spacing between windows */
335 | 	uint32_t active_border_color;  /* focused window border color */
336 | 	uint32_t normal_border_color;  /* unfocused window border color */
337 | 	int		 virtual_desktops;	   /* number of virtual desktops */
338 | 	bool	 focus_follow_pointer; /* mouse focus tracking */
339 | } config_t;
340 | 
341 | /* window rule structure (linked list) */
342 | typedef struct rule_t rule_t;
343 | struct rule_t {
344 | 	char	win_name[256]; /* window name pattern */
345 | 	state_t state;		   /* default window state */
346 | 	int		desktop_id;	   /* target desktop, if desired */
347 | 	rule_t *next;		   /* next rule in list */
348 | };
349 | 
350 | /* queue node */
351 | typedef struct queue_node_t queue_node_t;
352 | struct queue_node_t {
353 | 	node_t		 *tree_node; /* tree node reference */
354 | 	queue_node_t *next;		 /* next queue node */
355 | };
356 | 
357 | /* queue structure for level-order tree traversal */
358 | typedef struct {
359 | 	queue_node_t *front; /* front of queue */
360 | 	queue_node_t *rear;	 /* rear of queue */
361 | } queue_t;
362 | 
363 | /* event handler registration structure */
364 | typedef struct {
365 | 	uint8_t type;
366 | 	int (*handle)(const xcb_generic_event_t *);
367 | } event_handler_entry_t;
368 | 
369 | #endif /* ZWM_TYPE_H */
370 | 


--------------------------------------------------------------------------------
/src/zwm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BSD 2-Clause License
 3 |  * Copyright (c) 2024, Yazeed Alharthi
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *
 9 |  *	  1. Redistributions of source code must retain the above copyright
10 |  *	  notice, this list of conditions and the following disclaimer.
11 |  *
12 |  *	  2. Redistributions in binary form must reproduce the above copyright
13 |  *	  notice, this list of conditions and the following disclaimer in the
14 |  *	  documentation and/or other materials provided with the distribution.
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
17 |  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 |  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
19 |  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 |  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 |  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 |  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |  */
28 | 
29 | #ifndef ZWM_ZWM_H
30 | #define ZWM_ZWM_H
31 | 
32 | #include "type.h"
33 | #include <xcb/xcb_icccm.h>
34 | #include <xcb/xproto.h>
35 | 
36 | /* clang-format off */
37 | extern config_t 		  conf;
38 | extern wm_t 			  *wm;
39 | extern xcb_window_t 	  focused_win;
40 | extern monitor_t 		  *head_monitor;
41 | extern monitor_t		  *prim_monitor;
42 | extern monitor_t 		  *curr_monitor;
43 | extern bool 			  using_xrandr;
44 | extern bool 		      using_xinerama;
45 | extern uint8_t 			  randr_base;
46 | 
47 | xcb_window_t get_window_under_cursor(xcb_conn_t *conn, xcb_window_t win);
48 | void raise_window(xcb_window_t win);
49 | void lower_window(xcb_window_t win);
50 | void window_grab_buttons(xcb_window_t win);
51 | void window_above(xcb_window_t, xcb_window_t);
52 | void window_below(xcb_window_t, xcb_window_t);
53 | void grab_pointer(xcb_window_t, bool);
54 | void ungrab_pointer(void);
55 | char *win_name(xcb_window_t);
56 | int set_visibility(xcb_window_t win, bool is_visible);
57 | int exec_process(arg_t *arg);
58 | int layout_handler(arg_t *arg);
59 | int cycle_win_wrapper(arg_t *arg);
60 | int set_fullscreen_wrapper();
61 | int flip_node_wrapper();
62 | int reload_config_wrapper();
63 | int get_focused_desktop_idx();
64 | int switch_desktop_wrapper(arg_t *arg);
65 | int transfer_node_wrapper(arg_t *arg);
66 | int dynamic_resize_wrapper(arg_t *arg);
67 | int gap_handler(arg_t *arg);
68 | int cycle_desktop_wrapper(arg_t *arg);
69 | int close_or_kill_wrapper();
70 | int traverse_stack_wrapper(arg_t *arg);
71 | int shift_floating_window(arg_t *arg);
72 | int shrink_floating_window(arg_t *arg);
73 | int grow_floating_window(arg_t *arg);
74 | int cycle_monitors(arg_t *arg);
75 | int tile(node_t *node);
76 | int set_focus(node_t *n, bool flag);
77 | int swap_node_wrapper();
78 | int change_state(arg_t *arg);
79 | /* clang-format on */
80 | #endif /* ZWM_ZWM_H */
81 | 


--------------------------------------------------------------------------------
/zwm.1:
--------------------------------------------------------------------------------
  1 | .TH ZWM 1 "August 2024" "1.0" "ZWM Manual"
  2 | .SH NAME
  3 | ZWM
  4 | 
  5 | .SH SYNOPSIS
  6 | .B zwm
  7 | [\fIOPTIONS\fR]
  8 | 
  9 | .SH DESCRIPTION
 10 | .B zwm
 11 | is a minimalistic and opinionated tiling window manager for X11. It uses XCB for communication with the X server and employs a customized BSP tree for managing windows.
 12 | 
 13 | .SH CONFIGURATION
 14 | A configuration file is generated on first run and located at:
 15 | .TP
 16 | ~/.config/zwm/zwm.conf
 17 | 
 18 | .TP
 19 | Configuration variables:
 20 | .nf
 21 | border_width = 2
 22 | active_border_color = 0x4a4a48
 23 | normal_border_color = 0x30302f
 24 | window_gap = 10
 25 | virtual_desktops = 7
 26 | focus_follow_pointer = true
 27 | .fi
 28 | 
 29 | .TP
 30 | Commands to run on startup:
 31 | .nf
 32 | exec = "polybar"
 33 | exec = ["polybar", "-c", ".config/polybar/config.ini"]
 34 | .fi
 35 | 
 36 | .TP
 37 | Custom window rules:
 38 | .nf
 39 | rule = wm_class("window class name"), state(tiled|floated), desktop(1..N)
 40 | .fi
 41 | 
 42 | .TP
 43 | Key bindings:
 44 | .nf
 45 | bind = super + return -> run("alacritty")
 46 | bind = super + space -> run("dmenu_run")
 47 | bind = super + p -> run(["rofi","-show", "drun"])
 48 | bind = super + w -> func(kill)
 49 | bind = super + 1 -> func(switch_desktop:1)
 50 | bind = super + 2 -> func(switch_desktop:2)
 51 | bind = super + 3 -> func(switch_desktop:3)
 52 | bind = super + 4 -> func(switch_desktop:4)
 53 | bind = super + 5 -> func(switch_desktop:5)
 54 | bind = super + 6 -> func(switch_desktop:6)
 55 | bind = super + 7 -> func(switch_desktop:7)
 56 | bind = super + l -> func(resize:grow)
 57 | bind = super + h -> func(resize:shrink)
 58 | bind = super + i -> func(gap_handler:grow)
 59 | bind = super + d -> func(gap_handler:shrink)
 60 | bind = super + f -> func(fullscreen)
 61 | bind = super + s -> func(swap)
 62 | bind = super + up -> func(cycle_window:up)
 63 | bind = super + right -> func(cycle_window:right)
 64 | bind = super + left -> func(cycle_window:left)
 65 | bind = super + down -> func(cycle_window:down)
 66 | bind = shift + up -> func(shift_window:up)
 67 | bind = shift + right -> func(shift_window:right)
 68 | bind = shift + left -> func(shift_window:left)
 69 | bind = shift + down -> func(shift_window:down)
 70 | bind = shift + t -> func(change_state:tile)
 71 | bind = shift + f -> func(change_state:float)
 72 | bind = super|shift + left -> func(cycle_desktop:left)
 73 | bind = super|shift + right -> func(cycle_desktop:right)
 74 | bind = super|shift + 1 -> func(transfer_node:1)
 75 | bind = super|shift + 2 -> func(transfer_node:2)
 76 | bind = super|shift + 3 -> func(transfer_node:3)
 77 | bind = super|shift + 4 -> func(transfer_node:4)
 78 | bind = super|shift + 5 -> func(transfer_node:5)
 79 | bind = super|shift + 6 -> func(transfer_node:6)
 80 | bind = super|shift + 7 -> func(transfer_node:7)
 81 | bind = super|shift + m -> func(layout:master)
 82 | bind = super|shift + s -> func(layout:stack)
 83 | bind = super|shift + d -> func(layout:default)
 84 | bind = super|shift + k -> func(traverse:up)
 85 | bind = super|shift + j -> func(traverse:down)
 86 | bind = super|shift + f -> func(flip)
 87 | bind = super|shift + r -> func(reload_config)
 88 | .fi
 89 | 
 90 | .SH DEFAULT KEYBINDINGS
 91 | .TP
 92 | .B super + w
 93 |  \- Kill/close window
 94 | .TP
 95 | .B super + return
 96 |  \- Launch terminal (alacritty)
 97 | .TP
 98 | .B super + space
 99 |  \- Launch dmenu
100 | .TP
101 | .B super + p
102 |  \- Launch rofi
103 | .TP
104 | .B super + [1..N]
105 |  \- Switch desktop
106 | .TP
107 | .B super + l
108 |  \- Resize window (grow/expand)
109 | .TP
110 | .B super + h
111 |  \- Resize window (shrink)
112 | .TP
113 | .B super + f
114 |  \- Toggle fullscreen
115 | .TP
116 | .B super + shift + [1..N]
117 |  \- Transfer window to a different desktop
118 | .TP
119 | .B super + shift + m
120 |  \- Toggle master layout
121 | .TP
122 | .B super + shift + s
123 |  \- Toggle stack layout
124 | .TP
125 | .B super + shift + d
126 |  \- Toggle default layout
127 | .TP
128 | .B super + shift + j/k
129 |  \- Traverse the stack
130 | .TP
131 | .B super + shift + f
132 |  \- Flip window/partition
133 | .TP
134 | .B super + shift + r
135 |  \- Hot-reload configuration
136 | .TP
137 | .B super + ←
138 |  \- Focus window on the left
139 | .TP
140 | .B super + ↑
141 |  \- Focus window above
142 | .TP
143 | .B super + →
144 |  \- Focus window on the right
145 | .TP
146 | .B super + ↓
147 |  \- Focus window below
148 | .TP
149 | .B shift + ←
150 |  \- Shift window to the left by 10px
151 | .TP
152 | .B shift + ↑
153 |  \- Shift window up by 10px
154 | .TP
155 | .B shift + →
156 |  \- Shift window to the right by 10px
157 | .TP
158 | .B shift + ↓
159 |  \- Shift window down by 10px
160 | .TP
161 | .B shift + t
162 |  \- Tile window
163 | .TP
164 | .B shift + f
165 |  \- Float window
166 | .TP
167 | .B super + i
168 |  \- Increase window gaps by 5px
169 | .TP
170 | .B super + d
171 |  \- Decrease window gaps by 5px
172 | 
173 | .SH EWMH SPECIFIC SETTINGS FOR POLYBAR
174 | To display the window name (CLASS_NAME):
175 | .nf
176 | [module/xwindow]
177 | type = internal/xwindow
178 | format = <label>
179 | label = %title%
180 | label-maxlen = 50
181 | label-empty = "[null]"
182 | .fi
183 | 
184 | To display workspaces:
185 | .nf
186 | [module/ewmh]
187 | type = internal/xworkspaces
188 | label-active = %index%
189 | label-active-background = ${colors.bg}
190 | label-active-underline = ${colors.blue}
191 | label-active-padding = 1
192 | label-occupied = %index%
193 | label-occupied-padding = 1
194 | label-urgent = %index%!
195 | label-urgent-background = ${colors.red}
196 | label-urgent-padding = 1
197 | label-empty = %index%
198 | label-empty-foreground = ${colors.gray}
199 | label-empty-padding = 1
200 | label-separator = " "
201 | .fi
202 | 
203 | .SH CONTRIBUTING
204 | To contribute to
205 | .B zwm
206 | or fix a bug, please submit a pull request on GitHub.
207 | 
208 | .SH SEE ALSO
209 | .B polybar
210 | (1),
211 | .B bspwm
212 | (1),
213 | .B xprop
214 | (1)
215 | 


--------------------------------------------------------------------------------
/zwm.conf:
--------------------------------------------------------------------------------
  1 | ; ----------- ZWM Configuration File -------------
  2 | ;
  3 | ; This configuration file is used to customize the Zee Window Manager (ZWM) settings.
  4 | ; It allows you to define window appearance, behavior, and key bindings for various actions.
  5 | 
  6 | ; Command to run on startup
  7 | ; Use the exec directive to specify programs that should be started when ZWM is launched.
  8 | ; For single command: use -> exec = "command"
  9 | ; You can also specify additional arguments as a list.
 10 | exec = ["polybar", "-c", ".config/polybar/config.ini"]
 11 | 
 12 | ; Available Variables:
 13 | ; These variables control the appearance and behavior of the window manager.
 14 | ;
 15 | ; - border_width: defines the width of the window borders in pixels.
 16 | border_width = 2
 17 | ; - active_border_color: specifies the color of the border for the active (focused) window.
 18 | active_border_color = 0x4a4a48
 19 | ; - normal_border_color: specifies the color of the border for inactive (unfocused) windows.
 20 | normal_border_color = 0x30302f
 21 | ; - window_gap: sets the gap between windows in pixels.
 22 | window_gap = 10
 23 | ; - virtual_desktops: sets the number of virtual desktops available.
 24 | virtual_desktops = 7
 25 | ; - focus_follow_pointer: If false, the window is focused on click.
 26 | ;                        If true, the window is focused when the cursor enters it.
 27 | focus_follow_pointer = true
 28 | 
 29 | ; Custom window rules
 30 | ; Custom window rules allow you to define specific behaviors for windows based on their window class.
 31 | ;
 32 | ; Syntax:
 33 | ; rule = wm_class("window class name"), state(tiled|floated), desktop(1..N)
 34 | ;
 35 | ; Explanation:
 36 | ; - wm_class: The window class name used to identify the window. Use the 'xprop' tool to find the wm_class of a window.
 37 | ; - state: Specifies whether the window should be tiled or floated.
 38 | ;   - tiled: The window will be tiled, clearly.
 39 | ;   - floated: The window will be floated, clearly.
 40 | ; - desktop: The virtual desktop number where the window should be placed. Use -1 if you do not want to set it to a specific desktop.
 41 | ;
 42 | ; Example:
 43 | ; rule = wm_class("firefox"), state(tiled), desktop(-1)
 44 | ; This rule sets "firefox" window to be tiled and does not change its virtual desktop.
 45 | rule = wm_class("emacs"), state(tiled), desktop(-1)
 46 | 
 47 | ; Key Bindings:
 48 | ; Define keyboard shortcuts to perform various actions.
 49 | ; The syntax for defining key bindings is:
 50 | ; bind = modifier + key -> action/function
 51 | ; If two modifiers are used, combine them with a pipe (|). For example, alt + shift is written as alt|shift.
 52 | ; Colon Syntax:
 53 | ; Some functions require additional arguments to specify details of the action.
 54 | ; These arguments are provided using a colon syntax, where the function and its argument
 55 | ; are separated by a colon.
 56 | ; Example: func(switch_desktop:1) means "switch to desktop 1".
 57 | ; Example: func(resize:grow) means "grow the size of the window".
 58 | ; Example: func(layout:master) means "toggle master layout".
 59 | 
 60 | ; Available Modifiers:
 61 | ; - super: The "Windows" key or "Command" key on a Mac.
 62 | ; - alt: The "Alt" key.
 63 | ; - shift: The "Shift" key.
 64 | ; - ctrl: The "Control" key.
 65 | ;
 66 | ; Available Actions:
 67 | ; These actions specify what happens when a key binding is triggered.
 68 | ; - run(...): Executes a specified process.
 69 | ;   - Example: bind = super + return -> run("alacritty")
 70 | ;   - To run a process with arguments, use a list:
 71 | ;     Example: bind = super + p -> run(["rofi", "-show", "drun"])
 72 | ;
 73 | ; - func(...): Calls a predefined function. The following functions are available:
 74 | ;   - kill: Kills the focused window.
 75 | ;   - switch_desktop: Switches to a specified virtual desktop.
 76 | ;   - fullscreen: Toggles fullscreen mode for the focused window.
 77 | ;   - swap: Swaps the focused window with its sibling.
 78 | ;   - transfer_node: Moves the focused window to another virtual desktop.
 79 | ;   - layout: Toggles the specified layout (master, default, stack).
 80 | ;   - traverse: (In stack layout only) Moves focus to the window above or below.
 81 | ;   - flip: Changes the window's orientation; if the window is primarily vertical, it becomes horizontal, and vice versa.
 82 | ;   - cycle_window: Moves focus to the window in the specified direction (up, down, left, right).
 83 | ;   - cycle_desktop: Cycles through the virtual desktops (left, right).
 84 | ;   - resize: Adjusts the size of the focused window (grow, shrink).
 85 | ;   - reload_config: Reloads the configuration file without restarting ZWM.
 86 | ;   - shift_window: Shift floating window position to the specified direction (up, down, left, right).
 87 | ;   - gap_handler: Increase or decrease window gaps (GROW, SHRINK).
 88 | 
 89 | ; Define key bindings
 90 | 
 91 | ; run processes on some keys
 92 | bind = super + return -> run("alacritty")
 93 | bind = super + space -> run("dmenu_run")
 94 | bind = super + p -> run(["rofi", "-show", "drun"])
 95 | 
 96 | ; kill the focused window
 97 | bind = super + w -> func(kill)
 98 | 
 99 | ; switch to specific virtual desktops
100 | bind = super + 1 -> func(switch_desktop:1)
101 | bind = super + 2 -> func(switch_desktop:2)
102 | bind = super + 3 -> func(switch_desktop:3)
103 | bind = super + 4 -> func(switch_desktop:4)
104 | bind = super + 5 -> func(switch_desktop:5)
105 | bind = super + 6 -> func(switch_desktop:6)
106 | bind = super + 7 -> func(switch_desktop:7)
107 | 
108 | ; resize the focused window
109 | bind = super + l -> func(resize:grow)
110 | bind = super + h -> func(resize:shrink)
111 | 
112 | ; change the gaps between windows
113 | bind = super + i -> func(gap_handler:grow)
114 | bind = super + d -> func(gap_handler:shrink)
115 | 
116 | ; toggle fullscreen mode
117 | bind = super + f -> func(fullscreen)
118 | 
119 | ; swap the focused window with its sibling
120 | bind = super + s -> func(swap)
121 | 
122 | ; cycle focus between windows
123 | bind = super + up -> func(cycle_window:up)
124 | bind = super + right -> func(cycle_window:right)
125 | bind = super + left -> func(cycle_window:left)
126 | bind = super + down -> func(cycle_window:down)
127 | 
128 | ; cycle focus between monitors
129 | bind = super|ctrl + right -> func(cycle_monitors:next)
130 | bind = super|ctrl + left -> func(cycle_monitors:prev)
131 | 
132 | ; shift floating window position to the specified direction
133 | bind = shift + up -> func(shift_window:up)
134 | bind = shift + right -> func(shift_window:right)
135 | bind = shift + left -> func(shift_window:left)
136 | bind = shift + down -> func(shift_window:down)
137 | 
138 | ; grow floating windows
139 | bind = super|shift + y -> func(grow_floating_window:horizontal)
140 | bind = super|shift + h -> func(grow_floating_window:vertical)
141 | 
142 | ; shrink floating windows
143 | bind = super|shift + t -> func(shrink_floating_window:horizontal)
144 | bind = super|shift + g -> func(shrink_floating_window:vertical)
145 | 
146 | ; cycle through virtual desktops
147 | bind = super|shift + left -> func(cycle_desktop:left)
148 | bind = super|shift + right -> func(cycle_desktop:right)
149 | 
150 | ; transfer the focused window to another virtual desktop
151 | bind = super|shift + 1 -> func(transfer_node:1)
152 | bind = super|shift + 2 -> func(transfer_node:2)
153 | bind = super|shift + 3 -> func(transfer_node:3)
154 | bind = super|shift + 4 -> func(transfer_node:4)
155 | bind = super|shift + 5 -> func(transfer_node:5)
156 | bind = super|shift + 6 -> func(transfer_node:6)
157 | bind = super|shift + 7 -> func(transfer_node:7)
158 | 
159 | ; change the layout
160 | bind = super|shift + m -> func(layout:master)
161 | bind = super|shift + s -> func(layout:stack)
162 | bind = super|shift + d -> func(layout:default)
163 | 
164 | ; traverse the stack layout
165 | bind = super|shift + k -> func(traverse:up)
166 | bind = super|shift + j -> func(traverse:down)
167 | 
168 | ; flip the orientation of the window
169 | bind = super|shift + f -> func(flip)
170 | 
171 | ; reload the configuration file
172 | bind = super|shift + r -> func(reload_config)
173 | 


--------------------------------------------------------------------------------