Continuous Window Minimizer: Bash Script for Tidying X11 Desktops

The following script is a Bash script designed to continuously minimize all visible windows except the currently active one.

Could be beneficial for several reasons:

1. Improved Focus: By minimizing all windows except the active one, it helps users maintain focus on their current task without distractions from other open applications or windows.
2. Enhanced Organization: It automatically keeps the desktop tidy by minimizing unnecessary windows, reducing clutter and making it easier to find and access important information.
3. Increased Efficiency: Users can quickly switch between applications without manually minimizing or closing windows, saving time and effort.
4. Customizable: The script allows users to adjust the frequency of window minimization by modifying the sleep duration, providing flexibility to tailor the behavior according to individual preferences.
5. Accessibility: It can be particularly useful for individuals who frequently work with multiple windows or have limited screen space, as it streamlines the desktop environment for improved accessibility and usability.

Overall, this script offers a simple yet effective solution for maintaining an organized and focused workspace, ultimately contributing to productivity and workflow efficiency.

#!/bin/bash

DEBUG_LOG="./debug.log"  # Path to the debug log file

# Clear old logs
echo > $DEBUG_LOG

# Trap errors and execute the cleanup function
#trap 'cleanup' ERR

while true; do
    # Get the window ID of the currently active window
    ACTIVE_WINDOW_ID=$(xdotool getactivewindow)
    echo "ACTIVE_WINDOW_ID: $ACTIVE_WINDOW_ID" >> "$DEBUG_LOG"

    ACTIVE_WINDOW_NAME=$(xdotool getwindowname $ACTIVE_WINDOW_ID)
    echo "ACTIVE_WINDOW_NAME: $ACTIVE_WINDOW_NAME" >> "$DEBUG_LOG"

    # Get a list of all visible windows
    VISIBLE_WINDOWS=$(xdotool search --onlyvisible --class '')
    echo "VISIBLE_WINDOWS: $VISIBLE_WINDOWS" >> "$DEBUG_LOG"

    WINDOW_IGNORE=`echo $ACTIVE_WINDOW_NAME | grep -i -e save -e open`
    if [[ "$WINDOW_IGNORE" == *"Save"* || "$WINDOW_IGNORE" == *"Open"* ]]; then
	WINDOW_IGNORE="Ignore"
    else
    	echo "Starting iteration..." >> "$DEBUG_LOG"	
    fi

    # Loop through each visible window
    for WINDOW_ID in $VISIBLE_WINDOWS; do
        # Get the window title
        WINDOW_TITLE=$(xdotool getwindowname "$WINDOW_ID")
        echo "WINDOW_ID: $WINDOW_ID, WINDOW_TITLE: $WINDOW_TITLE" >> "$DEBUG_LOG"

        # Check if the window is not the active window and is not already minimized
        if [ "$WINDOW_ID" != "$ACTIVE_WINDOW_ID" ]; then # && [ "$(xdotool windowminimize "$WINDOW_ID" && echo true)" != true ]; then
            # Check if the window title indicates an open dialog window
            if [ "$WINDOW_IGNORE" != "Ignore" ]; then
		# Log that the window is being minimized to debug.log
            	echo "Minimizing window..." >> "$DEBUG_LOG"

		# Minimize the window
                xdotool windowminimize "$WINDOW_ID"
            fi
        fi
    done

    # Log the end of each iteration to debug.log
    echo "End of iteration." >> "$DEBUG_LOG"

    # Activate the active window
    xdotool windowactivate "$ACTIVE_WINDOW_ID"

    # Sleep for a specified duration before repeating the loop
    sleep 3  # Adjust the duration as needed
done

Let's break down how it works:

1. The script starts with a while loop that runs indefinitely (while true). This means the script will keep executing until it's explicitly stopped.
2. Inside the loop, it first retrieves the ID of the currently active window using the xdotool getactivewindow command and stores it in the variable ACTIVE_WINDOW_ID.
3. Next, it gets a list of all visible windows on the desktop using the xdotool search --onlyvisible --class '' command. The --onlyvisible flag ensures that only visible windows are considered, and --class '' means it doesn't filter based on window class, effectively fetching all visible windows.
4. It then enters a for loop to iterate over each window ID (WINDOW_ID) from the list of visible windows.
5. Within the loop, it checks if the current window is not the active window ("$WINDOW_ID" != "$ACTIVE_WINDOW_ID") and if it's not already minimized. It does this by attempting to minimize the window (xdotool windowminimize "$WINDOW_ID") and checking if the command was successful (if it returns true).
6. If the window is not the active window and it's not already minimized, it minimizes the window using xdotool windowminimize "$WINDOW_ID".
7. After iterating through all visible windows, it ensures that the active window remains activated by using xdotool windowactivate "$ACTIVE_WINDOW_ID".
8. Finally, it introduces a pause (sleep 1) to control the frequency of the loop. In this case, it waits for one second before repeating the process.

To run it automatically in the background:

• Using a Startup Application: Most operating systems provide a way to set up applications or scripts to run automatically when you log in. You can add your script to the list of startup applications in your system settings.
• Cron Job: You can schedule the script to run at regular intervals using cron. You can edit your crontab file (crontab -e) and add a line to specify when and how often the script should run.For example, to run the script every time the system starts, you can add the following line to your crontab:

@reboot /usr/local/bin/only1window.sh &

• Systemd Service: You can create a systemd service to manage the execution of your script. This method provides more control and flexibility over how the script is started and managed.

Here's a basic example of a systemd service file (only1window.service):

[Unit]
Description=Your Script Description
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash /usr/local/bin/only1window.sh

[Install]
WantedBy=multi-user.target

• After creating the service file, you need to reload systemd (sudo systemctl daemon-reload), enable the service (sudo systemctl enable only1window.service), and start it (sudo systemctl start only1window.service).

Regardless of the method you choose, make sure your script has executable permissions (chmod +x yourscript.sh) and specify the full path to your script in any configuration files or commands you use to run it automatically.

To ensure it will work correctly, it necessitates the X11 windowing system to manage window operations, meaning it's indispensable that your desktop environment operates within the X11 framework.

This script essentially creates a continuous loop that keeps all windows minimized except for the currently active one, effectively maintaining a tidy desktop environment. Adjusting the sleep duration can change how frequently the script checks and minimizes windows.