redesign the window with flatlaf

pom.xml

@@ -32,6 +32,18 @@
             <version>2.2.2</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.formdev</groupId>
+            <artifactId>flatlaf</artifactId>
+            <version>3.7.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.miglayout</groupId>
+            <artifactId>miglayout-swing</artifactId>
+            <version>11.4.3</version>
+        </dependency>
+
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
@@ -67,25 +79,44 @@
                 <version>5.8.0.7211</version>
             </plugin>
             <plugin>
-                <artifactId>maven-assembly-plugin</artifactId>
+                <groupId>org.apache.maven.plugins</groupId>
-                <version>3.8.0</version>
+                <artifactId>maven-shade-plugin</artifactId>
-                <configuration>
+                <version>3.6.2</version>
-                    <archive>
-                        <manifest>
-                            <mainClass>wtf.beatrice.autosqueal.Main</mainClass>
-                        </manifest>
-                    </archive>
-                    <descriptorRefs>
-                        <descriptorRef>jar-with-dependencies</descriptorRef>
-                    </descriptorRefs>
-                </configuration>
                 <executions>
                     <execution>
-                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
+                        <id>make-fat-jar</id>
-                        <phase>package</phase> <!-- bind to the packaging phase -->
+                        <phase>package</phase>
                         <goals>
-                            <goal>single</goal>
+                            <goal>shade</goal>
                         </goals>
+                        <configuration>
+                            <!-- the fat jar replaces the main artifact: jpackage
+                                 and plain `java -jar` both use it. shade merges
+                                 the multi-release and service files correctly,
+                                 which the assembly plugin does not -->
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                            <filters>
+                                <filter>
+                                    <artifact>*:*</artifact>
+                                    <excludes>
+                                        <exclude>META-INF/*.SF</exclude>
+                                        <exclude>META-INF/*.DSA</exclude>
+                                        <exclude>META-INF/*.RSA</exclude>
+                                        <exclude>module-info.class</exclude>
+                                        <exclude>META-INF/versions/*/module-info.class</exclude>
+                                    </excludes>
+                                </filter>
+                            </filters>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>wtf.beatrice.autosqueal.Main</mainClass>
+                                    <manifestEntries>
+                                        <Multi-Release>true</Multi-Release>
+                                    </manifestEntries>
+                                </transformer>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                            </transformers>
+                        </configuration>
                     </execution>
                 </executions>
             </plugin>
@@ -135,7 +166,7 @@
                                         <resource>
                                             <directory>${project.build.directory}</directory>
                                             <includes>
-                                                <include>${project.build.finalName}-jar-with-dependencies.jar</include>
+                                                <include>${project.build.finalName}.jar</include>
                                             </includes>
                                         </resource>
                                     </resources>
@@ -167,7 +198,7 @@
                                         <argument>--input</argument>
                                         <argument>${project.build.directory}/jpackage-input</argument>
                                         <argument>--main-jar</argument>
-                                        <argument>${project.build.finalName}-jar-with-dependencies.jar</argument>
+                                        <argument>${project.build.finalName}.jar</argument>
                                         <argument>--main-class</argument>
                                         <argument>wtf.beatrice.autosqueal.Main</argument>
                                         <argument>--java-options</argument>

readme.md

@@ -28,7 +28,7 @@
  1. clone the official repository linked below using `git clone`.  
  2. `cd` into the directory and run `mvn clean package`.  
  3. you will find a runnable jar with dependencies in the `target/` folder.  
- 4. run the built jar file with `java -jar target/autosqueal-*-jar-with-dependencies.jar`.
+ 4. run the built jar file with `java -jar target/autosqueal-*.jar`.
 
 **macos .app bundle**  
  - on macos, run `mvn clean package -Pmac-app`: you will find `autosqueal.app` in `target/jpackage/`.  

src/main/java/wtf/beatrice/autosqueal/Main.java

@@ -4,16 +4,20 @@ import com.github.kwhat.jnativehook.GlobalScreen;
 import com.github.kwhat.jnativehook.NativeHookException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+import wtf.beatrice.autosqueal.config.ConfigStore;
 import wtf.beatrice.autosqueal.listener.KeyPressListener;
 import wtf.beatrice.autosqueal.ui.MainWindow;
+import wtf.beatrice.autosqueal.ui.ThemeManager;
+import wtf.beatrice.autosqueal.util.SystemUtil;
 
 import javax.swing.*;
-import javax.swing.UnsupportedLookAndFeelException;
 
 public class Main {
 
     private static final Logger LOGGER = LogManager.getLogger(Main.class);
-    private static final MainWindow mainWindow = new MainWindow();
+    private static MainWindow mainWindow;
+    private static AutoSquealConfig config;
 
     /** Whether the hook and its listener are registered, so retries don't add duplicates. */
     private static boolean hookRegistered = false;
@@ -21,11 +25,24 @@ public class Main {
     public static void main(String[] args) {
         LOGGER.info("Hello world!");
 
+        // macos window chrome: these must be set before AWT initializes,
+        // or they are ignored
+        if (SystemUtil.getHostSystem() == SystemUtil.OperatingSystem.MAC_OS) {
+            // follow the system appearance for the window title bars
+            System.setProperty("apple.awt.application.appearance", "system");
+            // name the app in the menu bar
+            System.setProperty("apple.awt.application.name", "autosqueal");
+        }
+
+        ConfigStore configStore = new ConfigStore();
+        config = configStore.load();
+        mainWindow = new MainWindow(config, configStore);
+
         // ⌘Q on macOS, the IDE stop button and signals all bypass
         // windowClosing: make cleanup run on every exit path instead
         Runtime.getRuntime().addShutdownHook(new Thread(mainWindow::cleanup, "autosqueal-shutdown"));
 
-        useSystemLookAndFeel();
+        ThemeManager.applySystemTheme();
         boolean hookRegistered = registerJNativeHook();
 
         // all Swing components must be created and updated on the EDT
@@ -37,14 +54,6 @@ public class Main {
         });
     }
 
-    private static void useSystemLookAndFeel() {
-        try {
-            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-        } catch (ReflectiveOperationException | UnsupportedLookAndFeelException ex) {
-            LOGGER.warn("Could not set the system look and feel, using the default one", ex);
-        }
-    }
-
     public static boolean registerJNativeHook() {
         if (hookRegistered) {
             return true;
@@ -53,7 +62,8 @@ public class Main {
         LOGGER.info("Registering jnativehook library...");
         try {
             GlobalScreen.registerNativeHook();
-            GlobalScreen.addNativeKeyListener(new KeyPressListener());
+            GlobalScreen.addNativeKeyListener(
+                    new KeyPressListener(mainWindow::toggleRunning, mainWindow::notifyKeyboardActivity, config));
             hookRegistered = true;
             LOGGER.info("Successfully registered jnativehook library!");
             return true;
@@ -84,8 +94,4 @@ public class Main {
         }
     }
 
-    public static MainWindow getMainWindow() {
-        return mainWindow;
-    }
-
 }

src/main/java/wtf/beatrice/autosqueal/config/AutoSquealConfig.java

@@ -0,0 +1,113 @@
+package wtf.beatrice.autosqueal.config;
+
+/**
+ * The user-editable settings of the app.
+ *
+ * A single instance is shared between the components, which read the
+ * current values while running: a change is picked up by the next poll or
+ * movement without a restart. Values are clamped to sane ranges when set,
+ * so that no matter what ends up in the settings file, the automation
+ * always gets workable numbers.
+ */
+public class AutoSquealConfig {
+
+    public static final int AWAY_THRESHOLD_MIN_SECONDS = 5;
+    public static final int AWAY_THRESHOLD_MAX_SECONDS = 600;
+
+    public static final int MOVE_INTERVAL_MIN_SECONDS = 1;
+    public static final int MOVE_INTERVAL_MAX_SECONDS = 3600;
+
+    public static final int STEP_DELAY_MIN_MILLISECONDS = 1;
+    public static final int STEP_DELAY_MAX_MILLISECONDS = 50;
+
+    public static final int CLICK_EVERY_MIN_MOVES = 1;
+    public static final int CLICK_EVERY_MAX_MOVES = 100;
+
+    private volatile int awayThresholdSeconds = 30;
+    private volatile int moveIntervalSeconds = 10;
+    private volatile int stepDelayMilliseconds = 2;
+    private volatile boolean clickEnabled = true;
+    private volatile int clickEveryNMoves = 5;
+    private volatile ScreenArea movementScreen = ScreenArea.PRIMARY;
+    private volatile boolean startAutomatically = true;
+    private volatile boolean hotkeyEnabled = true;
+
+    /** Seconds without user activity after which the user is considered away. */
+    public int getAwayThresholdSeconds() {
+        return awayThresholdSeconds;
+    }
+
+    public void setAwayThresholdSeconds(int seconds) {
+        awayThresholdSeconds = clamp(seconds, AWAY_THRESHOLD_MIN_SECONDS, AWAY_THRESHOLD_MAX_SECONDS);
+    }
+
+    /** Seconds between two movements. */
+    public int getMoveIntervalSeconds() {
+        return moveIntervalSeconds;
+    }
+
+    public void setMoveIntervalSeconds(int seconds) {
+        moveIntervalSeconds = clamp(seconds, MOVE_INTERVAL_MIN_SECONDS, MOVE_INTERVAL_MAX_SECONDS);
+    }
+
+    /** Pause between two cursor steps, in milliseconds: the lower, the faster. */
+    public int getStepDelayMilliseconds() {
+        return stepDelayMilliseconds;
+    }
+
+    public void setStepDelayMilliseconds(int milliseconds) {
+        stepDelayMilliseconds = clamp(milliseconds, STEP_DELAY_MIN_MILLISECONDS, STEP_DELAY_MAX_MILLISECONDS);
+    }
+
+    /** Whether the corner double click is performed at all. */
+    public boolean isClickEnabled() {
+        return clickEnabled;
+    }
+
+    public void setClickEnabled(boolean enabled) {
+        clickEnabled = enabled;
+    }
+
+    /**
+     * One movement every N is a corner double click, so that the
+     * notification area gets exercised too.
+     */
+    public int getClickEveryNMoves() {
+        return clickEveryNMoves;
+    }
+
+    public void setClickEveryNMoves(int moves) {
+        clickEveryNMoves = clamp(moves, CLICK_EVERY_MIN_MOVES, CLICK_EVERY_MAX_MOVES);
+    }
+
+    /** Which screens the cursor may travel to. */
+    public ScreenArea getMovementScreen() {
+        return movementScreen;
+    }
+
+    public void setMovementScreen(ScreenArea screenArea) {
+        movementScreen = screenArea == null ? ScreenArea.PRIMARY : screenArea;
+    }
+
+    /** Whether the automation starts as soon as the window opens. */
+    public boolean isStartAutomatically() {
+        return startAutomatically;
+    }
+
+    public void setStartAutomatically(boolean automatically) {
+        startAutomatically = automatically;
+    }
+
+    /** Whether the global toggle hotkey is active. */
+    public boolean isHotkeyEnabled() {
+        return hotkeyEnabled;
+    }
+
+    public void setHotkeyEnabled(boolean enabled) {
+        hotkeyEnabled = enabled;
+    }
+
+    private static int clamp(int value, int min, int max) {
+        return Math.max(min, Math.min(max, value));
+    }
+}

src/main/java/wtf/beatrice/autosqueal/config/ConfigStore.java

@@ -0,0 +1,163 @@
+package wtf.beatrice.autosqueal.config;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.util.SystemUtil;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
+
+/**
+ * Loads and saves the settings, as a properties file in the user's config
+ * directory.
+ *
+ * The whole store is defensive: a missing file, garbage values or an
+ * unwritable directory degrade to the defaults instead of breaking the
+ * app, because the automation must be able to start no matter what.
+ * Writing goes through a temp file and an atomic move, so that a crash
+ * mid-save can never leave a truncated settings file behind.
+ */
+public class ConfigStore {
+
+    private static final Logger LOGGER = LogManager.getLogger(ConfigStore.class);
+
+    static final String KEY_AWAY_THRESHOLD_SECONDS = "away.threshold.seconds";
+    static final String KEY_MOVE_INTERVAL_SECONDS = "move.interval.seconds";
+    static final String KEY_STEP_DELAY_MILLISECONDS = "move.step.delay.milliseconds";
+    static final String KEY_CLICK_ENABLED = "click.enabled";
+    static final String KEY_CLICK_EVERY_N_MOVES = "click.every.n.moves";
+    static final String KEY_MOVEMENT_SCREEN = "move.screen";
+    static final String KEY_START_AUTOMATICALLY = "automation.start.automatically";
+    static final String KEY_HOTKEY_ENABLED = "hotkey.enabled";
+
+    private final Path file;
+
+    /** A store reading the standard settings file of the host platform. */
+    public ConfigStore() {
+        this(SystemUtil.getAppConfigDir().resolve("autosqueal.properties"));
+    }
+
+    /** A store reading the given file; used by the tests. */
+    public ConfigStore(Path file) {
+        this.file = file;
+    }
+
+    /** Reads the settings, falling back to the defaults for anything missing or broken. */
+    public AutoSquealConfig load() {
+        AutoSquealConfig config = new AutoSquealConfig();
+
+        if (!Files.isRegularFile(file)) {
+            LOGGER.info("No settings file yet, using the defaults");
+            return config;
+        }
+
+        Properties properties = new Properties();
+        try (InputStream input = Files.newInputStream(file)) {
+            properties.load(input);
+        } catch (IOException ex) {
+            LOGGER.warn("Could not read the settings file, using the defaults", ex);
+            return config;
+        }
+
+        readInt(properties, KEY_AWAY_THRESHOLD_SECONDS, config::setAwayThresholdSeconds);
+        readInt(properties, KEY_MOVE_INTERVAL_SECONDS, config::setMoveIntervalSeconds);
+        readInt(properties, KEY_STEP_DELAY_MILLISECONDS, config::setStepDelayMilliseconds);
+        readInt(properties, KEY_CLICK_EVERY_N_MOVES, config::setClickEveryNMoves);
+        readBoolean(properties, KEY_CLICK_ENABLED, config::setClickEnabled);
+        readBoolean(properties, KEY_START_AUTOMATICALLY, config::setStartAutomatically);
+        readBoolean(properties, KEY_HOTKEY_ENABLED, config::setHotkeyEnabled);
+        readEnum(properties, KEY_MOVEMENT_SCREEN, ScreenArea.class, config::setMovementScreen);
+
+        return config;
+    }
+
+    /** Writes the settings atomically, so that readers never see a half-written file. */
+    public void save(AutoSquealConfig config) {
+        Map<String, String> entries = new TreeMap<>();
+        entries.put(KEY_AWAY_THRESHOLD_SECONDS, String.valueOf(config.getAwayThresholdSeconds()));
+        entries.put(KEY_MOVE_INTERVAL_SECONDS, String.valueOf(config.getMoveIntervalSeconds()));
+        entries.put(KEY_STEP_DELAY_MILLISECONDS, String.valueOf(config.getStepDelayMilliseconds()));
+        entries.put(KEY_CLICK_ENABLED, String.valueOf(config.isClickEnabled()));
+        entries.put(KEY_CLICK_EVERY_N_MOVES, String.valueOf(config.getClickEveryNMoves()));
+        entries.put(KEY_MOVEMENT_SCREEN, String.valueOf(config.getMovementScreen()));
+        entries.put(KEY_START_AUTOMATICALLY, String.valueOf(config.isStartAutomatically()));
+        entries.put(KEY_HOTKEY_ENABLED, String.valueOf(config.isHotkeyEnabled()));
+
+        try {
+            Path directory = file.toAbsolutePath().getParent();
+            Files.createDirectories(directory);
+            Path tempFile = Files.createTempFile(directory, "autosqueal-", ".tmp");
+
+            try (BufferedWriter writer = Files.newBufferedWriter(tempFile)) {
+                writer.write("# autosqueal settings, rewritten by the app when the settings change");
+                writer.newLine();
+                for (Map.Entry<String, String> entry : entries.entrySet()) {
+                    writer.write(entry.getKey());
+                    writer.write("=");
+                    writer.write(entry.getValue());
+                    writer.newLine();
+                }
+            }
+
+            try {
+                Files.move(tempFile, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            } catch (AtomicMoveNotSupportedException ex) {
+                Files.move(tempFile, file, StandardCopyOption.REPLACE_EXISTING);
+            }
+        } catch (IOException ex) {
+            LOGGER.error("Could not save the settings", ex);
+        }
+    }
+
+    private static void readInt(Properties properties, String key, IntConsumer setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        try {
+            setter.accept(Integer.parseInt(value.trim()));
+        } catch (NumberFormatException ex) {
+            LOGGER.warn("Ignoring invalid value for {}: {}", key, value);
+        }
+    }
+
+    private static void readBoolean(Properties properties, String key, Consumer<Boolean> setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        String normalized = value.trim();
+        if ("true".equalsIgnoreCase(normalized)) {
+            setter.accept(true);
+        } else if ("false".equalsIgnoreCase(normalized)) {
+            setter.accept(false);
+        } else {
+            LOGGER.warn("Ignoring invalid value for {}: {}", key, value);
+        }
+    }
+
+    private static <E extends Enum<E>> void readEnum(Properties properties, String key, Class<E> type, Consumer<E> setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        try {
+            setter.accept(Enum.valueOf(type, value.trim()));
+        } catch (IllegalArgumentException ex) {
+            LOGGER.warn("Ignoring unknown value for {}: {}", key, value);
+        }
+    }
+}

src/main/java/wtf/beatrice/autosqueal/config/ScreenArea.java

@@ -0,0 +1,13 @@
+package wtf.beatrice.autosqueal.config;
+
+/**
+ * Which screens the automation is allowed to move the cursor to.
+ */
+public enum ScreenArea {
+
+    /** The main screen only, as the app has always used. */
+    PRIMARY,
+
+    /** Every connected screen, treated as one big virtual screen. */
+    ALL
+}

src/main/java/wtf/beatrice/autosqueal/controls/CursorMover.java

@@ -2,7 +2,7 @@ package wtf.beatrice.autosqueal.controls;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import wtf.beatrice.autosqueal.util.RunnerUtil;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 
 import java.awt.*;
 import java.security.SecureRandom;
@@ -10,10 +10,11 @@ import java.util.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.function.BooleanSupplier;
+import java.util.function.Supplier;
 
 /**
  * Periodically starts a new movement of the mouse cursor to a random position,
- * or to the top-right corner of the screen for a double click.
+ * or to the top-right corner of the main screen for a double click.
  *
  * The movements only happen when the user is away: while the user is actively
  * using the machine, they are skipped, so the app never fights for the mouse.
@@ -21,64 +22,119 @@ import java.util.function.BooleanSupplier;
  * the user is still away at every step, and gives the mouse back when they
  * are not.
  *
- * The movement itself is executed by a {@link SingleStepMovementTask}, which
+ * Everything that varies — how often to move, how fast, whether and how
- * runs on its own virtual thread until it reaches its destination.
+ * often to click, which screens to travel — comes from the settings, which
+ * are read live at every movement. The movement itself is executed by a
+ * {@link SingleStepMovementTask}, which runs on its own virtual thread
+ * until it reaches its destination.
  */
-public class CursorMover implements Runnable
+public class CursorMover implements Runnable {
-{
+
     private static final Logger LOGGER = LogManager.getLogger(CursorMover.class);
 
-    private static final int LOOPS_BEFORE_CLICK = 5;
+    /**
+     * Notified of the automation's own timing, for the live status view.
+     * Called on the scheduler thread: implementations marshal to their
+     * own thread.
+     */
+    public interface Listener {
 
-    private final Random random = new SecureRandom();
+        /** Called at every scheduled tick of the movement cadence. */
+        default void onTick() { }
+
+        /** Called when a movement was actually queued for execution. */
+        default void onMovementQueued(int destX, int destY, boolean click) { }
+    }
+
+    /** Distance from the screen edge, so the corner click lands inside the screen. */
+    private static final int CORNER_OFFSET_PIXELS = 5;
+
+    private final Random random;
     private final ExecutorService movementExecutor;
     private final RobotMouseTracker robotTracker;
     private final BooleanSupplier isUserAway;
+    private final AutoSquealConfig config;
+    private final Supplier<Rectangle> movementBounds;
+    private final Supplier<Rectangle> primaryScreenBounds;
+    private final Supplier<Point> currentPosition;
+    private volatile Listener listener;
 
+    /** Movements started since the last corner click. */
     private int iteration = 0;
 
-    public CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker, BooleanSupplier isUserAway) {
+    /** Sets the listener notified of ticks and queued movements. */
+    public void setListener(Listener listener) {
+        this.listener = listener;
+    }
+
+    public CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker,
+                       BooleanSupplier isUserAway, AutoSquealConfig config,
+                       Supplier<Rectangle> movementBounds, Supplier<Rectangle> primaryScreenBounds) {
+        this(movementExecutor, robotTracker, isUserAway, config, movementBounds, primaryScreenBounds,
+                new SecureRandom(), () -> MouseInfo.getPointerInfo().getLocation());
+    }
+
+    CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker,
+                BooleanSupplier isUserAway, AutoSquealConfig config,
+                Supplier<Rectangle> movementBounds, Supplier<Rectangle> primaryScreenBounds,
+                Random random, Supplier<Point> currentPosition) {
         this.movementExecutor = movementExecutor;
         this.robotTracker = robotTracker;
         this.isUserAway = isUserAway;
+        this.config = config;
+        this.movementBounds = movementBounds;
+        this.primaryScreenBounds = primaryScreenBounds;
+        this.random = random;
+        this.currentPosition = currentPosition;
     }
 
     @Override
     public void run() {
 
+        if (listener != null) {
+            listener.onTick();
+        }
+
         if (!isUserAway.getAsBoolean()) {
             LOGGER.debug("User is present, skipping movement");
             return;
         }
 
-        Point location = MouseInfo.getPointerInfo().getLocation();
+        Point location = currentPosition.get();
         LOGGER.info("Starting coordinates: {}, {}", location.x, location.y);
 
         int destX;
         int destY;
         boolean click;
 
-        if (iteration == LOOPS_BEFORE_CLICK) {
+        // one movement every N is a corner double click, so that the
-            destX = RunnerUtil.SCREEN_WIDTH - 5;
+        // notification area gets exercised too. the corner is always the
-            destY = 5;
+        // main screen's top-right one, whatever screens the cursor may
+        // otherwise travel to.
+        if (config.isClickEnabled() && iteration == config.getClickEveryNMoves() - 1) {
+            Rectangle primary = primaryScreenBounds.get();
+            destX = primary.x + primary.width - CORNER_OFFSET_PIXELS;
+            destY = primary.y + CORNER_OFFSET_PIXELS;
             click = true;
-
             iteration = 0;
         } else {
-            destX = random.nextInt(RunnerUtil.SCREEN_WIDTH);
+            Rectangle bounds = movementBounds.get();
-            destY = random.nextInt(RunnerUtil.SCREEN_HEIGHT);
+            destX = bounds.x + random.nextInt(Math.max(1, bounds.width));
+            destY = bounds.y + random.nextInt(Math.max(1, bounds.height));
             click = false;
-
             iteration++;
         }
 
         LOGGER.info("Destination coordinates: {}, {}", destX, destY);
 
         try {
-            SingleStepMovementTask movement = new SingleStepMovementTask(robotTracker, destX, destY, click, isUserAway);
+            SingleStepMovementTask movement = new SingleStepMovementTask(
+                    robotTracker, destX, destY, click, isUserAway,
+                    config.getStepDelayMilliseconds(), location);
             movementExecutor.execute(movement);
-        } catch (AWTException ex) {
+            if (listener != null) {
-            LOGGER.error("Could not start movement task", ex);
+                listener.onMovementQueued(destX, destY, click);
+            }
         } catch (RejectedExecutionException ex) {
             LOGGER.debug("Movement not started: automation is shutting down");
         }

src/main/java/wtf/beatrice/autosqueal/controls/SingleStepMovementTask.java

@@ -25,33 +25,31 @@ public class SingleStepMovementTask implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(SingleStepMovementTask.class);
 
-    /** Delay between two consecutive cursor steps, in milliseconds. */
-    private static final long STEP_DELAY_MILLISECONDS = 2L;
-
     private final RobotMouseTracker robotTracker;
-    private final Robot robot;
     private final int destX;
     private final int destY;
     private final boolean click;
     private final BooleanSupplier userIsAway;
+    private final long stepDelayMilliseconds;
 
     private float currentX;
     private float currentY;
     private float stepX;
     private float stepY;
 
-    public SingleStepMovementTask(RobotMouseTracker robotTracker, int destinationX, int destinationY, boolean click,
+    public SingleStepMovementTask(RobotMouseTracker robotTracker, int destinationX, int destinationY,
-                                  BooleanSupplier userIsAway) throws AWTException {
+                                  boolean click, BooleanSupplier userIsAway, long stepDelayMilliseconds,
+                                  Point start) {
 
         this.robotTracker = robotTracker;
         this.destX = destinationX;
         this.destY = destinationY;
         this.click = click;
         this.userIsAway = userIsAway;
+        this.stepDelayMilliseconds = stepDelayMilliseconds;
 
-        Point location = MouseInfo.getPointerInfo().getLocation();
+        this.currentX = start.x;
-        this.currentX = location.x;
+        this.currentY = start.y;
-        this.currentY = location.y;
 
         int lengthX = Math.round(Math.abs(currentX - destX));
         int lengthY = Math.round(Math.abs(currentY - destY));
@@ -61,13 +59,22 @@ public class SingleStepMovementTask implements Runnable {
 
         LOGGER.info("Dest: [{}, {}], Curr: [{}, {}]", destX, destY, currentX, currentY);
         LOGGER.info("Step: [{}, {}]", stepX, stepY);
-
-        this.robot = new Robot();
     }
 
     @Override
     public void run() {
 
+        // the robot is created here, not in the constructor: building a
+        // movement must never touch the system on its own, or there would be
+        // no way to queue one for testing or display without moving a mouse
+        Robot robot;
+        try {
+            robot = new Robot();
+        } catch (AWTException ex) {
+            LOGGER.error("Could not create a robot, skipping this movement", ex);
+            return;
+        }
+
         // any position change from here on is the app's doing
         robotTracker.moveStarted();
 
@@ -91,10 +98,10 @@ public class SingleStepMovementTask implements Runnable {
 
                 robot.mouseMove(Math.round(currentX), Math.round(currentY));
 
-                Thread.sleep(STEP_DELAY_MILLISECONDS);
+                Thread.sleep(stepDelayMilliseconds);
             }
 
-            onDestinationReached();
+            onDestinationReached(robot);
         } catch (InterruptedException ex) {
             // the movement was interrupted: the automation was stopped, so
             // just end the movement here
@@ -111,13 +118,13 @@ public class SingleStepMovementTask implements Runnable {
         return Math.round(currentX) == destX && Math.round(currentY) == destY;
     }
 
-    private void onDestinationReached() throws InterruptedException {
+    private void onDestinationReached(Robot robot) throws InterruptedException {
         LOGGER.info("Reached destination [{}, {}], stopping mover", destX, destY);
 
         robotTracker.moveEnded(destX, destY);
 
         if (click) {
-            performClickSequence();
+            performClickSequence(robot);
         }
     }
 
@@ -125,7 +132,7 @@ public class SingleStepMovementTask implements Runnable {
      * Performs a double click with the same pacing the app has always used:
      * press at +500ms, release at +700ms, press at +1200ms, release at +1400ms.
      */
-    private void performClickSequence() throws InterruptedException {
+    private void performClickSequence(Robot robot) throws InterruptedException {
         Thread.sleep(500L);
         robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
         Thread.sleep(200L);
@@ -183,4 +190,18 @@ public class SingleStepMovementTask implements Runnable {
         }
         return current;
     }
+
+    // package-private: read by the tests, and soon by the live status view
+
+    int getDestX() {
+        return destX;
+    }
+
+    int getDestY() {
+        return destY;
+    }
+
+    boolean isClick() {
+        return click;
+    }
 }

src/main/java/wtf/beatrice/autosqueal/listener/CursorMoveListener.java

@@ -2,41 +2,50 @@ package wtf.beatrice.autosqueal.listener;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
 
 import java.awt.*;
+import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 
 /**
- * Watches the cursor position and tracks whether the user is away: if the cursor
+ * Watches the cursor position and tracks whether the user is away: if the
- * stays still for long enough — ignoring the movements the app performs on its
+ * user has not touched mouse or keyboard for long enough — ignoring the
- * own — the user is considered away. Keyboard activity counts as presence,
+ * movements the app performs on its own — the user is considered away.
- * too: a user who is typing is using the machine, even if the mouse never moves.
+ * Keyboard activity counts as presence, too: a user who is typing is using
+ * the machine, even if the mouse never moves.
+ *
+ * The away state is time-based: how long the user has been idle is compared
+ * against the threshold at every poll, so a threshold changed on the fly
+ * applies from the very next poll.
  */
 public class CursorMoveListener implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(CursorMoveListener.class);
 
-    /** Number of consecutive still polls after which the user is considered away. */
-    private static final int LOOPS_BEFORE_AWAY = 30;
-
     private final RobotMouseTracker robotTracker;
     private final Supplier<Point> currentPosition;
+    private final AutoSquealConfig config;
+    private final LongSupplier clock;
 
     private int lastSeenX;
     private int lastSeenY;
     private boolean firstPoll = true;
-    private int loops = 0;
+    private long lastUserActivityTime;
     private volatile boolean userAway = false;
     private volatile boolean keyboardActivity = false;
 
-    public CursorMoveListener(RobotMouseTracker robotTracker) {
+    public CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config) {
-        this(robotTracker, () -> MouseInfo.getPointerInfo().getLocation());
+        this(robotTracker, config, () -> MouseInfo.getPointerInfo().getLocation(), System::currentTimeMillis);
     }
 
-    CursorMoveListener(RobotMouseTracker robotTracker, Supplier<Point> currentPosition) {
+    CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config,
+                       Supplier<Point> currentPosition, LongSupplier clock) {
         this.robotTracker = robotTracker;
+        this.config = config;
         this.currentPosition = currentPosition;
+        this.clock = clock;
     }
 
     /**
@@ -56,13 +65,15 @@ public class CursorMoveListener implements Runnable {
         this.keyboardActivity = false;
 
         Point location = currentPosition.get();
+        long now = clock.getAsLong();
 
         if (firstPoll) {
-            // seed the comparison baseline, so that the first poll is not
+            // seed the comparison baseline and the activity clock, so that
-            // mistaken for a movement
+            // the first poll is neither a movement nor a full idle period
             firstPoll = false;
             lastSeenX = location.x;
             lastSeenY = location.y;
+            lastUserActivityTime = now;
             return;
         }
 
@@ -70,18 +81,16 @@ public class CursorMoveListener implements Runnable {
         boolean userMoved = keyboardActivity || (positionChanged && !isAppMovement(location));
 
         if (userMoved) {
-            if (userAway) {
+            lastUserActivityTime = now;
-                LOGGER.info("User is no longer away!");
-            }
-            loops = 0;
-        } else if (loops < LOOPS_BEFORE_AWAY) {
-            loops++;
-            if (loops == LOOPS_BEFORE_AWAY) {
-                LOGGER.info("User is away!");
-            }
         }
 
-        userAway = loops >= LOOPS_BEFORE_AWAY;
+        boolean away = now - lastUserActivityTime >= config.getAwayThresholdSeconds() * 1000L;
+        if (away && !userAway) {
+            LOGGER.info("User is away!");
+        } else if (!away && userAway) {
+            LOGGER.info("User is no longer away!");
+        }
+        userAway = away;
 
         lastSeenX = location.x;
         lastSeenY = location.y;

src/main/java/wtf/beatrice/autosqueal/listener/KeyPressListener.java

@@ -4,16 +4,34 @@ import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
 import com.github.kwhat.jnativehook.keyboard.NativeKeyListener;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import wtf.beatrice.autosqueal.Main;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class KeyPressListener implements NativeKeyListener
+/**
-{
+ * Listens for the global toggle hotkey, and reports every key press to the
+ * away detection: a user who is typing is present, hotkey or not.
+ *
+ * The listener is fully decoupled: it receives the actions to run instead
+ * of reaching into the main window, so it can be wired — and tested — on
+ * its own.
+ */
+public class KeyPressListener implements NativeKeyListener {
+
     private static final Logger LOGGER = LogManager.getLogger(KeyPressListener.class);
+
+    private final Runnable toggleAction;
+    private final Runnable keyboardActivityReporter;
+    private final AutoSquealConfig config;
     private final List<Integer> pressedKeys = new ArrayList<>();
 
+    public KeyPressListener(Runnable toggleAction, Runnable keyboardActivityReporter, AutoSquealConfig config) {
+        this.toggleAction = toggleAction;
+        this.keyboardActivityReporter = keyboardActivityReporter;
+        this.config = config;
+    }
+
     @Override
     public void nativeKeyPressed(NativeKeyEvent e) {
         // the OS fires repeated "press" events while a key is being held down; ignore them,
@@ -27,18 +45,22 @@ public class KeyPressListener implements NativeKeyListener
 
         // any key the user presses means they are present: let the away
         // detection know, so the app doesn't grab the mouse while they type
-        Main.getMainWindow().notifyKeyboardActivity();
+        keyboardActivityReporter.run();
+
+        if (!config.isHotkeyEnabled()) {
+            return;
+        }
 
         // toggle only when the second key of the combo is pressed down: not only does this
         // fire exactly once per combo, but it also avoids toggling when any other key is
         // pressed or released while ctrl+alt happen to be held down
         if ((e.getKeyCode() == NativeKeyEvent.VC_CONTROL && pressedKeys.contains(NativeKeyEvent.VC_ALT))
                 || (e.getKeyCode() == NativeKeyEvent.VC_ALT && pressedKeys.contains(NativeKeyEvent.VC_CONTROL))) {
-            LOGGER.warn("Received shutdown keystroke: [{}][{}]",
+            LOGGER.info("Received toggle hotkey: [{}][{}]",
                     NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL),
                     NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT));
 
-            Main.getMainWindow().toggleRunning();
+            toggleAction.run();
         }
     }
 

src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java

@@ -1,11 +1,16 @@
 package wtf.beatrice.autosqueal.ui;
 
 import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
+import net.miginfocom.swing.MigLayout;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import wtf.beatrice.autosqueal.Main;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+import wtf.beatrice.autosqueal.config.ConfigStore;
+import wtf.beatrice.autosqueal.config.ScreenArea;
 import wtf.beatrice.autosqueal.controls.CursorMover;
 import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
+import wtf.beatrice.autosqueal.controls.SingleStepMovementTask;
 import wtf.beatrice.autosqueal.listener.CursorMoveListener;
 import wtf.beatrice.autosqueal.util.RunnerUtil;
 import wtf.beatrice.autosqueal.util.SystemUtil;
@@ -15,56 +20,121 @@ import java.awt.*;
 import java.awt.desktop.QuitStrategy;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
+import java.awt.image.BaseMultiResolutionImage;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
+import java.util.Date;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+public class MainWindow {
 
-public class MainWindow
-{
     private static final Logger LOGGER = LogManager.getLogger(MainWindow.class);
 
-    private static final int WINDOW_HEIGHT = 700;
-    private static final int WINDOW_WIDTH = 800;
-
     private static final long AUTOMATION_START_DELAY_SECONDS = 1L;
     private static final long AWAY_POLL_INTERVAL_SECONDS = 1L;
 
-    private final JFrame frame = new JFrame();
+    private static final Color RUNNING_COLOR = new Color(0x3F, 0xB9, 0x50);
-    private JButton toggleButton;
+
+    private final AutoSquealConfig config;
+    private final ConfigStore configStore;
 
     // the away detection tracks the user, not the automation: it lives from
     // the window's creation and is polled only while the automation runs
-    private final RobotMouseTracker robotTracker = new RobotMouseTracker();
+    private final RobotMouseTracker robotTracker;
-    private final CursorMoveListener awayDetector = new CursorMoveListener(robotTracker);
+    private final CursorMoveListener awayDetector;
 
-    private ScheduledExecutorService periodicScheduler;
+    private final JFrame frame = new JFrame();
-    private ExecutorService movementExecutor;
+
-    private CursorMover cursorMover;
+    // status
+    private JLabel statusPill;
+    private JLabel userStateLabel;
+    private JLabel nextMoveLabel;
+    private JLabel movesLabel;
+    private JButton toggleButton;
+    private JButton moveNowButton;
+
+    // settings
+    private JSpinner awaySpinner;
+    private JSpinner intervalSpinner;
+    private JSlider stepPauseSlider;
+    private JCheckBox clickCheckBox;
+    private JSpinner clickEverySpinner;
+    private JComboBox<ScreenArea> screenCombo;
+    private JCheckBox startAutoCheckBox;
+    private JCheckBox hotkeyCheckBox;
 
     private TrayIcon trayIcon;
     private MenuItem trayToggleItem;
 
-    /** Whether cleanup already ran, so it can safely be called twice. */
+    private ScheduledExecutorService periodicScheduler;
-    private boolean cleanedUp = false;
+    private ExecutorService movementExecutor;
+    private CursorMover cursorMover;
+    private ScheduledFuture<?> moverFuture;
+
+    /** When the movement cadence last ticked; drives the countdown. */
+    private volatile long lastMovementTickAt = 0L;
+
+    // status state: only touched on the EDT
+    private long sessionMoves = 0;
+    private String lastMoveAt = null;
+
+    /** Updates the status section once per second. */
+    private final javax.swing.Timer statusTimer = new javax.swing.Timer(1000, e -> refreshStatus());
+
+    /** Counts the automation's own movements, wherever they come from. */
+    private final CursorMover.Listener movementListener = new CursorMover.Listener() {
+        @Override
+        public void onTick() {
+            lastMovementTickAt = System.currentTimeMillis();
+        }
+
+        @Override
+        public void onMovementQueued(int destX, int destY, boolean click) {
+            SwingUtilities.invokeLater(() -> {
+                sessionMoves++;
+                lastMoveAt = String.format("%tT", new Date());
+            });
+        }
+    };
 
     /**
-     * Builds and shows the main window, and starts the automation.
+     * Creates the window around the given settings: the components read
-     * Must be called on the EDT.
+     * them live, so a change applies without a restart. The store is used
+     * to persist the settings as soon as the user changes them.
+     */
+    public MainWindow(AutoSquealConfig config, ConfigStore configStore) {
+        this.config = config;
+        this.configStore = configStore;
+        this.robotTracker = new RobotMouseTracker();
+        this.awayDetector = new CursorMoveListener(robotTracker, config);
+    }
+
+    /**
+     * Builds and shows the main window, and starts the automation if the
+     * settings say so. Must be called on the EDT.
      */
     public void init() {
 
-        frame.setSize(new Dimension(WINDOW_WIDTH, WINDOW_HEIGHT));
         frame.setTitle("autosqueal");
         frame.setResizable(false);
         frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
         frame.addWindowListener(new WindowAdapter() {
             @Override
             public void windowClosing(WindowEvent e) {
+                statusTimer.stop();
                 cleanup();
             }
+
+            @Override
+            public void windowActivated(WindowEvent e) {
+                // catch a system appearance change while the app was inactive
+                ThemeManager.reapplyIfSystemThemeChanged();
+            }
         });
 
         // ⌘Q on macOS defaults to calling System.exit(0) directly, which
@@ -78,62 +148,358 @@ public class MainWindow
             }
         }
 
-        toggleButton = new JButton();
+        buildContent();
-        toggleButton.setBounds(new Rectangle((WINDOW_WIDTH / 2) - 60, WINDOW_HEIGHT - 60, 120, 30));
-        toggleButton.addActionListener(e -> toggleRunning());
-        frame.add(toggleButton);
-
-        int bordersPx = 10;
-        int rescaleRateo = ((WINDOW_WIDTH - (2 * bordersPx)) * 100) / RunnerUtil.SCREEN_WIDTH;
-        int rescaleWidth = RunnerUtil.SCREEN_WIDTH * rescaleRateo / 100;
-        int rescaleHeight = RunnerUtil.SCREEN_HEIGHT * rescaleRateo / 100;
-        JLabel imageLabel = new JLabel(new ImageIcon(getScreenCapture(rescaleWidth, rescaleHeight)));
-        imageLabel.setBounds(new Rectangle(bordersPx, bordersPx, rescaleWidth, rescaleHeight));
-        frame.add(imageLabel);
-
-        Image preciseScreenshot = getPreciseScreenshot();
-        JLabel timestampLabel = new JLabel(new ImageIcon(preciseScreenshot));
-        timestampLabel.setBounds(new Rectangle(bordersPx, bordersPx + rescaleHeight + bordersPx, 100, 30));
-        frame.add(timestampLabel);
-
-        frame.setLayout(null);
-        frame.setVisible(true);
 
         if (SystemTray.isSupported()) {
             addTrayIcon();
         }
 
+        if (config.isStartAutomatically()) {
             startAutomation();
+        }
+        updateToggleLabel();
+        refreshStatus();
+        statusTimer.start();
+
+        frame.pack();
+        frame.setLocationRelativeTo(null);
+        frame.setVisible(true);
+    }
+
+    // ── layout ──────────────────────────────────────────────────────────
+
+    private void buildContent() {
+
+        MigLayout layout = new MigLayout("wrap 1, insets 16, gap 6", "[grow]");
+        JPanel root = new JPanel(layout);
+
+        root.add(buildHeader(), "growx");
+        root.add(buildStatusSection(), "growx");
+        root.add(buildSettingsSection(), "growx");
+        root.add(buildFooter(), "growx");
+
+        frame.setContentPane(root);
+    }
+
+    private JPanel buildHeader() {
+        JPanel header = new JPanel(new MigLayout("insets 0, gap 0", "[][grow, right]"));
+
+        JLabel titleLabel = new JLabel("autosqueal");
+        titleLabel.setFont(titleLabel.getFont().deriveFont(20f));
+
+        JLabel subtitleLabel = new JLabel("moves the mouse only when you're away");
+        subtitleLabel.setForeground(UIManager.getColor("Label.disabledForeground"));
+
+        statusPill = new JLabel("○ paused");
+        statusPill.setForeground(UIManager.getColor("Label.disabledForeground"));
+
+        header.add(titleLabel, "cell 0 0, aligny top");
+        header.add(statusPill, "cell 1 0, aligny top");
+        header.add(subtitleLabel, "cell 0 1");
+        return header;
+    }
+
+    private JPanel buildStatusSection() {
+        JPanel status = new JPanel(new MigLayout("wrap 1, insets 10 14 14 14, gap 4"));
+        status.setBorder(BorderFactory.createTitledBorder("status"));
+
+        userStateLabel = new JLabel("you are here");
+        nextMoveLabel = new JLabel("—");
+        movesLabel = new JLabel("no moves yet");
+
+        toggleButton = new JButton("Start");
+        toggleButton.addActionListener(e -> toggleRunning());
+
+        moveNowButton = new JButton("Move now");
+        moveNowButton.setToolTipText("queues a single small movement, ignoring the away detection: to test permissions");
+        moveNowButton.addActionListener(e -> moveNow());
+
+        JPanel buttons = new JPanel(new MigLayout("insets 0, gap 8"));
+        buttons.add(toggleButton, "width 120:120:120, height 30:30:30");
+        buttons.add(moveNowButton);
+
+        status.add(userStateLabel);
+        status.add(nextMoveLabel);
+        status.add(movesLabel);
+        status.add(buttons, "gaptop 8");
+        return status;
+    }
+
+    private JPanel buildSettingsSection() {
+        JPanel settings = new JPanel(new MigLayout("wrap 2, insets 10 14 14 14, gap 6 12", "[][right]", ""));
+        settings.setBorder(BorderFactory.createTitledBorder("settings"));
+
+        // away detection
+        settings.add(new JLabel("Consider the user away after (seconds)"));
+        awaySpinner = new JSpinner(new SpinnerNumberModel(config.getAwayThresholdSeconds(),
+                AutoSquealConfig.AWAY_THRESHOLD_MIN_SECONDS, AutoSquealConfig.AWAY_THRESHOLD_MAX_SECONDS, 1));
+        awaySpinner.addChangeListener(e -> applySetting(() ->
+                config.setAwayThresholdSeconds(spinnerValue(awaySpinner))));
+        settings.add(awaySpinner, "width 90:90:90, wrap");
+
+        // movement cadence
+        settings.add(new JLabel("Move every (seconds)"));
+        intervalSpinner = new JSpinner(new SpinnerNumberModel(config.getMoveIntervalSeconds(),
+                AutoSquealConfig.MOVE_INTERVAL_MIN_SECONDS, AutoSquealConfig.MOVE_INTERVAL_MAX_SECONDS, 1));
+        intervalSpinner.addChangeListener(e -> {
+            applySetting(() -> config.setMoveIntervalSeconds(spinnerValue(intervalSpinner)));
+            rescheduleMoverInterval();
+        });
+        settings.add(intervalSpinner, "width 90:90:90, wrap");
+
+        // movement speed: the slider shows the speed, from slow (left) to
+        // fast (right) — internally it is the step pause, read upside down
+        int fastest = AutoSquealConfig.STEP_DELAY_MIN_MILLISECONDS;
+        int slowest = AutoSquealConfig.STEP_DELAY_MAX_MILLISECONDS;
+        settings.add(new JLabel("Movement speed"));
+        stepPauseSlider = new JSlider(fastest, slowest, slowest + fastest - config.getStepDelayMilliseconds());
+        stepPauseSlider.addChangeListener(e -> applySetting(() ->
+                config.setStepDelayMilliseconds(slowest + fastest - stepPauseSlider.getValue())));
+        settings.add(stepPauseSlider, "width 140:160:180, wrap");
+
+        // corner clicks
+        settings.add(new JLabel("Click the notification corner"));
+        clickCheckBox = new JCheckBox("", config.isClickEnabled());
+        clickCheckBox.addChangeListener(e -> applySetting(() -> config.setClickEnabled(clickCheckBox.isSelected())));
+        settings.add(clickCheckBox, "wrap");
+
+        settings.add(new JLabel("One corner click every (moves)"));
+        clickEverySpinner = new JSpinner(new SpinnerNumberModel(config.getClickEveryNMoves(),
+                AutoSquealConfig.CLICK_EVERY_MIN_MOVES, AutoSquealConfig.CLICK_EVERY_MAX_MOVES, 1));
+        clickEverySpinner.addChangeListener(e -> applySetting(() ->
+                config.setClickEveryNMoves(spinnerValue(clickEverySpinner))));
+        settings.add(clickEverySpinner, "width 90:90:90, wrap");
+        clickCheckBox.addChangeListener(e -> clickEverySpinner.setEnabled(clickCheckBox.isSelected()));
+        clickEverySpinner.setEnabled(clickCheckBox.isSelected());
+
+        // screen
+        settings.add(new JLabel("Travel to"));
+        screenCombo = new JComboBox<>(ScreenArea.values());
+        screenCombo.setRenderer(new DefaultListCellRenderer() {
+            @Override
+            public Component getListCellRendererComponent(JList<?> list, Object value, int index,
+                                                         boolean isSelected, boolean cellHasFocus) {
+                return super.getListCellRendererComponent(list, screenName((ScreenArea) value),
+                        index, isSelected, cellHasFocus);
+            }
+        });
+        screenCombo.setSelectedItem(config.getMovementScreen());
+        screenCombo.addActionListener(e -> applySetting(() ->
+                config.setMovementScreen((ScreenArea) screenCombo.getSelectedItem())));
+        settings.add(screenCombo, "width 140:140:140, wrap");
+
+        // startup
+        settings.add(new JLabel("Start the automation at launch"));
+        startAutoCheckBox = new JCheckBox("", config.isStartAutomatically());
+        startAutoCheckBox.addChangeListener(e -> applySetting(() ->
+                config.setStartAutomatically(startAutoCheckBox.isSelected())));
+        settings.add(startAutoCheckBox, "wrap");
+
+        // hotkey
+        settings.add(new JLabel("Global toggle hotkey"));
+        JPanel hotkeyPanel = new JPanel(new MigLayout("insets 0, gap 8", "[]push[]", ""));
+        hotkeyCheckBox = new JCheckBox("enabled", config.isHotkeyEnabled());
+        hotkeyCheckBox.addChangeListener(e -> applySetting(() ->
+                config.setHotkeyEnabled(hotkeyCheckBox.isSelected())));
+        String hotkey = "[" + NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL) + "]"
+                + "[" + NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT) + "]";
+        hotkeyPanel.add(hotkeyCheckBox);
+        hotkeyPanel.add(new JLabel(hotkey));
+        settings.add(hotkeyPanel, "wrap");
+
+        return settings;
+    }
+
+    private String screenName(ScreenArea area) {
+        return area == ScreenArea.ALL ? "all screens" : "the main screen";
+    }
+
+    private JComponent buildFooter() {
+        JLabel footer = new JLabel("settings are saved as they change · ⌘Q or the tray icon quits");
+        footer.setFont(footer.getFont().deriveFont(11f));
+        footer.setForeground(UIManager.getColor("Label.disabledForeground"));
+        footer.setHorizontalAlignment(SwingConstants.CENTER);
+        return footer;
+    }
+
+    // ── status ──────────────────────────────────────────────────────────
+
+    private void refreshStatus() {
+        boolean away = awayDetector.isUserAway();
+
+        userStateLabel.setText(away ? "● you are away" : "● you are here");
+        userStateLabel.setForeground(away ? RUNNING_COLOR : UIManager.getColor("Label.foreground"));
+
+        boolean running = cursorMover != null;
+        if (!running) {
+            nextMoveLabel.setText("automation is paused");
+        } else if (robotTracker.isMoving()) {
+            nextMoveLabel.setText("moving…");
+        } else {
+            long nextAt = lastMovementTickAt + config.getMoveIntervalSeconds() * 1000L;
+            long seconds = Math.max(0L, (nextAt - System.currentTimeMillis()) / 1000L);
+            nextMoveLabel.setText((away ? "next move in " : "next attempt in ") + seconds + "s");
+        }
+
+        movesLabel.setText(sessionMoves + " moves this session"
+                + (lastMoveAt == null ? "" : " · last at " + lastMoveAt));
+
         updateToggleLabel();
     }
 
-    private Image getScreenCapture(int rescaleWidth, int rescaleHeight) {
+    private void updateToggleLabel() {
-
+        if (toggleButton == null) {
-            Image fullImage = getScreenCapture();
+            // the window is not initialized yet
-            return fullImage.getScaledInstance(rescaleWidth, rescaleHeight, Image.SCALE_FAST);
+            return;
         }
 
-    public Image getPreciseScreenshot() {
+        boolean running = cursorMover != null;
+        toggleButton.setText(running ? "Pause" : "Start");
+        moveNowButton.setEnabled(running);
+        statusPill.setText(running ? "● running" : "○ paused");
+        statusPill.setForeground(running ? RUNNING_COLOR : UIManager.getColor("Label.disabledForeground"));
 
-        if(SystemUtil.getHostSystem().equals(SystemUtil.OperatingSystem.MAC_OS)) {
+        if (trayToggleItem != null) {
-            BufferedImage screenshot = getScreenCapture();
+            trayToggleItem.setLabel(running ? "Pause" : "Start");
-            return screenshot.getSubimage(RunnerUtil.SCREEN_WIDTH - 100,0, 100, 30);
+        }
     }
 
-        return null;
+    // ── settings plumbing ───────────────────────────────────────────────
+
+    /** Applies a setting change and persists it right away. */
+    private void applySetting(Runnable setter) {
+        setter.run();
+        configStore.save(config);
     }
 
-    public BufferedImage getScreenCapture() {
+    private static int spinnerValue(JSpinner spinner) {
-        try {
+        return (Integer) spinner.getValue();
-            Robot robot = new Robot();
-            return robot.createScreenCapture(new Rectangle(RunnerUtil.SCREEN_WIDTH, RunnerUtil.SCREEN_HEIGHT));
-        } catch (AWTException e) {
-            LOGGER.error("Robot initialization error", e);
     }
 
-        return null;
+    /**
+     * Re-schedules the movement cadence with the current interval, without
+     * stopping the automation: the away detection keeps running untouched.
+     */
+    private void rescheduleMoverInterval() {
+        if (cursorMover == null || periodicScheduler == null) {
+            return;
         }
 
+        if (moverFuture != null) {
+            moverFuture.cancel(false);
+        }
+        long interval = config.getMoveIntervalSeconds();
+        moverFuture = periodicScheduler.scheduleWithFixedDelay(cursorMover, interval, interval, TimeUnit.SECONDS);
+    }
+
+    // ── automation ──────────────────────────────────────────────────────
+
+    /** Queues a single small movement, ignoring the away detection: a test. */
+    private void moveNow() {
+        if (movementExecutor == null) {
+            return;
+        }
+
+        Rectangle bounds = RunnerUtil.screenBounds(ScreenArea.PRIMARY);
+        Point start = MouseInfo.getPointerInfo().getLocation();
+
+        int destX = Math.min(bounds.x + bounds.width - 20, start.x + 80);
+        int destY = Math.max(bounds.y + 20, start.y - 60);
+        if (destX == start.x && destY == start.y) {
+            // no visible movement otherwise
+            destX += 40;
+        }
+
+        // the test move ignores the away detection, or it would be
+        // abandoned at the first poll with the user present
+        SingleStepMovementTask movement = new SingleStepMovementTask(
+                robotTracker, destX, destY, false, () -> true,
+                config.getStepDelayMilliseconds(), start);
+        movementExecutor.execute(movement);
+
+        sessionMoves++;
+        lastMoveAt = String.format("%tT", new Date());
+    }
+
+    private void startAutomation() {
+        LOGGER.info("Starting automation");
+
+        // periodic work (polling and movement cadence) on a classic scheduler,
+        // so that it can be scheduled with fixed delays
+        periodicScheduler = Executors.newScheduledThreadPool(2, runnable -> {
+            Thread thread = new Thread(runnable, "autosqueal-scheduler");
+            thread.setDaemon(true);
+            return thread;
+        });
+
+        // movements and clicks run on virtual threads: they mostly sleep,
+        // and blocking them costs nothing
+        movementExecutor = Executors.newThreadPerTaskExecutor(
+                Thread.ofVirtual().name("autosqueal-movement-").factory());
+
+        // away-detection: polls the cursor position and ignores the movements
+        // the app performs itself, as reported by the robot mouse tracker.
+        // the automation only moves the mouse when the user is away.
+        periodicScheduler.scheduleWithFixedDelay(awayDetector, 0L, AWAY_POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
+
+        // the movement bounds are read again at every movement, so a change
+        // of setting applies from the next movement without a restart. the
+        // corner click always aims at the main screen, whatever screens the
+        // cursor may otherwise travel to.
+        Supplier<Rectangle> movementBounds = () -> RunnerUtil.screenBounds(config.getMovementScreen());
+        Supplier<Rectangle> primaryScreenBounds = () -> RunnerUtil.screenBounds(ScreenArea.PRIMARY);
+
+        cursorMover = new CursorMover(movementExecutor, robotTracker, awayDetector::isUserAway,
+                config, movementBounds, primaryScreenBounds);
+        cursorMover.setListener(movementListener);
+        lastMovementTickAt = System.currentTimeMillis();
+
+        moverFuture = periodicScheduler.scheduleWithFixedDelay(cursorMover,
+                AUTOMATION_START_DELAY_SECONDS,
+                config.getMoveIntervalSeconds(),
+                TimeUnit.SECONDS);
+    }
+
+    private void stopAutomation() {
+        LOGGER.info("Stopping automation");
+
+        if (moverFuture != null) {
+            moverFuture.cancel(false);
+            moverFuture = null;
+        }
+
+        if (periodicScheduler != null) {
+            periodicScheduler.shutdownNow();
+            periodicScheduler = null;
+        }
+
+        if (movementExecutor != null) {
+            // interrupts the in-flight movement threads, too
+            movementExecutor.shutdownNow();
+            movementExecutor = null;
+        }
+
+        cursorMover = null;
+    }
+
+    /**
+     * Toggles the automation on or off. Safe to call from any thread: the actual
+     * work is always marshalled to the EDT, since it touches Swing components.
+     */
+    public void toggleRunning() {
+        SwingUtilities.invokeLater(() -> {
+            if (cursorMover == null) {
+                startAutomation();
+            } else {
+                stopAutomation();
+            }
+            updateToggleLabel();
+            refreshStatus();
+        });
+    }
+
+    // ── tray ─────────────────────────────────────────────────────────────
+
     /**
      * Adds a menu bar icon with a toggle entry and a quit entry, so the
      * automation can be controlled even with the window closed.
@@ -147,11 +513,13 @@ public class MainWindow
 
         MenuItem quitItem = new MenuItem("Quit");
         quitItem.addActionListener(e -> {
+            statusTimer.stop();
             cleanup();
             System.exit(0);
         });
         menu.add(quitItem);
 
+        // multi-resolution, so the icon stays crisp on HiDPI screens
         trayIcon = new TrayIcon(createTrayIconImage(), "autosqueal", menu);
         trayIcon.setImageAutoSize(true);
 
@@ -164,24 +532,47 @@ public class MainWindow
         }
     }
 
-    /** Draws the little mouse pointer used as tray icon. */
+    /** Draws the mouse pointer used as tray icon, at the given pixel size. */
     private Image createTrayIconImage() {
-        BufferedImage image = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
+        return new BaseMultiResolutionImage(drawPointer(16), drawPointer(32), drawPointer(64));
+    }
+
+    private BufferedImage drawPointer(int size) {
+        BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
+        double scale = size / 16.0;
 
         int[] xPoints = {3, 3, 6, 8, 10, 8, 12};
         int[] yPoints = {1, 12, 8, 12, 11, 7, 7};
+        int[] scaledX = scale(xPoints, scale);
+        int[] scaledY = scale(yPoints, scale);
 
         Graphics2D graphics = image.createGraphics();
+        try {
             graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
             graphics.setColor(Color.BLACK);
-        graphics.fillPolygon(xPoints, yPoints, xPoints.length);
+            graphics.fillPolygon(scaledX, scaledY, scaledX.length);
             graphics.setColor(Color.WHITE);
-        graphics.drawPolygon(xPoints, yPoints, xPoints.length);
+            graphics.setStroke(new BasicStroke((float) Math.max(1.0, scale)));
+            graphics.drawPolygon(scaledX, scaledY, scaledX.length);
+        } finally {
             graphics.dispose();
-
+        }
         return image;
     }
 
+    private static int[] scale(int[] points, double factor) {
+        int[] scaled = new int[points.length];
+        for (int i = 0; i < points.length; i++) {
+            scaled[i] = (int) Math.round(points[i] * factor);
+        }
+        return scaled;
+    }
+
+    // ── shutdown ─────────────────────────────────────────────────────────
+
+    /** Whether cleanup already ran, so it can safely be called twice. */
+    private boolean cleanedUp = false;
+
     /**
      * Stops the automation and releases everything the app is holding.
      * Safe to call more than once, from any thread: window closing and
@@ -194,6 +585,7 @@ public class MainWindow
         cleanedUp = true;
 
         LOGGER.info("Shutting down...");
+        statusTimer.stop();
         stopAutomation();
 
         if (trayIcon != null) {
@@ -204,6 +596,8 @@ public class MainWindow
         Main.unregisterJNativeHook();
     }
 
+    // ── permissions help ──────────────────────────────────────────────────
+
     /**
      * Explains which permissions the app needs and offers to open each pane.
      * the hook is retried on demand, so the app can start working without a
@@ -219,8 +613,7 @@ public class MainWindow
                             + "   versions — lets the app listen for the ctrl+alt hotkey.\n"
                             + "   if the pane shows a separate \"events\" switch for autosqueal, turn\n"
                             + "   that on too: it is what lets the app move the mouse and click.\n\n"
-                            + "2. screen recording — lets the app take the screenshot shown\n"
+                            + "2. screen recording — lets the app read the cursor position.\n\n"
-                            + "   in the main window.\n\n"
                             + "open each pane, unlock it, and make sure autosqueal is listed and switched on.\n"
                             + "if it is already listed, remove it with the minus button and re-add it:\n"
                             + "every rebuild looks like a different app to the system.\n"
@@ -271,82 +664,4 @@ public class MainWindow
     public void notifyKeyboardActivity() {
         awayDetector.reportKeyboardActivity();
     }
-
-    /**
-     * Toggles the automation on or off. Safe to call from any thread: the actual
-     * work is always marshalled to the EDT, since it touches Swing components.
-     */
-    public void toggleRunning() {
-        SwingUtilities.invokeLater(() -> {
-            if (cursorMover == null) {
-                startAutomation();
-            } else {
-                stopAutomation();
-            }
-            updateToggleLabel();
-        });
-    }
-
-    private void startAutomation() {
-        LOGGER.info("Starting automation");
-
-        // periodic work (polling and movement cadence) on a classic scheduler,
-        // so that it can be scheduled with fixed delays
-        periodicScheduler = Executors.newScheduledThreadPool(2, runnable -> {
-            Thread thread = new Thread(runnable, "autosqueal-scheduler");
-            thread.setDaemon(true);
-            return thread;
-        });
-
-        // movements and clicks run on virtual threads: they mostly sleep,
-        // and blocking them costs nothing
-        movementExecutor = Executors.newThreadPerTaskExecutor(
-                Thread.ofVirtual().name("autosqueal-movement-").factory());
-
-        // away-detection: polls the cursor position and ignores the movements
-        // the app performs itself, as reported by the robot mouse tracker.
-        // the automation only moves the mouse when the user is away.
-        periodicScheduler.scheduleWithFixedDelay(awayDetector, 0L, AWAY_POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
-
-        cursorMover = new CursorMover(movementExecutor, robotTracker, awayDetector::isUserAway);
-        periodicScheduler.scheduleWithFixedDelay(cursorMover,
-                AUTOMATION_START_DELAY_SECONDS,
-                RunnerUtil.SECONDS_BETWEEN_MOVES,
-                TimeUnit.SECONDS);
-    }
-
-    private void stopAutomation() {
-        LOGGER.info("Stopping automation");
-
-        if (periodicScheduler != null) {
-            periodicScheduler.shutdownNow();
-            periodicScheduler = null;
-        }
-
-        if (movementExecutor != null) {
-            // interrupts the in-flight movement threads, too
-            movementExecutor.shutdownNow();
-            movementExecutor = null;
-        }
-
-        cursorMover = null;
-    }
-
-    private void updateToggleLabel() {
-        if (toggleButton == null) {
-            // the window is not initialized yet
-            return;
-        }
-
-        String hotkey = "[" + NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL) + "]"
-                + "[" + NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT) + "]";
-
-        String label = (cursorMover == null ? "Start " : "Stop ") + hotkey;
-
-        toggleButton.setText(label);
-        if (trayToggleItem != null) {
-            trayToggleItem.setLabel(label);
-        }
-    }
-
 }

src/main/java/wtf/beatrice/autosqueal/ui/ThemeManager.java

@@ -0,0 +1,89 @@
+package wtf.beatrice.autosqueal.ui;
+
+import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.themes.FlatMacDarkLaf;
+import com.formdev.flatlaf.themes.FlatMacLightLaf;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.util.SystemUtil;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Keeps the look and feel in sync with the system appearance.
+ *
+ * On macOS the dark or light mode is read from the system, so the app
+ * follows the user's taste without any setting of its own; everywhere
+ * else the light theme is used. The check runs again every time the
+ * window is activated, so switching the system appearance while the app
+ * runs is picked up without a restart.
+ */
+public final class ThemeManager {
+
+    private static final Logger LOGGER = LogManager.getLogger(ThemeManager.class);
+
+    /** The theme currently applied, so a change of system appearance is noticed. */
+    private static boolean darkThemeApplied = false;
+
+    private ThemeManager() {
+        throw new AssertionError("The ThemeManager class is not intended to be instantiated.");
+    }
+
+    /** Applies the theme matching the current system appearance. */
+    public static void applySystemTheme() {
+        boolean systemDark = isSystemDarkMode();
+        applyTheme(systemDark);
+    }
+
+    /** Re-checks the system appearance, and switches theme if it changed. */
+    public static void reapplyIfSystemThemeChanged() {
+        boolean systemDark = isSystemDarkMode();
+        if (systemDark != darkThemeApplied) {
+            applyTheme(systemDark);
+        }
+    }
+
+    private static void applyTheme(boolean dark) {
+        try {
+            FlatLaf.setup(dark ? new FlatMacDarkLaf() : new FlatMacLightLaf());
+            darkThemeApplied = dark;
+        } catch (RuntimeException ex) {
+            // a broken theme must never keep the app from starting
+            LOGGER.error("Could not apply the flat theme, using the default look and feel", ex);
+        }
+    }
+
+    /**
+     * Whether the system is in dark mode. On macOS, the appearance lives
+     * in AppleInterfaceStyle, which simply does not exist while the system
+     * is in light mode.
+     */
+    private static boolean isSystemDarkMode() {
+        if (SystemUtil.getHostSystem() != SystemUtil.OperatingSystem.MAC_OS) {
+            return false;
+        }
+
+        try {
+            ProcessBuilder builder = new ProcessBuilder(
+                    "defaults", "read", "NSGlobalDomain", "AppleInterfaceStyle");
+            builder.redirectErrorStream(true);
+            Process process = builder.start();
+
+            String style;
+            try (BufferedReader reader = new BufferedReader(
+                    new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
+                style = reader.readLine();
+            }
+
+            boolean exited = process.waitFor() == 0;
+            return exited && "Dark".equalsIgnoreCase(style == null ? "" : style.trim());
+        } catch (IOException | InterruptedException ex) {
+            // if the check fails, prefer the light theme
+            LOGGER.debug("Could not read the system appearance, assuming light", ex);
+            return false;
+        }
+    }
+}

src/main/java/wtf/beatrice/autosqueal/util/RunnerUtil.java

@@ -1,5 +1,7 @@
 package wtf.beatrice.autosqueal.util;
 
+import wtf.beatrice.autosqueal.config.ScreenArea;
+
 import java.awt.*;
 
 public class RunnerUtil {
@@ -8,9 +10,32 @@ public class RunnerUtil {
         throw new AssertionError("The RunnerUtil class is not intended to be instantiated.");
     }
 
-    public static final int SECONDS_BETWEEN_MOVES = 10;
+    /**
+     * The bounds of the screens the cursor may travel to, according to the
+     * given setting. Fetched on every call, so that a change of setting, or
+     * a screen plugged in while the app runs, is picked up by the next
+     * movement.
+     *
+     * The result is never empty: when no screen is found, the main screen
+     * is returned, because it always exists.
+     */
+    public static Rectangle screenBounds(ScreenArea area) {
+        Rectangle bounds = new Rectangle();
 
-    public static final int SCREEN_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height;
+        if (area == ScreenArea.ALL) {
-    public static final int SCREEN_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width;
+            for (GraphicsDevice device : GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()) {
+                bounds.add(device.getDefaultConfiguration().getBounds());
+            }
+        }
+
+        if (bounds.isEmpty()) {
+            // the main screen was requested, or no other screen was found
+            bounds = GraphicsEnvironment.getLocalGraphicsEnvironment()
+                    .getDefaultScreenDevice().getDefaultConfiguration().getBounds();
+        }
+
+        // defensive copy: the callers treat the rectangle as theirs
+        return new Rectangle(bounds);
+    }
 
 }

src/main/java/wtf/beatrice/autosqueal/util/SystemUtil.java

@@ -1,5 +1,6 @@
 package wtf.beatrice.autosqueal.util;
 
+import java.nio.file.Path;
 import java.util.Locale;
 
 public class SystemUtil
@@ -9,6 +10,27 @@ public class SystemUtil
         return fromOsName(System.getProperty("os.name"));
     }
 
+    /**
+     * The per-user directory where the app keeps its settings, following
+     * the conventions of the host platform.
+     */
+    public static Path getAppConfigDir() {
+        String home = System.getProperty("user.home", ".");
+        String appData = System.getenv("APPDATA");
+        String xdgConfigHome = System.getenv("XDG_CONFIG_HOME");
+
+        return switch (getHostSystem()) {
+            case MAC_OS -> Path.of(home, "Library", "Application Support", "autosqueal");
+            case WINDOWS -> appData != null && !appData.isBlank()
+                    ? Path.of(appData, "autosqueal")
+                    : Path.of(home, ".autosqueal");
+            case LINUX -> xdgConfigHome != null && !xdgConfigHome.isBlank()
+                    ? Path.of(xdgConfigHome, "autosqueal")
+                    : Path.of(home, ".config", "autosqueal");
+            default -> Path.of(home, ".autosqueal");
+        };
+    }
+
     public static OperatingSystem fromOsName(String osName) {
         String normalizedOsName = osName.toLowerCase(Locale.ENGLISH);
         if (normalizedOsName.contains("win")) {

src/main/resources/log4j2.xml

@@ -6,7 +6,7 @@
         </Console>
     </Appenders>
     <Loggers>
-        <Root level="info">
+        <Root level="debug">
             <AppenderRef ref="ConsoleAppender" />
         </Root>
     </Loggers>

src/test/java/wtf/beatrice/autosqueal/config/ConfigStoreTest.java

@@ -0,0 +1,125 @@
+package wtf.beatrice.autosqueal.config;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConfigStoreTest
+{
+    @TempDir
+    Path tempDir;
+
+    private ConfigStore store;
+
+    @BeforeEach
+    void createStore() {
+        store = new ConfigStore(tempDir.resolve("autosqueal.properties"));
+    }
+
+    @Test
+    void missingFileYieldsTheDefaults() {
+        AutoSquealConfig config = store.load();
+
+        assertEquals(30, config.getAwayThresholdSeconds());
+        assertEquals(10, config.getMoveIntervalSeconds());
+        assertEquals(2, config.getStepDelayMilliseconds());
+        assertTrue(config.isClickEnabled());
+        assertEquals(5, config.getClickEveryNMoves());
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+        assertTrue(config.isStartAutomatically());
+        assertTrue(config.isHotkeyEnabled());
+    }
+
+    @Test
+    void savedSettingsLoadBack() {
+        AutoSquealConfig config = new AutoSquealConfig();
+        config.setAwayThresholdSeconds(45);
+        config.setMoveIntervalSeconds(20);
+        config.setStepDelayMilliseconds(4);
+        config.setClickEnabled(false);
+        config.setClickEveryNMoves(7);
+        config.setMovementScreen(ScreenArea.ALL);
+        config.setStartAutomatically(false);
+        config.setHotkeyEnabled(false);
+
+        store.save(config);
+        AutoSquealConfig loaded = store.load();
+
+        assertEquals(45, loaded.getAwayThresholdSeconds());
+        assertEquals(20, loaded.getMoveIntervalSeconds());
+        assertEquals(4, loaded.getStepDelayMilliseconds());
+        assertFalse(loaded.isClickEnabled());
+        assertEquals(7, loaded.getClickEveryNMoves());
+        assertEquals(ScreenArea.ALL, loaded.getMovementScreen());
+        assertFalse(loaded.isStartAutomatically());
+        assertFalse(loaded.isHotkeyEnabled());
+    }
+
+    @Test
+    void outOfRangeValuesAreClamped() throws IOException {
+        writeFile(ConfigStore.KEY_AWAY_THRESHOLD_SECONDS + "=0",
+                ConfigStore.KEY_MOVE_INTERVAL_SECONDS + "=99999999",
+                ConfigStore.KEY_STEP_DELAY_MILLISECONDS + "=-3",
+                ConfigStore.KEY_CLICK_EVERY_N_MOVES + "=1000");
+
+        AutoSquealConfig config = store.load();
+
+        assertEquals(5, config.getAwayThresholdSeconds());
+        assertEquals(3600, config.getMoveIntervalSeconds());
+        assertEquals(1, config.getStepDelayMilliseconds());
+        assertEquals(100, config.getClickEveryNMoves());
+    }
+
+    @Test
+    void invalidValuesKeepTheDefaults() throws IOException {
+        writeFile(ConfigStore.KEY_AWAY_THRESHOLD_SECONDS + "=soon",
+                ConfigStore.KEY_CLICK_ENABLED + "=banana",
+                ConfigStore.KEY_MOVEMENT_SCREEN + "=THE_MOON",
+                ConfigStore.KEY_MOVE_INTERVAL_SECONDS + "=15");
+
+        AutoSquealConfig config = store.load();
+
+        assertEquals(30, config.getAwayThresholdSeconds());
+        assertTrue(config.isClickEnabled());
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+        // the one valid value still loads
+        assertEquals(15, config.getMoveIntervalSeconds());
+    }
+
+    @Test
+    void settingsSettersClampToo() {
+        AutoSquealConfig config = new AutoSquealConfig();
+
+        config.setAwayThresholdSeconds(-10);
+        assertEquals(5, config.getAwayThresholdSeconds());
+
+        config.setAwayThresholdSeconds(10_000);
+        assertEquals(600, config.getAwayThresholdSeconds());
+
+        config.setMovementScreen(null);
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+    }
+
+    @Test
+    void savingNeverLeavesTempFilesBehind() throws IOException {
+        store.save(new AutoSquealConfig());
+
+        assertTrue(Files.isRegularFile(tempDir.resolve("autosqueal.properties")));
+        try (var files = Files.list(tempDir)) {
+            assertEquals(1, files.count());
+        }
+    }
+
+    private void writeFile(String... lines) throws IOException {
+        Files.write(tempDir.resolve("autosqueal.properties"), List.of(lines));
+    }
+}

src/test/java/wtf/beatrice/autosqueal/controls/CursorMoverTest.java

@@ -0,0 +1,187 @@
+package wtf.beatrice.autosqueal.controls;
+
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CursorMoverTest
+{
+    private static final Point CURSOR_AT = new Point(100, 100);
+
+    private final RobotMouseTracker robotTracker = new RobotMouseTracker();
+    private final AutoSquealConfig config = new AutoSquealConfig();
+    private final RecordingExecutor executor = new RecordingExecutor();
+
+    /** Bounds of a pretend multi-screen setup: the main screen is offset. */
+    private final Rectangle movementBounds = new Rectangle(100, 50, 800, 600);
+    private final Rectangle primaryBounds = new Rectangle(100, 50, 800, 600);
+
+    /** A mover that queues its movements on the recording executor. */
+    private CursorMover mover() {
+        return new CursorMover(executor, robotTracker, () -> true, config,
+                () -> movementBounds, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+    }
+
+    private List<SingleStepMovementTask> movements() {
+        List<SingleStepMovementTask> movements = new ArrayList<>();
+        for (Runnable movement : executor.movements) {
+            movements.add((SingleStepMovementTask) movement);
+        }
+        return movements;
+    }
+
+    @Test
+    void movementsAreSkippedWhileTheUserIsPresent() {
+        // the automation only moves the mouse when the user is away
+        CursorMover presentMover = new CursorMover(executor, robotTracker, () -> false, config,
+                () -> movementBounds, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+
+        for (int i = 0; i < 10; i++) {
+            presentMover.run();
+        }
+
+        assertTrue(executor.movements.isEmpty());
+    }
+
+    @Test
+    void randomMovementsStayWithinTheBounds() {
+        config.setClickEnabled(false);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 50; i++) {
+            cursorMover.run();
+        }
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(50, movements.size());
+        for (SingleStepMovementTask movement : movements) {
+            assertFalse(movement.isClick());
+            assertTrue(movement.getDestX() >= 100, "destX below the bounds: " + movement.getDestX());
+            assertTrue(movement.getDestX() < 900, "destX above the bounds: " + movement.getDestX());
+            assertTrue(movement.getDestY() >= 50, "destY below the bounds: " + movement.getDestY());
+            assertTrue(movement.getDestY() < 650, "destY above the bounds: " + movement.getDestY());
+        }
+    }
+
+    @Test
+    void cornerClicksHappenEveryNthMovement() {
+        config.setClickEveryNMoves(3);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 6; i++) {
+            cursorMover.run();
+        }
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(6, movements.size());
+
+        // one movement every 3: the 3rd and the 6th are corner clicks
+        assertFalse(movements.get(0).isClick());
+        assertFalse(movements.get(1).isClick());
+        assertTrue(movements.get(2).isClick());
+        assertFalse(movements.get(3).isClick());
+        assertFalse(movements.get(4).isClick());
+        assertTrue(movements.get(5).isClick());
+    }
+
+    @Test
+    void cornerClicksAimAtTheMainScreensTopRight() {
+        // the click must open the notifications, which live on the main
+        // screen's corner: wherever the movement bounds are, the click
+        // destination follows the main screen
+        config.setClickEveryNMoves(3);
+        Rectangle elsewhere = new Rectangle(5000, 5000, 200, 200);
+        CursorMover cursorMover = new CursorMover(executor, robotTracker, () -> true, config,
+                () -> elsewhere, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+
+        cursorMover.run(); // iteration 0: a normal movement
+        cursorMover.run(); // iteration 1: a normal movement
+        cursorMover.run(); // iteration 2: the corner click
+
+        List<SingleStepMovementTask> movements = movements();
+        assertTrue(movements.get(2).isClick());
+        // the main screen's top-right corner, 5px inside
+        assertEquals(100 + 800 - 5, movements.get(2).getDestX());
+        assertEquals(50 + 5, movements.get(2).getDestY());
+    }
+
+    @Test
+    void clicksCanBeTurnedOff() {
+        config.setClickEnabled(false);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 10; i++) {
+            cursorMover.run();
+        }
+
+        for (SingleStepMovementTask movement : movements()) {
+            assertFalse(movement.isClick());
+        }
+    }
+
+    @Test
+    void clickCadenceIsReadLive() {
+        config.setClickEveryNMoves(2);
+
+        CursorMover cursorMover = mover();
+        cursorMover.run(); // iteration 0
+        cursorMover.run(); // iteration 1: click, cadence 2
+        assertTrue(movements().get(1).isClick());
+
+        // the user loosens the cadence while the automation runs
+        config.setClickEveryNMoves(4);
+        cursorMover.run(); // iteration 0
+        cursorMover.run(); // iteration 1
+        cursorMover.run(); // iteration 2
+        cursorMover.run(); // iteration 3: click, cadence 4
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(6, movements.size());
+        assertFalse(movements.get(2).isClick());
+        assertFalse(movements.get(3).isClick());
+        assertFalse(movements.get(4).isClick());
+        assertTrue(movements.get(5).isClick());
+    }
+
+    /** An executor that records the tasks instead of running them. */
+    private static class RecordingExecutor extends AbstractExecutorService {
+
+        final List<Runnable> movements = new ArrayList<>();
+
+        public void execute(Runnable command) {
+            movements.add(command);
+        }
+
+        public void shutdown() { }
+
+        public List<Runnable> shutdownNow() {
+            return List.of();
+        }
+
+        public boolean isShutdown() {
+            return false;
+        }
+
+        public boolean isTerminated() {
+            return false;
+        }
+
+        public boolean awaitTermination(long timeout, TimeUnit unit) {
+            return false;
+        }
+    }
+}

src/test/java/wtf/beatrice/autosqueal/listener/CursorMoveListenerTest.java

@@ -1,12 +1,11 @@
 package wtf.beatrice.autosqueal.listener;
 
 import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
 
 import java.awt.*;
 import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Queue;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -14,73 +13,93 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class CursorMoveListenerTest
 {
-    private static final int LOOPS_BEFORE_AWAY = 30;
+    private static final int AWAY_THRESHOLD_SECONDS = 30;
 
     private final RobotMouseTracker robotTracker = new RobotMouseTracker();
 
+    /** The fake clock the listener polls with, in milliseconds. */
+    private long now = 1_000_000L;
+
     /** Builds a listener that reads scripted cursor positions, one per poll. */
     private CursorMoveListener scriptedListener(Point... positions) {
         Queue<Point> positionQueue = new ArrayDeque<>(java.util.List.of(positions));
-        return new CursorMoveListener(robotTracker, positionQueue::remove);
+        return new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positionQueue::remove, () -> now);
     }
 
     private static Point at(int x, int y) {
         return new Point(x, y);
     }
 
+    /** Polls, pretending that the given seconds have passed since the previous poll. */
+    private void poll(CursorMoveListener listener, int secondsSincePreviousPoll) {
+        now += secondsSincePreviousPoll * 1000L;
+        listener.run();
+    }
+
     @Test
     void userIsAwayAfterThirtyStillSeconds() {
-        Point[] still = new Point[LOOPS_BEFORE_AWAY + 2];
+        Point[] still = new Point[AWAY_THRESHOLD_SECONDS + 3];
         for (int i = 0; i < still.length; i++) {
             still[i] = at(100, 100);
         }
         CursorMoveListener listener = scriptedListener(still);
 
         // the first poll seeds the baseline and does not count
-        for (int i = 0; i < LOOPS_BEFORE_AWAY; i++) {
+        poll(listener, 1);
-            listener.run();
+
+        // 29 still seconds: the user is still considered present
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
             assertFalse(listener.isUserAway());
         }
 
-        listener.run();
+        // the 30th still second: the user is away
+        poll(listener, 1);
         assertTrue(listener.isUserAway());
     }
 
     @Test
-    void firstPollDoesNotCountAsMovement() {
+    void firstPollDoesNotCountAsMovementOrIdleTime() {
-        // the very first position read must seed the baseline: starting anywhere
+        // the very first position read must seed the baseline and the
-        // else would have counted as a user movement and reset the away timer
+        // activity clock: starting anywhere else would have counted the
+        // first poll as a movement, or as a full idle period
         CursorMoveListener listener = scriptedListener(at(500, 300), at(500, 300));
 
-        listener.run();
+        poll(listener, 5);
-        listener.run();
+        poll(listener, 10);
 
         assertFalse(listener.isUserAway());
-        // still at (500, 300), so the baseline was seeded correctly
+        // still at (500, 300), and only 10 idle seconds: the seeding poll
+        // consumed the first 5 seconds
     }
 
     @Test
     void userMovementResetsTheAwayTimer() {
-        List<Point> positions = new ArrayList<>();
+        Queue<Point> positions = new ArrayDeque<>();
         positions.add(at(100, 100));                          // baseline
-        for (int i = 0; i < 5; i++) positions.add(at(100, 100)); // 5 still polls
+        for (int i = 0; i < 3; i++) positions.add(at(100, 100)); // 3 still seconds
         positions.add(at(140, 100));                          // the user moves the mouse
-        for (int i = 0; i < LOOPS_BEFORE_AWAY; i++) positions.add(at(140, 100)); // then it stays put
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) positions.add(at(140, 100)); // then it stays put
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
 
-        CursorMoveListener listener = scriptedListener(positions.toArray(Point[]::new));
+        poll(listener, 1); // seed the baseline
-
+        for (int i = 0; i < 3; i++) {
-        listener.run(); // seed the baseline
+            poll(listener, 1);
-        for (int i = 0; i < 5; i++) listener.run(); // loops = 5
+        }
         assertFalse(listener.isUserAway());
 
-        listener.run(); // the user moved: the away timer resets
+        poll(listener, 1); // the user moved: the away timer resets
         assertFalse(listener.isUserAway());
 
-        // ...and it still takes 30 more still polls to be away again
+        // ...and it still takes 30 more still seconds to be away again
-        for (int i = 0; i < LOOPS_BEFORE_AWAY - 1; i++) listener.run(); // loops = 29
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
             assertFalse(listener.isUserAway());
+        }
 
-        listener.run(); // loops = 30
+        poll(listener, 1);
         assertTrue(listener.isUserAway());
     }
 
@@ -92,19 +111,21 @@ class CursorMoveListenerTest
         // always think the user was present
 
         // every poll finds the cursor where the app last left it
-        List<Point> positions = new ArrayList<>();
+        Queue<Point> appPositions = new ArrayDeque<>();
-        positions.add(at(100, 100)); // baseline
+        appPositions.add(at(100, 100));
-        for (int i = 1; i <= 40; i++) positions.add(at(100 + i, 100));
+        for (int i = 1; i <= 40; i++) {
+            appPositions.add(at(100 + i, 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                appPositions::remove, () -> now);
 
-        CursorMoveListener listener = scriptedListener(positions.toArray(Point[]::new));
+        poll(listener, 1); // seed the baseline
-
-        listener.run(); // seed the baseline
 
         for (int i = 1; i <= 40; i++) {
             // the app just finished a movement, leaving the cursor exactly
             // where this poll will find it
             robotTracker.moveEnded(100 + i, 100);
-            listener.run();
+            poll(listener, 1);
         }
 
         // every position change was the app's own doing: the user is away
@@ -115,16 +136,17 @@ class CursorMoveListenerTest
     void ongoingAppMovementsDoNotKeepTheUserPresent() {
         // same as above, but the polls happen while the app is mid-movement,
         // with the cursor transiently at intermediate positions
-        Point[] positions = new Point[41];
+        Queue<Point> positions = new ArrayDeque<>();
-        positions[0] = at(100, 100);
+        positions.add(at(100, 100));
-        for (int i = 1; i < positions.length; i++) {
+        for (int i = 1; i <= 40; i++) {
-            positions[i] = at(100 + (i / 2), 100);
+            positions.add(at(100 + (i / 2), 100));
         }
-        CursorMoveListener listener = scriptedListener(positions);
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
 
         robotTracker.moveStarted();
-        for (int i = 1; i < positions.length; i++) {
+        for (int i = 0; i <= 40; i++) {
-            listener.run();
+            poll(listener, 1);
         }
 
         assertTrue(listener.isUserAway());
@@ -132,48 +154,55 @@ class CursorMoveListenerTest
 
     @Test
     void keyboardActivityResetsTheAwayTimer() {
-        List<Point> positions = new ArrayList<>();
+        Queue<Point> positions = new ArrayDeque<>();
         positions.add(at(100, 100)); // baseline
-        for (int i = 0; i < 29; i++) positions.add(at(100, 100)); // 29 still polls
+        for (int i = 0; i < 60; i++) {
-        positions.add(at(100, 100));                              // the user presses a key
+            positions.add(at(100, 100)); // the mouse never moves
-        for (int i = 0; i < LOOPS_BEFORE_AWAY; i++) positions.add(at(100, 100)); // then the mouse stays put
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
 
-        CursorMoveListener listener = scriptedListener(positions.toArray(Point[]::new));
+        poll(listener, 1); // seed the baseline
-
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
-        listener.run(); // seed the baseline
+            poll(listener, 1);
-        for (int i = 0; i < 29; i++) listener.run(); // loops = 29
+        }
         assertFalse(listener.isUserAway());
 
         // the user is typing without moving the mouse: the timer resets
         listener.reportKeyboardActivity();
-        listener.run();
+        poll(listener, 1);
         assertFalse(listener.isUserAway());
 
-        // ...and it still takes 30 still polls to be away again
+        // ...and it still takes 30 still seconds to be away again
-        for (int i = 0; i < LOOPS_BEFORE_AWAY - 1; i++) listener.run(); // loops = 29
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
             assertFalse(listener.isUserAway());
+        }
 
-        listener.run(); // loops = 30
+        poll(listener, 1);
         assertTrue(listener.isUserAway());
     }
 
     @Test
     void keyboardActivityBringsTheUserBackWhileAway() {
-        Point[] positions = new Point[LOOPS_BEFORE_AWAY + 3];
+        Queue<Point> positions = new ArrayDeque<>();
-        for (int i = 0; i < positions.length; i++) {
+        positions.add(at(100, 100));
-            positions[i] = at(100, 100);
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS + 3; i++) {
+            positions.add(at(100, 100));
         }
-        CursorMoveListener listener = scriptedListener(positions);
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
 
-        for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) { // baseline + 30 still polls
+        poll(listener, 1); // seed the baseline
-            listener.run();
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
+            poll(listener, 1);
         }
         assertTrue(listener.isUserAway());
 
         // the user comes back at the keyboard: the away state must end,
         // even though the mouse never moved
         listener.reportKeyboardActivity();
-        listener.run();
+        poll(listener, 1);
         assertFalse(listener.isUserAway());
     }
 
@@ -181,34 +210,72 @@ class CursorMoveListenerTest
     void userComingBackIsDetectedWhileTheAppIsWiggling() {
         // the app keeps wiggling while the user is away; when the user comes
         // back and moves the mouse, the away state must end
-
+        Queue<Point> positions = new ArrayDeque<>();
-        // polls: baseline, 30 still polls, two app wiggles, then the user's move
+        positions.add(at(100, 100));
-        Point[] positions = new Point[LOOPS_BEFORE_AWAY + 4];
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
-        for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) {
+            positions.add(at(100, 100));
-            positions[i] = at(100, 100);
         }
-        positions[LOOPS_BEFORE_AWAY + 1] = at(150, 100);
+        positions.add(at(150, 100)); // app wiggle
-        positions[LOOPS_BEFORE_AWAY + 2] = at(200, 100);
+        positions.add(at(200, 100)); // app wiggle
-        positions[LOOPS_BEFORE_AWAY + 3] = at(333, 100);
+        positions.add(at(333, 100)); // the user's move
-        CursorMoveListener listener = scriptedListener(positions);
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
 
-        // baseline + 30 still polls: the user goes away
+        poll(listener, 1); // seed the baseline
-        for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) {
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
-            listener.run();
+            poll(listener, 1);
         }
         assertTrue(listener.isUserAway());
 
         // the app wiggles: each movement is discounted, the user stays "away"
         robotTracker.moveEnded(150, 100);
-        listener.run();
+        poll(listener, 1);
         assertTrue(listener.isUserAway());
 
         robotTracker.moveEnded(200, 100);
-        listener.run();
+        poll(listener, 1);
         assertTrue(listener.isUserAway());
 
         // the user comes back and grabs the mouse
-        listener.run();
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+    }
+
+    @Test
+    void thresholdChangesApplyFromTheNextPoll() {
+        // the threshold is read live: a change applies without a restart
+        AutoSquealConfig config = new AutoSquealConfig();
+        config.setAwayThresholdSeconds(10);
+        Queue<Point> positions = new ArrayDeque<>();
+        for (int i = 0; i < 20; i++) {
+            positions.add(at(100, 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, config,
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+
+        // 9 still seconds: not away with a 10 seconds threshold
+        for (int i = 0; i < 9; i++) {
+            poll(listener, 1);
+            assertFalse(listener.isUserAway());
+        }
+
+        // 10th second: away
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+
+        // the user tightens the threshold to 5: the next poll re-evaluates
+        // and the user is still away (already idle for more than 5 seconds)
+        config.setAwayThresholdSeconds(5);
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+
+        // the user loosens the threshold to 600: the same idle time is no
+        // longer enough, so the user is present again — and back to away
+        // only after 600 seconds of stillness
+        config.setAwayThresholdSeconds(600);
+        poll(listener, 1);
         assertFalse(listener.isUserAway());
     }
 }

src/test/java/wtf/beatrice/autosqueal/listener/KeyPressListenerTest.java

@@ -0,0 +1,86 @@
+package wtf.beatrice.autosqueal.listener;
+
+import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class KeyPressListenerTest
+{
+    private final List<String> events = new ArrayList<>();
+    private final AutoSquealConfig config = new AutoSquealConfig();
+    private final KeyPressListener listener = new KeyPressListener(
+            () -> events.add("toggle"), () -> events.add("activity"), config);
+
+    private static NativeKeyEvent press(int keyCode) {
+        return new NativeKeyEvent(NativeKeyEvent.NATIVE_KEY_PRESSED, 0, 0, keyCode, ' ');
+    }
+
+    private static NativeKeyEvent release(int keyCode) {
+        return new NativeKeyEvent(NativeKeyEvent.NATIVE_KEY_RELEASED, 0, 0, keyCode, ' ');
+    }
+
+    @Test
+    void theComboTogglesOnceOnItsSecondKey() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+
+        // ctrl alone is not the combo: it only reports presence
+        assertEquals(List.of("activity"), events);
+
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        // the second key completes the combo: presence first, then the toggle
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void theComboWorksInTheOtherOrderToo() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void repeatedPressesAreIgnored() {
+        // the OS repeats press events while a key is held down: they must
+        // not toggle repeatedly
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        events.clear();
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        assertEquals(List.of(), events);
+    }
+
+    @Test
+    void theComboCanFireAgainAfterBothKeysAreReleased() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+        listener.nativeKeyReleased(release(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyReleased(release(NativeKeyEvent.VC_ALT));
+
+        events.clear();
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void theHotkeyCanBeDisabledWithoutLosingPresenceReporting() {
+        config.setHotkeyEnabled(false);
+
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        // typing still counts as presence, but the combo does nothing
+        assertEquals(List.of("activity", "activity"), events);
+    }
+}