a2qlinux 0.2.0__tar.gz → 0.2.1__tar.gz

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/CHANGELOG.md

@@ -3,6 +3,19 @@
 What changed for players, release by release. Technical details are in
 `docs/ARCHITECTURE.md`.
 
+## [0.2.1] — 2026-11-05
+
+### Fixed
+- `a2qlinux-setup --questlog-dir <folder>` now always takes effect: the
+  folder is written into the settings file even when that file already
+  exists, and the other settings in it stay as they were.
+
+### Changed
+- Installing from the source code is one command, `install-from-source.sh`,
+  which builds, installs and sets up. The build looks for Wine's files where
+  the distributions in the install guide keep them, and names missing build
+  tools with the command that installs them.
+
 ## [0.2.0] — 2026-11-05
 
 ### Changed

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: a2qlinux
-Version: 0.2.0
+Version: 0.2.1
 Summary: Questlog Desktop (AION 2 damage meter) on Linux under Proton, with live game traffic.
 Project-URL: homepage, https://github.com/raman78/A2Qlinux
 Project-URL: repository, https://github.com/raman78/A2Qlinux
@@ -116,12 +116,14 @@ for Arch, Debian, Ubuntu, Fedora and openSUSE. In short:
 | `a2qlinux/setup_desktop.py` | `a2qlinux-setup`: dependency and capture checks with install commands, Questlog installation, menu entry, icon |
 | `a2qlinux/bin/` | the built Windows parts (shipped in the package, not in git) |
 | `bridge/` | Windows parts in C: `wpcap.dll` stand-in, `questlog_ctl.exe`, their tests; `build.sh` |
+| `install-from-source.sh` | installs this checkout for development: build, editable pipx install, setup |
 | `tests/` | Python tests: `python3 -m unittest` |
 | `tools/` | diagnostics: replay-file tools, TCP-owner probe |
 
 The Windows parts are built with `clang` against the installed Wine's headers
-(`bridge/build.sh`) — by the release workflow for the packages, by hand in a
-source checkout; built files are not kept in the repository. Releasing:
+(`bridge/build.sh`) — by the release workflow for the packages, by
+`install-from-source.sh` in a source checkout; built files are not kept in
+the repository. Releasing:
 [docs/RELEASE.md](https://github.com/raman78/A2Qlinux/blob/main/docs/RELEASE.md).
 
 ## Not affiliated

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/README.md

@@ -74,12 +74,14 @@ for Arch, Debian, Ubuntu, Fedora and openSUSE. In short:
 | `a2qlinux/setup_desktop.py` | `a2qlinux-setup`: dependency and capture checks with install commands, Questlog installation, menu entry, icon |
 | `a2qlinux/bin/` | the built Windows parts (shipped in the package, not in git) |
 | `bridge/` | Windows parts in C: `wpcap.dll` stand-in, `questlog_ctl.exe`, their tests; `build.sh` |
+| `install-from-source.sh` | installs this checkout for development: build, editable pipx install, setup |
 | `tests/` | Python tests: `python3 -m unittest` |
 | `tools/` | diagnostics: replay-file tools, TCP-owner probe |
 
 The Windows parts are built with `clang` against the installed Wine's headers
-(`bridge/build.sh`) — by the release workflow for the packages, by hand in a
-source checkout; built files are not kept in the repository. Releasing:
+(`bridge/build.sh`) — by the release workflow for the packages, by
+`install-from-source.sh` in a source checkout; built files are not kept in
+the repository. Releasing:
 [docs/RELEASE.md](https://github.com/raman78/A2Qlinux/blob/main/docs/RELEASE.md).
 
 ## Not affiliated

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/a2qlinux/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/a2qlinux/config.py

@@ -140,6 +140,26 @@ def template(questlog_dir=None):
     return "\n".join(lines)
 
 
+def set_questlog_dir(questlog_dir, path=CONFIG_PATH):
+    """Write `questlog_dir` into the settings file, for a2qlinux-setup --questlog-dir.
+
+    A missing file is created from template(); in an existing one only the
+    questlog_dir line changes (or is added), so the user's other settings and
+    comments stay as they are.
+    """
+    path = Path(path)
+    line = f"questlog_dir = {_toml(str(questlog_dir))}"
+    if not path.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(template(questlog_dir))
+        return
+    text = path.read_text()
+    new, count = re.subn(r"(?m)^[ \t]*questlog_dir[ \t]*=.*$", lambda _: line, text, count=1)
+    if not count:
+        new = text + ("" if text.endswith("\n") or not text else "\n") + line + "\n"
+    path.write_text(new)
+
+
 def _toml(value):
     if isinstance(value, bool):
         return "true" if value else "false"

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/a2qlinux/setup_desktop.py

@@ -316,22 +316,28 @@ def main():
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("--questlog-dir", type=Path,
                         default=None,
-                        help=f"folder with Questlog.exe (default: from {config.CONFIG_PATH}, else ~/Games/Questlog); "
-                             "written into a new settings file")
+                        help=f"Questlog's folder (default: from {config.CONFIG_PATH}, else ~/Games/Questlog); "
+                             "written into the settings file. Without Questlog.exe in it, the newest Questlog "
+                             "is installed there")
     parser.add_argument("--desktop-shortcut", action="store_true", help="also put the entry on the desktop")
     args = parser.parse_args()
+    created = not config.CONFIG_PATH.exists()
+    if args.questlog_dir:
+        # Into the settings file, which every A2Qlinux command reads, so the
+        # folder used here is the one the launcher uses later.
+        config.set_questlog_dir(args.questlog_dir.expanduser().resolve())
+    elif created:
+        config.CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        config.CONFIG_PATH.write_text(config.template())
     settings, config_problems = config.load()
-    questlog_dir = (args.questlog_dir or settings.questlog_dir).expanduser().resolve()
+    questlog_dir = settings.questlog_dir.resolve()
     problems = list(config_problems)
-    if not config.CONFIG_PATH.exists():
-        config.CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
-        config.CONFIG_PATH.write_text(config.template(questlog_dir))
-        print(f"Settings: {config.CONFIG_PATH} (every setting at its default, with comments)")
-    elif questlog_dir != settings.questlog_dir.resolve():
-        problems.append(f"--questlog-dir {questlog_dir} differs from {settings.questlog_dir} in "
-                        f"{config.CONFIG_PATH}; set questlog_dir there, which A2Qlinux reads")
-    else:
-        print(f"Settings: {config.CONFIG_PATH}")
+    print(f"Settings: {config.CONFIG_PATH}"
+          + (" (every setting at its default, with comments)" if created else "")
+          + (f"; questlog_dir = {questlog_dir}" if args.questlog_dir else ""))
+    if os.environ.get("QUESTLOG_DIR"):
+        print(f"Note: the QUESTLOG_DIR environment variable sets Questlog's folder to {questlog_dir}, over "
+              f"{config.CONFIG_PATH}; the menu entry and Steam do not see that variable.")
 
     info = os_release()
     missing, wanted = missing_packages()

a2qlinux-0.2.1/bridge/build.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+# Build the Windows parts for x64 with clang and Wine's headers and import
+# libraries; no MinGW toolchain is needed:
+#   a2qlinux/bin/wpcap.dll        stand-in for Npcap's wpcap.dll, fed by the Linux side
+#   a2qlinux/bin/questlog_ctl.exe acts on a running Questlog from inside its Wine session
+#   bridge/tests/*.exe            test programs for the two above
+#   tools/tcp_owner_probe.exe     diagnostic: does Wine report TCP connection owners
+# Rebuild after a Wine update.
+#
+# Wine's files are looked for where the distributions put them (their package
+# file lists, docs/ARCHITECTURE.md §14); WINE_INCLUDE and WINE_LIB override that.
+# Anything missing is reported with the command that installs it.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+# Package names for building, per distribution family (/etc/os-release).
+family=""
+if [ -r /etc/os-release ]; then
+    ids=" $(. /etc/os-release; echo "${ID:-} ${ID_LIKE:-}") "
+    case "$ids" in
+        *" arch "*) family=arch ;;
+        *" ubuntu "*|*" debian "*) family=debian ;;
+        *" fedora "*) family=fedora ;;
+        *" suse "*|*" opensuse "*) family=suse ;;
+    esac
+fi
+case "$family" in
+    arch)   install="sudo pacman -S --needed clang lld wine" ;;
+    debian) install="sudo apt install clang lld libwine-dev" ;;
+    fedora) install="sudo dnf install clang lld wine-devel" ;;
+    suse)   install="sudo zypper install clang lld wine-devel" ;;
+    *)      install="install clang, lld and Wine's development files (headers and import libraries)" ;;
+esac
+
+missing=()
+command -v clang >/dev/null || missing+=("clang")
+command -v ld.lld >/dev/null || missing+=("lld (ld.lld)")
+
+# Include root: the folder holding msvcrt/ and windows/ (Arch, Fedora, openSUSE:
+# /usr/include/wine; Debian, Ubuntu: /usr/include/wine/wine).
+W="${WINE_INCLUDE:-}"
+if [ -z "$W" ]; then
+    for candidate in /usr/include/wine /usr/include/wine/wine; do
+        if [ -f "$candidate/windows/windows.h" ] && [ -d "$candidate/msvcrt" ]; then W="$candidate"; break; fi
+    done
+fi
+[ -n "$W" ] && [ -f "$W/windows/windows.h" ] || missing+=("Wine's headers (windows/windows.h)")
+
+# Import libraries for x86_64 Windows programs (Arch: /usr/lib/wine; openSUSE:
+# /usr/lib64/wine; Debian, Ubuntu: /usr/lib/x86_64-linux-gnu/wine).
+L="${WINE_LIB:-}"
+if [ -z "$L" ]; then
+    for candidate in /usr/lib/wine/x86_64-windows /usr/lib64/wine/x86_64-windows \
+                     /usr/lib/x86_64-linux-gnu/wine/x86_64-windows; do
+        if [ -f "$candidate/libkernel32.a" ]; then L="$candidate"; break; fi
+    done
+fi
+[ -n "$L" ] && [ -f "$L/libkernel32.a" ] || missing+=("Wine's x86_64 import libraries (x86_64-windows/libkernel32.a)")
+
+if [ ${#missing[@]} -gt 0 ]; then
+    echo "bridge/build.sh: cannot build, missing: $(IFS=';'; echo "${missing[*]}" | sed 's/;/; /g')" >&2
+    echo "  $install" >&2
+    echo "  (Wine's files in other folders: set WINE_INCLUDE and WINE_LIB.)" >&2
+    exit 1
+fi
+echo "Wine's headers: $W; import libraries: $L"
+
+mkdir -p ../a2qlinux/bin
+CF=(--target=x86_64-w64-windows-gnu -fuse-ld=lld -nostdinc -isystem "$W/msvcrt" -isystem "$W/windows"
+    -isystem "$(clang -print-resource-dir)/include" -O2 -Wall -Wextra)
+clang "${CF[@]}" -shared -o ../a2qlinux/bin/wpcap.dll wpcap_bridge.c -nostdlib -L"$L" -lucrtbase -lkernel32 -luser32 -lws2_32 \
+    -Wl,--entry=DllMain
+clang "${CF[@]}" -o ../a2qlinux/bin/questlog_ctl.exe questlog_ctl.c -nostdlib -L"$L" -lucrtbase -lkernel32 -luser32 \
+    -lshell32 -Wl,--entry=start
+clang "${CF[@]}" -o tests/bridge_client_test.exe tests/bridge_client_test.c -nostdlib -L"$L" -lucrtbase -lkernel32 \
+    -Wl,--entry=main
+clang "${CF[@]}" -o tests/zorder_guard_test.exe tests/zorder_guard_test.c -nostdlib -L"$L" -lucrtbase -lkernel32 \
+    -luser32 -lshell32 -Wl,--entry=start
+clang "${CF[@]}" -o ../tools/tcp_owner_probe.exe ../tools/tcp_owner_probe.c -nostdlib -L"$L" -lucrtbase \
+    -lkernel32 -liphlpapi -lws2_32 -Wl,--entry=main
+echo "built: a2qlinux/bin/wpcap.dll, a2qlinux/bin/questlog_ctl.exe, bridge/tests/*.exe, tools/tcp_owner_probe.exe"

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/docs/ARCHITECTURE.md

@@ -735,7 +735,8 @@ privileges a Wine process should not have. `dumpcap` gets them through the
 `wireshark` group and its file capabilities, and runs as the normal user.
 
 **The DLL built with clang against Wine's headers**, not MinGW: the build
-needs only `clang`, `lld` and the installed Wine (`bridge/build.sh`).
+needs only `clang`, `lld` and the installed Wine's development files
+(`bridge/build.sh`, §14).
 
 **Our tray instead of fixing the Wine one** — §6.2. **The guard instead of a
 patched Proton** — §6.1. **Session end after a delay instead of an immediate
@@ -856,7 +857,15 @@ release.
 `a2qlinux/config.py` reads `~/.config/a2qlinux/config.toml` (or under
 `$XDG_CONFIG_HOME`) with the standard library's `tomllib`. `a2qlinux-setup`
 writes it when missing (`config.template`), with every setting at its
-default and a comment for each; it never rewrites an existing file.
+default and a comment for each. It changes an existing file in one case
+only: `a2qlinux-setup --questlog-dir` (`config.set_questlog_dir`) replaces
+the `questlog_dir` line, or adds it, and leaves every other line and comment
+as it was. The setup then reads the folder back from the file, like every
+other command, so the folder it checks and installs Questlog into is the
+one the launcher uses later. An earlier version only wrote the option into
+a new file; with a file already there, the option was refused, and the
+first-installation code would have installed into a folder the settings did
+not name.
 
 | Setting | Default | Replaces | Read by |
 |---|---|---|---|
@@ -980,6 +989,28 @@ case reads as a missing group membership, not as a missing package.
 `pipx install protontricks` provides the command (its wheel's entry
 points). Debian's `wireshark-common` asks whether non-root users may
 capture, with no as the default (its debconf template `install-setuid`);
-`dpkg-reconfigure wireshark-common` changes the answer. `bridge/build.sh`
-uses Arch's Wine paths; users of other distributions install the package
-from PyPI, which carries the built parts (§12).
+`dpkg-reconfigure wireshark-common` changes the answer.
+
+**Building from source** (`bridge/build.sh`, `install-from-source.sh`).
+The build needs `clang`, `ld.lld` and Wine's headers and x86_64 import
+libraries. Where the distributions put the latter, from their package file
+lists: headers under `/usr/include/wine` (Arch, Fedora, openSUSE) or
+`/usr/include/wine/wine` (Debian, Ubuntu, package `libwine-dev`); import
+libraries in `x86_64-windows` under `/usr/lib/wine` (Arch),
+`/usr/lib64/wine` (openSUSE) or `/usr/lib/x86_64-linux-gnu/wine` (Debian,
+Ubuntu). `build.sh` tries these in turn, takes `WINE_INCLUDE` / `WINE_LIB`
+over them, and when something is missing prints the family's install line
+(from `/etc/os-release`, as `a2qlinux-setup` does) and exits 1 before
+compiling. Fedora 44's `wine-devel` file list (mdapi) showed only
+`i386-windows` import libraries; whether its x86_64 ones live under
+`/usr/lib64/wine` is not established, and the build would then say so.
+Checked here: the detected Arch paths and a Debian-shaped layout given
+through the variables build code and data sections identical to the
+previous script's (`llvm-objdump` of `.text`, `.rdata`, `.data`; the files
+differ only in the PE time stamp, which changes on every build). Only Arch
+has built it for real. `install-from-source.sh` runs `build.sh`,
+`pipx install --editable .` (after `pipx uninstall a2qlinux` if one is
+installed, since pipx refuses a second install), `pipx ensurepath` and
+`a2qlinux-setup` with `PIPX_BIN_DIR` (default `~/.local/bin`) put first on
+`PATH`, so the menu entry points at pipx's stable command folder rather
+than at the environment's own `bin`.

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/docs/INSTALL.md

@@ -180,7 +180,7 @@ What the setup does, in order:
 | checks the programs from "Installing the packages", and for missing ones prints one install command for your distribution | `missing: …` and the command |
 | tries a one-second capture, to see that capturing is allowed | `capturing is not allowed yet …` and the commands, if not |
 | starts A2Qlinux's tray icon for a moment, without showing it, to see that it can run on your desktop | a reason, if not; see "The tray icon" in [TROUBLESHOOTING.md](TROUBLESHOOTING.md) |
-| installs Questlog in `~/Games/Questlog` if it is not there yet (about 130 MB) | `Downloading Questlog …`, then `Installed Questlog …` |
+| installs Questlog in its folder (`~/Games/Questlog`, or the one given with `--questlog-dir`) if it is not there yet (about 130 MB) | `Downloading Questlog …`, then `Installed Questlog …` |
 | takes Questlog's icon from it (A2Qlinux does not ship Questlog's logo) | `Icon: …` |
 | creates the "Questlog (AION 2)" entry in your applications menu | `Menu entry: …` |
 | prints the line for Steam's launch options, used in the optional last section | `Steam > AION 2 > …` |
@@ -188,10 +188,29 @@ What the setup does, in order:
 It runs nothing with `sudo` and changes nothing in the game; the commands
 that need administrator rights are printed for you to run.
 
-If you already have Questlog unpacked somewhere else, give its folder once
-as `a2qlinux-setup --questlog-dir <folder>`; it is written into A2Qlinux's
-settings file and nothing is downloaded. If the automatic installation
-fails, the message says why; installing Questlog by hand is described in
+**Questlog in another folder.** A2Qlinux keeps Questlog in `~/Games/Questlog`
+unless you tell it otherwise. To use another folder, run the setup once
+with it:
+
+```
+a2qlinux-setup --questlog-dir <folder>
+```
+
+The setup writes that folder into A2Qlinux's settings file (only that line;
+your other settings stay), so the menu entry, the Steam launch option and
+every later run of the setup use it; you do not give it again. Then:
+
+| What is in the folder | What the setup does |
+|---|---|
+| a Questlog you unpacked before (`Questlog.exe` is there) | uses it; nothing is downloaded |
+| nothing, or the folder does not exist yet | installs the newest Questlog there |
+| other files, but no `Questlog.exe` | installs nothing, and says so; choose an empty folder |
+
+To move back to the default, run it with `--questlog-dir ~/Games/Questlog`,
+or change `questlog_dir` in the settings file.
+
+If the automatic installation fails, the message says why; installing
+Questlog by hand is described in
 [UPDATING.md](UPDATING.md#installing-questlog-by-hand).
 
 The menu entry keeps itself up to date: each time `a2qlinux` starts, it
@@ -199,18 +218,51 @@ checks that the entry (and the desktop icon, if you have one) still runs
 this installation, and writes it again if not, for example after A2Qlinux
 was reinstalled elsewhere. Options you added to the entry by hand stay.
 
-**From the source code instead** (for changing A2Qlinux itself): in a copy of
-the repository, build the small Windows parts once (needs `clang`, `lld` and
-`wine`), then install that copy so that your changes take effect at once,
-instead of steps 1 and 2:
-```
-bash bridge/build.sh && pipx install --editable .
-```
-Then run `a2qlinux-setup` as above. The build script looks for Wine's
-files where Arch and CachyOS put them (`/usr/include/wine`,
-`/usr/lib/wine/x86_64-windows`). On other distributions `pipx install
-a2qlinux` is the simpler way, since that package comes with these parts
-built.
+### From the source code instead
+
+This is for changing A2Qlinux itself; to use it, the PyPI package above is
+all you need. Installing from a copy of the repository differs in two
+ways. The small Windows parts A2Qlinux puts into the game's Proton
+environment are not in the repository, only in the PyPI package, so they
+are built first. And the copy is installed *editable*: pipx runs the files
+in your copy instead of its own copies of them, so a change you make takes
+effect the next time A2Qlinux starts, without installing again.
+
+1. Install what the build needs, besides the packages above:
+
+   | Distribution | Command |
+   |---|---|
+   | Arch, CachyOS | `sudo pacman -S --needed clang lld wine` |
+   | Debian, Ubuntu | `sudo apt install clang lld libwine-dev` |
+   | Fedora | `sudo dnf install clang lld wine-devel` |
+   | openSUSE | `sudo zypper install clang lld wine-devel` |
+
+   `clang` and `lld` compile and link the Windows parts; the Wine package
+   provides the Windows headers and libraries they are built against.
+2. Get the repository and run its installer from it:
+   ```
+   git clone https://github.com/raman78/A2Qlinux.git && cd A2Qlinux && ./install-from-source.sh --desktop-shortcut
+   ```
+3. Open a new terminal, so that the A2Qlinux commands are found, and read
+   the end of what the installer printed, as in step 4 above.
+
+What `install-from-source.sh` does, in order, with a line `== 1/4 …` and so
+on for each step:
+
+| Step | Command it runs | Why |
+|---|---|---|
+| 1 | `bash bridge/build.sh` | builds the Windows parts into the copy. It finds Wine's files in the folders Arch, Debian, Ubuntu, Fedora and openSUSE use; if something is missing it prints the install command for your distribution |
+| 2 | `pipx install --editable .` | installs this copy (the `.` is the current folder); an A2Qlinux installed before is removed first, whether from PyPI or another copy |
+| 3 | `pipx ensurepath` | as in step 2 above |
+| 4 | `a2qlinux-setup` | the same checks and setup as above; options given to the installer, such as `--desktop-shortcut`, are passed on |
+
+Run it again after `git pull` when the Windows parts changed, or after a
+Wine update (the parts are built against the installed Wine). A change to
+the Python files needs nothing. Building has been tried on Arch and
+CachyOS only so far; the other distributions' folders come from their
+package file lists. If Wine's files are somewhere else, the build says so;
+give the folders as `WINE_INCLUDE=<folder with windows/windows.h>` and
+`WINE_LIB=<folder with libkernel32.a>` in front of the command.
 
 ## Checking that it works
 

{a2qlinux-0.2.0 → a2qlinux-0.2.1}/tests/test_config.py

@@ -78,5 +78,39 @@ class LoadTest(unittest.TestCase):
         self.assertEqual(settings.after_game, "keep")
 
 
+class SetQuestlogDirTest(unittest.TestCase):
+    """a2qlinux-setup --questlog-dir writes the folder into the settings file, new or existing."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.path = Path(self.tmp.name) / "a2qlinux" / "config.toml"
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_a_missing_file_is_created_with_the_folder(self):
+        config.set_questlog_dir("/games/QL", self.path)
+        settings, problems = config.load(self.path)
+        self.assertEqual((settings.questlog_dir, problems), (Path("/games/QL"), []))
+        self.assertIn("after_game", self.path.read_text())          # the full template
+
+    def test_an_existing_file_changes_only_that_line(self):
+        self.path.parent.mkdir(parents=True)
+        self.path.write_text('# mine\nquestlog_dir = "/old"\nauto_update = false   # off\n')
+        config.set_questlog_dir("/new/QL", self.path)
+        self.assertEqual(self.path.read_text(), '# mine\nquestlog_dir = "/new/QL"\nauto_update = false   # off\n')
+
+    def test_a_file_without_the_line_gets_it_added(self):
+        self.path.parent.mkdir(parents=True)
+        self.path.write_text("auto_update = false")
+        config.set_questlog_dir("/new/QL", self.path)
+        settings, problems = config.load(self.path)
+        self.assertEqual((settings.questlog_dir, settings.auto_update, problems), (Path("/new/QL"), False, []))
+
+    def test_quotes_and_backslashes_in_the_folder_survive(self):
+        config.set_questlog_dir('/games/"odd" \\ name', self.path)
+        self.assertEqual(config.load(self.path)[0].questlog_dir, Path('/games/"odd" \\ name'))
+
+
 if __name__ == "__main__":
     unittest.main()

a2qlinux-0.2.0/bridge/build.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-# Build the Windows parts for x64 with clang and Wine's headers and import
-# libraries; no MinGW toolchain is needed:
-#   a2qlinux/bin/wpcap.dll        stand-in for Npcap's wpcap.dll, fed by the Linux side
-#   a2qlinux/bin/questlog_ctl.exe acts on a running Questlog from inside its Wine session
-#   bridge/tests/*.exe            test programs for the two above
-#   tools/tcp_owner_probe.exe     diagnostic: does Wine report TCP connection owners
-# Rebuild after a Wine update.
-set -euo pipefail
-cd "$(dirname "$0")"
-mkdir -p ../a2qlinux/bin
-W=/usr/include/wine
-L=/usr/lib/wine/x86_64-windows
-CF=(--target=x86_64-w64-windows-gnu -fuse-ld=lld -nostdinc -isystem "$W/msvcrt" -isystem "$W/windows"
-    -isystem "$(clang -print-resource-dir)/include" -O2 -Wall -Wextra)
-clang "${CF[@]}" -shared -o ../a2qlinux/bin/wpcap.dll wpcap_bridge.c -nostdlib -L"$L" -lucrtbase -lkernel32 -luser32 -lws2_32 \
-    -Wl,--entry=DllMain
-clang "${CF[@]}" -o ../a2qlinux/bin/questlog_ctl.exe questlog_ctl.c -nostdlib -L"$L" -lucrtbase -lkernel32 -luser32 \
-    -lshell32 -Wl,--entry=start
-clang "${CF[@]}" -o tests/bridge_client_test.exe tests/bridge_client_test.c -nostdlib -L"$L" -lucrtbase -lkernel32 \
-    -Wl,--entry=main
-clang "${CF[@]}" -o tests/zorder_guard_test.exe tests/zorder_guard_test.c -nostdlib -L"$L" -lucrtbase -lkernel32 \
-    -luser32 -lshell32 -Wl,--entry=start
-clang "${CF[@]}" -o ../tools/tcp_owner_probe.exe ../tools/tcp_owner_probe.c -nostdlib -L"$L" -lucrtbase \
-    -lkernel32 -liphlpapi -lws2_32 -Wl,--entry=main
-echo "built: a2qlinux/bin/wpcap.dll, a2qlinux/bin/questlog_ctl.exe, bridge/tests/*.exe, tools/tcp_owner_probe.exe"