redesign the window with flatlaf

.drone.yml

@@ -14,19 +14,19 @@ steps:
   - name: build
     image: maven:3-eclipse-temurin-25
     commands:
-      - mvn verify --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V
+      - ./mvnw verify --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V
 
   # run unit tests
   - name: test
     image: maven:3-eclipse-temurin-25
     commands:
-      - mvn test --no-transfer-progress -B -V
+      - ./mvnw test --no-transfer-progress -B -V
 
   # run code analysis
   - name: code-analysis
     image: maven:3-eclipse-temurin-25
     commands:
-      - mvn sonar:sonar --no-transfer-progress -Dsonar.projectKey=$SONAR_PROJECT_KEY -Dsonar.host.url=$SONAR_INSTANCE_URL -Dsonar.token=$SONAR_LOGIN_KEY -B -V
+      - ./mvnw sonar:sonar --no-transfer-progress -Dsonar.projectKey=$SONAR_PROJECT_KEY -Dsonar.host.url=$SONAR_INSTANCE_URL -Dsonar.token=$SONAR_LOGIN_KEY -B -V
     environment:
       SONAR_PROJECT_KEY:
         from_secret: sonar_project_key
@@ -57,7 +57,7 @@ steps:
   - name: maven-deploy
     image: maven:3-eclipse-temurin-25
     commands:
-      - mvn deploy --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V -gs settings.xml -Dmaven.repo.username=$MAVEN_REPO_USERNAME -Dmaven.repo.password=$MAVEN_REPO_PASSWORD
+      - ./mvnw deploy --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V -gs settings.xml -Dmaven.repo.username=$MAVEN_REPO_USERNAME -Dmaven.repo.password=$MAVEN_REPO_PASSWORD
     environment:
       MAVEN_REPO_USERNAME:
         from_secret: maven_repo_username

.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,3 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.16/apache-maven-3.9.16-bin.zip

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2024-2026 Beatrice Dellacà <hello@beatrice.wtf>
+
+All rights reserved.
+
+This software and its source code are the exclusive property of the
+copyright holder and are protected by copyright laws and international
+treaty provisions. No part of this software or its source code may be
+reproduced, distributed, transmitted, displayed, published, or broadcast,
+in any form or by any means, electronic or mechanical, including but not
+limited to photocopying, recording, or the use of any information storage
+and retrieval system, without the prior written permission of the
+copyright holder.
+
+No license or other right to use this software or its source code is
+granted by this notice, whether by implication, estoppel, or otherwise.
+
+THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN
+CONNECTION WITH THIS SOFTWARE OR ITS USE.

mvnw

@@ -0,0 +1,295 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.4
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+scriptDir="$(dirname "$0")"
+scriptName="$(basename "$0")"
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+actualDistributionDir=""
+
+# First try the expected directory name (for regular distributions)
+if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then
+  if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then
+    actualDistributionDir="$distributionUrlNameMain"
+  fi
+fi
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if [ -z "$actualDistributionDir" ]; then
+  # enable globbing to iterate over items
+  set +f
+  for dir in "$TMP_DOWNLOAD_DIR"/*; do
+    if [ -d "$dir" ]; then
+      if [ -f "$dir/bin/$MVN_CMD" ]; then
+        actualDistributionDir="$(basename "$dir")"
+        break
+      fi
+    fi
+  done
+  set -f
+fi
+
+if [ -z "$actualDistributionDir" ]; then
+  verbose "Contents of $TMP_DOWNLOAD_DIR:"
+  verbose "$(ls -la "$TMP_DOWNLOAD_DIR")"
+  die "Could not find Maven distribution directory in extracted archive"
+fi
+
+verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"

mvnw.cmd

@@ -0,0 +1,189 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.4
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"

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>
@@ -64,27 +76,47 @@
             <plugin>
                 <groupId>org.sonarsource.scanner.maven</groupId>
                 <artifactId>sonar-maven-plugin</artifactId>
-                <version>5.0.0.4389</version>
+                <version>5.8.0.7211</version>
             </plugin>
             <plugin>
-                <artifactId>maven-assembly-plugin</artifactId>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <mainClass>wtf.beatrice.autosqueal.Main</mainClass>
-                        </manifest>
-                    </archive>
-                    <descriptorRefs>
-                        <descriptorRef>jar-with-dependencies</descriptorRef>
-                    </descriptorRefs>
-                </configuration>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.6.2</version>
                 <executions>
                     <execution>
-                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
-                        <phase>package</phase> <!-- bind to the packaging phase -->
+                        <id>make-fat-jar</id>
+                        <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>
@@ -134,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>
@@ -166,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/`.  
@@ -40,5 +40,6 @@
 | official repository | [gitea src](https://git.beatrice.wtf/Tools/autosqeal.git)     |
 | mirror repository   | [github src](https://github.com/mind-overflow/autosqueal.git) |
 | build status        | [drone-ci](https://drone.beatrice.wtf/Tools/autosqeal)        |
+| license             | copyright, all rights reserved — see [license](LICENSE)       |
 | dev email           | [hello@beatrice.wtf](mailto:hello@beatrice.wtf)               |
 

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

@@ -4,21 +4,45 @@ 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;
 
     public static void main(String[] args) {
         LOGGER.info("Hello world!");
 
-        useSystemLookAndFeel();
+        // 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"));
+
+        ThemeManager.applySystemTheme();
         boolean hookRegistered = registerJNativeHook();
 
         // all Swing components must be created and updated on the EDT
@@ -30,19 +54,17 @@ 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;
+        }
+
         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;
         }
@@ -58,6 +80,10 @@ public class Main {
     }
 
     public static void unregisterJNativeHook() {
+        if (!hookRegistered) {
+            return;
+        }
+
         try {
             GlobalScreen.unregisterNativeHook();
             LOGGER.info("Successfully unregistered jnativehook library!");
@@ -68,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,72 +10,131 @@ 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.
+ * The same goes for a movement already in progress: the task checks whether
+ * 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
- * runs on its own virtual thread until it reaches its destination.
+ * Everything that varies — how often to move, how fast, whether and how
+ * 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) {
-            destX = RunnerUtil.SCREEN_WIDTH - 5;
-            destY = 5;
+        // one movement every N is a corner double click, so that the
+        // notification area gets exercised too. the corner is always the
+        // 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);
-            destY = random.nextInt(RunnerUtil.SCREEN_HEIGHT);
+            Rectangle bounds = movementBounds.get();
+            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);
+            SingleStepMovementTask movement = new SingleStepMovementTask(
+                    robotTracker, destX, destY, click, isUserAway,
+                    config.getStepDelayMilliseconds(), location);
             movementExecutor.execute(movement);
-        } catch (AWTException ex) {
-            LOGGER.error("Could not start movement task", ex);
+            if (listener != null) {
+                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

@@ -5,6 +5,7 @@ import org.apache.logging.log4j.Logger;
 
 import java.awt.*;
 import java.awt.event.InputEvent;
+import java.util.function.BooleanSupplier;
 
 /**
  * Moves the mouse cursor towards a destination one small step at a time.
@@ -13,6 +14,10 @@ import java.awt.event.InputEvent;
  * it is free. When it gets to its destination, it can optionally perform a
  * double click, with the pacing the app has always used.
  *
+ * If the user comes back mid-movement, the movement is abandoned at once —
+ * within the latency of the away detection, which polls about once a second —
+ * so the mouse is returned to the user instead of being dragged to a corner.
+ *
  * All the movements it performs are reported to the {@link RobotMouseTracker},
  * so that the away detection can tell them apart from the user's.
  */
@@ -20,30 +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) throws AWTException {
+    public SingleStepMovementTask(RobotMouseTracker robotTracker, int destinationX, int destinationY,
+                                  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 = location.x;
-        this.currentY = location.y;
+        this.currentX = start.x;
+        this.currentY = start.y;
 
         int lengthX = Math.round(Math.abs(currentX - destX));
         int lengthY = Math.round(Math.abs(currentY - destY));
@@ -53,18 +59,35 @@ 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();
 
         try {
             while (!hasReachedDestination()) {
+                // a user who came back mid-movement gets the mouse back
+                if (!userIsAway.getAsBoolean()) {
+                    LOGGER.info("User is back: abandoning the movement at [{}, {}]",
+                            Math.round(currentX), Math.round(currentY));
+                    robotTracker.moveEnded(Math.round(currentX), Math.round(currentY));
+                    return;
+                }
+
                 // when less than a full step is left, move exactly what is
                 // left, so that both axes always land on their destination
                 stepX = adjustedStep(currentX, destX, stepX);
@@ -75,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
@@ -95,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);
         }
     }
 
@@ -109,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);
@@ -167,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,71 +2,95 @@ 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
- * stays still for long enough — ignoring the movements the app performs on its
- * own — the user is considered away.
+ * Watches the cursor position and tracks whether the user is away: if the
+ * user has not touched mouse or keyboard for long enough — ignoring the
+ * movements the app performs on its own — the user is considered away.
+ * 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) {
-        this(robotTracker, () -> MouseInfo.getPointerInfo().getLocation());
+    public CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config) {
+        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;
+    }
+
+    /**
+     * Reports that the user pressed a key: keyboard activity counts as
+     * presence, so it resets the away timer at the next poll. Safe to call
+     * from any thread.
+     */
+    public void reportKeyboardActivity() {
+        keyboardActivity = true;
     }
 
     @Override
     public void run() {
 
+        // consume the keyboard activity reported since the previous poll
+        boolean keyboardActivity = this.keyboardActivity;
+        this.keyboardActivity = false;
+
         Point location = currentPosition.get();
+        long now = clock.getAsLong();
 
         if (firstPoll) {
-            // seed the comparison baseline, so that the first poll is not
-            // mistaken for a movement
+            // seed the comparison baseline and the activity clock, so that
+            // the first poll is neither a movement nor a full idle period
             firstPoll = false;
             lastSeenX = location.x;
             lastSeenY = location.y;
+            lastUserActivityTime = now;
             return;
         }
 
         boolean positionChanged = location.x != lastSeenX || location.y != lastSeenY;
-        boolean userMoved = positionChanged && !isAppMovement(location);
+        boolean userMoved = keyboardActivity || (positionChanged && !isAppMovement(location));
 
         if (userMoved) {
-            if (userAway) {
-                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!");
-            }
+            lastUserActivityTime = now;
         }
 
-        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,
@@ -23,10 +41,14 @@ public class KeyPressListener implements NativeKeyListener
         }
 
         pressedKeys.add(e.getKeyCode());
-        LOGGER.info("Key Pressed: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
+        LOGGER.debug("Key Pressed: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
 
-        if (e.getKeyCode() == NativeKeyEvent.VC_ESCAPE) {
-            Main.unregisterJNativeHook();
+        // 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
+        keyboardActivityReporter.run();
+
+        if (!config.isHotkeyEnabled()) {
+            return;
         }
 
         // toggle only when the second key of the combo is pressed down: not only does this
@@ -34,17 +56,17 @@ public class KeyPressListener implements NativeKeyListener
         // 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();
         }
     }
 
     @Override
     public void nativeKeyReleased(NativeKeyEvent e) {
-        LOGGER.info("Key Released: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
+        LOGGER.debug("Key Released: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
 
         pressedKeys.remove((Integer) e.getKeyCode());
     }

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

@@ -1,119 +1,505 @@
 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;
 
 import javax.swing.*;
 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 JButton toggleButton;
+    private static final Color RUNNING_COLOR = new Color(0x3F, 0xB9, 0x50);
 
-    private ScheduledExecutorService periodicScheduler;
-    private ExecutorService movementExecutor;
-    private CursorMover cursorMover;
+    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;
+    private final CursorMoveListener awayDetector;
+
+    private final JFrame frame = new JFrame();
+
+    // 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;
 
+    private ScheduledExecutorService periodicScheduler;
+    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.
-     * Must be called on the EDT.
+     * Creates the window around the given settings: the components read
+     * 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();
+            }
         });
 
-        toggleButton = new JButton();
-        toggleButton.setBounds(new Rectangle((WINDOW_WIDTH / 2) - 60, WINDOW_HEIGHT - 60, 120, 30));
-        toggleButton.addActionListener(e -> toggleRunning());
-        frame.add(toggleButton);
+        // ⌘Q on macOS defaults to calling System.exit(0) directly, which
+        // bypasses windowClosing and skips cleanup: route quits through
+        // the window instead, so the hook is always released
+        if (Desktop.isDesktopSupported()) {
+            try {
+                Desktop.getDesktop().setQuitStrategy(QuitStrategy.CLOSE_ALL_WINDOWS);
+            } catch (UnsupportedOperationException ex) {
+                LOGGER.debug("Quit strategy not supported here", ex);
+            }
+        }
 
-        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);
+        buildContent();
 
         if (SystemTray.isSupported()) {
             addTrayIcon();
         }
 
-        startAutomation();
+        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) {
-
-            Image fullImage = getScreenCapture();
-            return fullImage.getScaledInstance(rescaleWidth, rescaleHeight, Image.SCALE_FAST);
-    }
-
-    public Image getPreciseScreenshot() {
-
-        if(SystemUtil.getHostSystem().equals(SystemUtil.OperatingSystem.MAC_OS)) {
-            BufferedImage screenshot = getScreenCapture();
-            return screenshot.getSubimage(RunnerUtil.SCREEN_WIDTH - 100,0, 100, 30);
+    private void updateToggleLabel() {
+        if (toggleButton == null) {
+            // the window is not initialized yet
+            return;
         }
 
-        return null;
+        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 (trayToggleItem != null) {
+            trayToggleItem.setLabel(running ? "Pause" : "Start");
+        }
     }
 
-    public BufferedImage getScreenCapture() {
-        try {
-            Robot robot = new Robot();
-            return robot.createScreenCapture(new Rectangle(RunnerUtil.SCREEN_WIDTH, RunnerUtil.SCREEN_HEIGHT));
-        } catch (AWTException e) {
-            LOGGER.error("Robot initialization error", e);
+    // ── settings plumbing ───────────────────────────────────────────────
+
+    /** Applies a setting change and persists it right away. */
+    private void applySetting(Runnable setter) {
+        setter.run();
+        configStore.save(config);
+    }
+
+    private static int spinnerValue(JSpinner spinner) {
+        return (Integer) spinner.getValue();
+    }
+
+    /**
+     * 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;
         }
 
-        return null;
+        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.
@@ -127,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);
 
@@ -144,27 +532,60 @@ 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();
-        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-        graphics.setColor(Color.BLACK);
-        graphics.fillPolygon(xPoints, yPoints, xPoints.length);
-        graphics.setColor(Color.WHITE);
-        graphics.drawPolygon(xPoints, yPoints, xPoints.length);
-        graphics.dispose();
-
+        try {
+            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            graphics.setColor(Color.BLACK);
+            graphics.fillPolygon(scaledX, scaledY, scaledX.length);
+            graphics.setColor(Color.WHITE);
+            graphics.setStroke(new BasicStroke((float) Math.max(1.0, scale)));
+            graphics.drawPolygon(scaledX, scaledY, scaledX.length);
+        } finally {
+            graphics.dispose();
+        }
         return image;
     }
 
-    /** Stops the automation and releases everything the app is holding. */
-    private void cleanup() {
+    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
+     * JVM shutdown hooks can race each other on the way out.
+     */
+    public synchronized void cleanup() {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+
         LOGGER.info("Shutting down...");
+        statusTimer.stop();
         stopAutomation();
 
         if (trayIcon != null) {
@@ -175,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
@@ -190,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"
-                            + "   in the main window.\n\n"
+                            + "2. screen recording — lets the app read the cursor position.\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"
@@ -236,82 +658,10 @@ public class MainWindow
     }
 
     /**
-     * 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.
+     * Forwards keyboard activity to the away detection, so that typing
+     * counts as presence even when the mouse never moves.
      */
-    public void toggleRunning() {
-        SwingUtilities.invokeLater(() -> {
-            if (cursorMover == null) {
-                startAutomation();
-            } else {
-                stopAutomation();
-            }
-            updateToggleLabel();
-        });
+    public void notifyKeyboardActivity() {
+        awayDetector.reportKeyboardActivity();
     }
-
-    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.
-        RobotMouseTracker robotTracker = new RobotMouseTracker();
-        CursorMoveListener cursorMoveListener = new CursorMoveListener(robotTracker);
-        periodicScheduler.scheduleWithFixedDelay(cursorMoveListener, 0L, AWAY_POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
-
-        cursorMover = new CursorMover(movementExecutor, robotTracker, cursorMoveListener::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;
-    public static final int SCREEN_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width;
+        if (area == ScreenArea.ALL) {
+            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

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<Configuration status="INFO">
+<Configuration status="WARN">
     <Appenders>
         <Console name="ConsoleAppender" target="SYSTEM_OUT">
             <PatternLayout pattern="[%d{HH:mm:ss.SSS}] [%t] %-4level | %logger{36} - %msg%n" />

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++) {
-            listener.run();
+        poll(listener, 1);
+
+        // 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() {
-        // the very first position read must seed the baseline: starting anywhere
-        // else would have counted as a user movement and reset the away timer
+    void firstPollDoesNotCountAsMovementOrIdleTime() {
+        // the very first position read must seed the baseline and the
+        // 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();
-        listener.run();
+        poll(listener, 5);
+        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<>();
-        positions.add(at(100, 100));                              // baseline
-        for (int i = 0; i < 5; i++) positions.add(at(100, 100)); // 5 still polls
-        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
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));                          // baseline
+        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 < 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));
-
-        listener.run(); // seed the baseline
-        for (int i = 0; i < 5; i++) listener.run(); // loops = 5
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < 3; i++) {
+            poll(listener, 1);
+        }
         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
-        for (int i = 0; i < LOOPS_BEFORE_AWAY - 1; i++) listener.run(); // loops = 29
-        assertFalse(listener.isUserAway());
+        // ...and it still takes 30 more still seconds to be away again
+        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<>();
-        positions.add(at(100, 100)); // baseline
-        for (int i = 1; i <= 40; i++) positions.add(at(100 + i, 100));
+        Queue<Point> appPositions = new ArrayDeque<>();
+        appPositions.add(at(100, 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));
-
-        listener.run(); // seed the baseline
+        poll(listener, 1); // 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,53 +136,146 @@ 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];
-        positions[0] = at(100, 100);
-        for (int i = 1; i < positions.length; i++) {
-            positions[i] = at(100 + (i / 2), 100);
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));
+        for (int i = 1; i <= 40; i++) {
+            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++) {
-            listener.run();
+        for (int i = 0; i <= 40; i++) {
+            poll(listener, 1);
         }
 
         assertTrue(listener.isUserAway());
     }
 
+    @Test
+    void keyboardActivityResetsTheAwayTimer() {
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100)); // baseline
+        for (int i = 0; i < 60; i++) {
+            positions.add(at(100, 100)); // the mouse never moves
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
+        }
+        assertFalse(listener.isUserAway());
+
+        // the user is typing without moving the mouse: the timer resets
+        listener.reportKeyboardActivity();
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+
+        // ...and it still takes 30 still seconds to be away again
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
+            assertFalse(listener.isUserAway());
+        }
+
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+    }
+
+    @Test
+    void keyboardActivityBringsTheUserBackWhileAway() {
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS + 3; i++) {
+            positions.add(at(100, 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+        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();
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+    }
+
     @Test
     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
-
-        // polls: baseline, 30 still polls, two app wiggles, then the user's move
-        Point[] positions = new Point[LOOPS_BEFORE_AWAY + 4];
-        for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) {
-            positions[i] = at(100, 100);
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
+            positions.add(at(100, 100));
         }
-        positions[LOOPS_BEFORE_AWAY + 1] = at(150, 100);
-        positions[LOOPS_BEFORE_AWAY + 2] = at(200, 100);
-        positions[LOOPS_BEFORE_AWAY + 3] = at(333, 100);
-        CursorMoveListener listener = scriptedListener(positions);
+        positions.add(at(150, 100)); // app wiggle
+        positions.add(at(200, 100)); // app wiggle
+        positions.add(at(333, 100)); // the user's move
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
 
-        // baseline + 30 still polls: the user goes away
-        for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) {
-            listener.run();
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
+            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);
+    }
+}