add xdg-desktop-portal backend and picker mode UI

Status	File	+	-
M	`Cargo.lock`	506	10
M	`Cargo.toml`	7	0
A	`garfield-portal/Cargo.toml`	28	0
A	`garfield-portal/README.md`	146	0
A	`garfield-portal/data/gar-portals.conf`	15	0
A	`garfield-portal/data/garfield-portal.service`	12	0
A	`garfield-portal/data/garfield.portal`	4	0
A	`garfield-portal/install.sh`	296	0
A	`garfield-portal/src/file_chooser.rs`	319	0
A	`garfield-portal/src/main.rs`	56	0
A	`garfield-portal/src/request.rs`	117	0
A	`garfield-portal/test-portal.sh`	76	0
M	`garfield/Cargo.toml`	3	0
M	`garfield/src/app.rs`	289	54
M	`garfield/src/core/entry.rs`	65	0
M	`garfield/src/core/mod.rs`	1	1
M	`garfield/src/main.rs`	147	13
M	`garfield/src/ui/mod.rs`	4	2
M	`garfield/src/ui/pane.rs`	219	12
A	`garfield/src/ui/picker_toolbar.rs`	241	0
M	`garfield/src/ui/tab.rs`	10	5
M	`garfield/src/ui/tab_bar.rs`	114	11

Cargo.lockmodified

  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
++[[package]]
++name = "async-broadcast"
++version = "0.7.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
++dependencies = [
++ "event-listener",
++ "event-listener-strategy",
++ "futures-core",
++ "pin-project-lite",
++]
++
++[[package]]
++name = "async-recursion"
++version = "1.1.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
++[[package]]
++name = "async-trait"
++version = "0.1.89"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
  [[package]]
  name = "autocfg"
  version = "1.5.0"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
++[[package]]
++name = "bytes"
++version = "1.11.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
++
  [[package]]
  name = "cairo-rs"
  version = "0.20.12"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
++[[package]]
++name = "concurrent-queue"
++version = "2.5.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
++dependencies = [
++ "crossbeam-utils",
++]
++
  [[package]]
  name = "core-foundation-sys"
  version = "0.8.7"
   "cfg-if",
+ ]
++[[package]]
++name = "crossbeam-utils"
++version = "0.8.21"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
++
  [[package]]
  name = "dirs"
  version = "6.0.0"
   "windows-sys 0.61.2",
+ ]
++[[package]]
++name = "endi"
++version = "1.1.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
++
++[[package]]
++name = "enumflags2"
++version = "0.7.12"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
++dependencies = [
++ "enumflags2_derive",
++ "serde",
++]
++
++[[package]]
++name = "enumflags2_derive"
++version = "0.7.12"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
  [[package]]
  name = "equivalent"
  version = "1.0.2"
   "windows-sys 0.61.2",
+ ]
++[[package]]
++name = "event-listener"
++version = "5.4.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
++dependencies = [
++ "concurrent-queue",
++ "parking",
++ "pin-project-lite",
++]
++
++[[package]]
++name = "event-listener-strategy"
++version = "0.5.4"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
++dependencies = [
++ "event-listener",
++ "pin-project-lite",
++]
++
++[[package]]
++name = "fastrand"
++version = "2.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
++
  [[package]]
  name = "fdeflate"
  version = "0.3.7"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
++[[package]]
++name = "futures-lite"
++version = "2.6.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
++dependencies = [
++ "fastrand",
++ "futures-core",
++ "futures-io",
++ "parking",
++ "pin-project-lite",
++]
++
  [[package]]
  name = "futures-macro"
  version = "0.3.31"
   "anyhow",
   "cairo-rs 0.21.5",
   "chrono",
++ "clap",
   "dirs",
   "freedesktop_entry_parser",
   "garfield-ipc",
   "thiserror 2.0.18",
+ ]
++[[package]]
++name = "garfield-portal"
++version = "0.1.0"
++dependencies = [
++ "anyhow",
++ "clap",
++ "tokio",
++ "tracing",
++ "tracing-subscriber",
++ "zbus",
++]
++
  [[package]]
  name = "garfieldctl"
  version = "0.1.0"
   "wasi",
+ ]
++[[package]]
++name = "getrandom"
++version = "0.3.4"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
++dependencies = [
++ "cfg-if",
++ "libc",
++ "r-efi",
++ "wasip2",
++]
++
  [[package]]
  name = "gif"
  version = "0.14.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
++[[package]]
++name = "hex"
++version = "0.4.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
++
  [[package]]
  name = "iana-time-zone"
  version = "0.1.64"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
++[[package]]
++name = "memoffset"
++version = "0.9.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
++dependencies = [
++ "autocfg",
++]
++
  [[package]]
  name = "minimal-lexical"
  version = "0.2.1"
   "simd-adler32",
+ ]
++[[package]]
++name = "mio"
++version = "1.1.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
++dependencies = [
++ "libc",
++ "wasi",
++ "windows-sys 0.61.2",
++]
++
  [[package]]
  name = "moxcms"
  version = "0.7.11"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
++[[package]]
++name = "ordered-stream"
++version = "0.2.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
++dependencies = [
++ "futures-core",
++ "pin-project-lite",
++]
++
  [[package]]
  name = "pango"
  version = "0.20.12"
   "system-deps",
+ ]
++[[package]]
++name = "parking"
++version = "2.2.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
++
  [[package]]
  name = "pin-project-lite"
  version = "0.2.16"
   "proc-macro2",
+ ]
++[[package]]
++name = "r-efi"
++version = "5.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
++
  [[package]]
  name = "redox_users"
  version = "0.5.2"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
  dependencies = [
-- "getrandom",
++ "getrandom 0.2.17",
   "libredox",
   "thiserror 2.0.18",
+ ]
   "zmij",
+ ]
++[[package]]
++name = "serde_repr"
++version = "0.1.20"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
  [[package]]
  name = "serde_spanned"
  version = "1.0.4"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
++[[package]]
++name = "signal-hook-registry"
++version = "1.4.8"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
++dependencies = [
++ "errno",
++ "libc",
++]
++
  [[package]]
  name = "simd-adler32"
  version = "0.3.8"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
++[[package]]
++name = "socket2"
++version = "0.6.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
++dependencies = [
++ "libc",
++ "windows-sys 0.60.2",
++]
++
  [[package]]
  name = "strsim"
  version = "0.11.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
++[[package]]
++name = "tempfile"
++version = "3.24.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
++dependencies = [
++ "fastrand",
++ "getrandom 0.3.4",
++ "once_cell",
++ "rustix",
++ "windows-sys 0.61.2",
++]
++
  [[package]]
  name = "thiserror"
  version = "1.0.69"
   "cfg-if",
+ ]
++[[package]]
++name = "tokio"
++version = "1.49.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
++dependencies = [
++ "bytes",
++ "libc",
++ "mio",
++ "pin-project-lite",
++ "signal-hook-registry",
++ "socket2",
++ "tokio-macros",
++ "tracing",
++ "windows-sys 0.61.2",
++]
++
++[[package]]
++name = "tokio-macros"
++version = "2.6.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
  [[package]]
  name = "toml"
  version = "0.9.11+spec-1.1.0"
   "tracing-log",
+ ]
++[[package]]
++name = "uds_windows"
++version = "1.1.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "89daebc3e6fd160ac4aa9fc8b3bf71e1f74fbf92367ae71fb83a037e8bf164b9"
++dependencies = [
++ "memoffset",
++ "tempfile",
++ "winapi",
++]
++
  [[package]]
  name = "unicode-ident"
  version = "1.0.22"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
++[[package]]
++name = "uuid"
++version = "1.20.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f"
++dependencies = [
++ "js-sys",
++ "serde_core",
++ "wasm-bindgen",
++]
++
  [[package]]
  name = "valuable"
  version = "0.1.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
++[[package]]
++name = "wasip2"
++version = "1.0.2+wasi-0.2.9"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
++dependencies = [
++ "wit-bindgen",
++]
++
  [[package]]
  name = "wasm-bindgen"
  version = "0.2.108"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
++[[package]]
++name = "winapi"
++version = "0.3.9"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
++dependencies = [
++ "winapi-i686-pc-windows-gnu",
++ "winapi-x86_64-pc-windows-gnu",
++]
++
++[[package]]
++name = "winapi-i686-pc-windows-gnu"
++version = "0.4.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
++
  [[package]]
  name = "winapi-util"
  version = "0.1.11"
   "windows-sys 0.61.2",
+ ]
++[[package]]
++name = "winapi-x86_64-pc-windows-gnu"
++version = "0.4.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
++
  [[package]]
  name = "windows-core"
  version = "0.62.2"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
  dependencies = [
-- "windows-targets",
++ "windows-targets 0.52.6",
++]
++
++[[package]]
++name = "windows-sys"
++version = "0.60.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
++dependencies = [
++ "windows-targets 0.53.5",
+ ]
  [[package]]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
  dependencies = [
-- "windows_aarch64_gnullvm",
++ "windows_aarch64_gnullvm 0.52.6",
-- "windows_aarch64_msvc",
++ "windows_aarch64_msvc 0.52.6",
-- "windows_i686_gnu",
++ "windows_i686_gnu 0.52.6",
-- "windows_i686_gnullvm",
++ "windows_i686_gnullvm 0.52.6",
-- "windows_i686_msvc",
++ "windows_i686_msvc 0.52.6",
-- "windows_x86_64_gnu",
++ "windows_x86_64_gnu 0.52.6",
-- "windows_x86_64_gnullvm",
++ "windows_x86_64_gnullvm 0.52.6",
-- "windows_x86_64_msvc",
++ "windows_x86_64_msvc 0.52.6",
++]
++
++[[package]]
++name = "windows-targets"
++version = "0.53.5"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
++dependencies = [
++ "windows-link",
++ "windows_aarch64_gnullvm 0.53.1",
++ "windows_aarch64_msvc 0.53.1",
++ "windows_i686_gnu 0.53.1",
++ "windows_i686_gnullvm 0.53.1",
++ "windows_i686_msvc 0.53.1",
++ "windows_x86_64_gnu 0.53.1",
++ "windows_x86_64_gnullvm 0.53.1",
++ "windows_x86_64_msvc 0.53.1",
+ ]
  [[package]]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
++[[package]]
++name = "windows_aarch64_gnullvm"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
++
  [[package]]
  name = "windows_aarch64_msvc"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
++[[package]]
++name = "windows_aarch64_msvc"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
++
  [[package]]
  name = "windows_i686_gnu"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
++[[package]]
++name = "windows_i686_gnu"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
++
  [[package]]
  name = "windows_i686_gnullvm"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
++[[package]]
++name = "windows_i686_gnullvm"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
++
  [[package]]
  name = "windows_i686_msvc"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
++[[package]]
++name = "windows_i686_msvc"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
++
  [[package]]
  name = "windows_x86_64_gnu"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
++[[package]]
++name = "windows_x86_64_gnu"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
++
  [[package]]
  name = "windows_x86_64_gnullvm"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
++[[package]]
++name = "windows_x86_64_gnullvm"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
++
  [[package]]
  name = "windows_x86_64_msvc"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
++[[package]]
++name = "windows_x86_64_msvc"
++version = "0.53.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
++
  [[package]]
  name = "winnow"
  version = "0.7.14"
   "memchr",
+ ]
++[[package]]
++name = "wit-bindgen"
++version = "0.51.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
++
  [[package]]
  name = "x11rb"
  version = "0.13.2"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "bec9e4a500ca8864c5b47b8b482a73d62e4237670e5b5f1d6b9e3cae50f28f2b"
++[[package]]
++name = "zbus"
++version = "5.13.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "1bfeff997a0aaa3eb20c4652baf788d2dfa6d2839a0ead0b3ff69ce2f9c4bdd1"
++dependencies = [
++ "async-broadcast",
++ "async-recursion",
++ "async-trait",
++ "enumflags2",
++ "event-listener",
++ "futures-core",
++ "futures-lite",
++ "hex",
++ "libc",
++ "ordered-stream",
++ "rustix",
++ "serde",
++ "serde_repr",
++ "tokio",
++ "tracing",
++ "uds_windows",
++ "uuid",
++ "windows-sys 0.61.2",
++ "winnow",
++ "zbus_macros",
++ "zbus_names",
++ "zvariant",
++]
++
++[[package]]
++name = "zbus_macros"
++version = "5.13.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "0bbd5a90dbe8feee5b13def448427ae314ccd26a49cac47905cafefb9ff846f1"
++dependencies = [
++ "proc-macro-crate",
++ "proc-macro2",
++ "quote",
++ "syn",
++ "zbus_names",
++ "zvariant",
++ "zvariant_utils",
++]
++
++[[package]]
++name = "zbus_names"
++version = "4.3.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f"
++dependencies = [
++ "serde",
++ "winnow",
++ "zvariant",
++]
++
  [[package]]
  name = "zmij"
  version = "1.0.16"
  dependencies = [
   "zune-core",
+ ]
++
++[[package]]
++name = "zvariant"
++version = "5.9.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "68b64ef4f40c7951337ddc7023dd03528a57a3ce3408ee9da5e948bd29b232c4"
++dependencies = [
++ "endi",
++ "enumflags2",
++ "serde",
++ "winnow",
++ "zvariant_derive",
++ "zvariant_utils",
++]
++
++[[package]]
++name = "zvariant_derive"
++version = "5.9.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "484d5d975eb7afb52cc6b929c13d3719a20ad650fea4120e6310de3fc55e415c"
++dependencies = [
++ "proc-macro-crate",
++ "proc-macro2",
++ "quote",
++ "syn",
++ "zvariant_utils",
++]
++
++[[package]]
++name = "zvariant_utils"
++version = "3.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "serde",
++ "syn",
++ "winnow",
++]

Cargo.tomlmodified

      "garfield",
      "garfieldctl",
      "garfield-ipc",
++    "garfield-portal",
  ]
  [workspace.package]
  poppler-rs = "0.25"
  cairo-rs = { version = "0.21", features = ["png"] }
++# Async runtime
++tokio = { version = "1", features = ["rt-multi-thread", "macros", "process", "io-util", "sync"] }
++
++# D-Bus
++zbus = { version = "5", default-features = false, features = ["tokio"] }
++
  # IPC types (shared between crates)
  garfield-ipc = { path = "garfield-ipc" }

garfield-portal/Cargo.tomladded

++[package]
++name = "garfield-portal"
++version.workspace = true
++edition.workspace = true
++authors.workspace = true
++license.workspace = true
++description = "XDG Desktop Portal backend for garfield file picker"
++
++[[bin]]
++name = "garfield-portal"
++path = "src/main.rs"
++
++[dependencies]
++# Async runtime
++tokio.workspace = true
++
++# D-Bus
++zbus.workspace = true
++
++# Logging
++tracing.workspace = true
++tracing-subscriber.workspace = true
++
++# Error handling
++anyhow.workspace = true
++
++# CLI
++clap.workspace = true

garfield-portal/README.mdadded

++# garfield-portal
++
++XDG Desktop Portal backend for garfield file picker.
++
++This daemon implements the `org.freedesktop.impl.portal.FileChooser` interface, allowing applications to use garfield as the system file picker dialog.
++
++## How It Works
++
++When an application (GTK, Qt, Flatpak, etc.) requests a file dialog through the portal API:
++
++1. `xdg-desktop-portal` receives the request
++2. It routes the request to `garfield-portal` based on configuration
++3. `garfield-portal` spawns `garfield --picker` with appropriate options
++4. User selects files in garfield
++5. Selected paths are returned to the application as `file://` URIs
++
++## Building
++
++```bash
++cargo build --release -p garfield-portal
++```
++
++## Installation
++
++### System-wide (recommended)
++
++```bash
++cd garfield-portal
++./install.sh
++```
++
++This installs:
++- Binary to `/usr/local/bin/garfield-portal`
++- Portal config to `/usr/share/xdg-desktop-portal/portals/garfield.portal`
++- Systemd service to `/usr/lib/systemd/user/garfield-portal.service`
++- Portal preferences to `/usr/share/xdg-desktop-portal/gar-portals.conf`
++
++### User-only
++
++```bash
++./install.sh --user
++```
++
++Installs to `~/.local/` directories instead.
++
++### Enable the Service
++
++After installation:
++
++```bash
++systemctl --user daemon-reload
++systemctl --user enable --now garfield-portal
++```
++
++## Testing
++
++Run the test script:
++
++```bash
++./test-portal.sh
++```
++
++Or test with real applications:
++
++```bash
++# GTK apps
++GTK_USE_PORTAL=1 gedit
++GTK_USE_PORTAL=1 firefox
++
++# Qt/KDE apps
++QT_QPA_PLATFORMTHEME=xdgdesktopportal dolphin
++
++# Flatpak apps (automatically use portals)
++flatpak run org.gnome.TextEditor
++```
++
++## Configuration
++
++### Making garfield the default
++
++For the gar desktop environment, the installer creates `gar-portals.conf`:
++
++```ini
++[preferred]
++default=garfield;gtk
++org.freedesktop.impl.portal.FileChooser=garfield
++```
++
++Set `XDG_CURRENT_DESKTOP=gar` in your session to activate this configuration.
++
++### Manual configuration
++
++To use garfield in other desktop environments, create `~/.config/xdg-desktop-portal/portals.conf`:
++
++```ini
++[preferred]
++default=garfield;gtk
++```
++
++Then restart xdg-desktop-portal:
++
++```bash
++systemctl --user restart xdg-desktop-portal
++```
++
++## Uninstallation
++
++```bash
++./install.sh --uninstall      # System-wide
++./install.sh --uninstall-user # User-only
++```
++
++## Troubleshooting
++
++### Check installation status
++
++```bash
++./install.sh --check
++```
++
++### View logs
++
++```bash
++journalctl --user -u garfield-portal -f
++```
++
++### Common issues
++
++**"Portal not found"**: Make sure `garfield-portal` is running:
++```bash
++systemctl --user status garfield-portal
++```
++
++**"garfield not found"**: The `garfield` binary must be in PATH for picker mode to work.
++
++**Dialog doesn't appear**: Check if `DISPLAY` is set and garfield can connect to X11.
++
++## D-Bus Interface
++
++The portal implements `org.freedesktop.impl.portal.FileChooser`:
++
++- `OpenFile(handle, app_id, parent_window, title, options)` - Open file dialog
++- `SaveFile(handle, app_id, parent_window, title, options)` - Save file dialog
++- `SaveFiles(handle, app_id, parent_window, title, options)` - Save multiple files
++
++See the [XDG Desktop Portal documentation](https://flatpak.github.io/xdg-desktop-portal/) for full details.

garfield-portal/data/gar-portals.confadded

++# XDG Desktop Portal configuration for gar desktop environment
++#
++# This file tells xdg-desktop-portal to prefer garfield for file chooser dialogs.
++# Install to: /usr/share/xdg-desktop-portal/gar-portals.conf
++#          or: ~/.config/xdg-desktop-portal/gar-portals.conf
++#
++# The desktop environment is detected from XDG_CURRENT_DESKTOP.
++# For gar, set: XDG_CURRENT_DESKTOP=gar
++
++[preferred]
++# Use garfield for file dialogs, fall back to gtk if garfield unavailable
++default=garfield;gtk
++
++# Explicitly prefer garfield for FileChooser interface
++org.freedesktop.impl.portal.FileChooser=garfield

garfield-portal/data/garfield-portal.serviceadded

++[Unit]
++Description=Garfield Portal Backend
++PartOf=graphical-session.target
++After=graphical-session.target
++
++[Service]
++Type=dbus
++BusName=org.freedesktop.impl.portal.desktop.garfield
++ExecStart=/usr/local/bin/garfield-portal
++
++[Install]
++WantedBy=xdg-desktop-portal.service

garfield-portal/data/garfield.portaladded

++[portal]
++DBusName=org.freedesktop.impl.portal.desktop.garfield
++Interfaces=org.freedesktop.impl.portal.FileChooser
++UseIn=gar

garfield-portal/install.shadded

++#!/bin/bash
++# Install script for garfield-portal
++#
++# This script installs the garfield portal backend which allows
++# applications to use garfield as the system file picker.
++#
++# Usage:
++#   ./install.sh         - Install to system (requires sudo)
++#   ./install.sh --user  - Install to user directory only
++#   ./install.sh --check - Check installation status
++
++set -e
++
++# Colors for output
++RED='\033[0;31m'
++GREEN='\033[0;32m'
++YELLOW='\033[1;33m'
++NC='\033[0m' # No Color
++
++# Directories
++SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
++BINARY_NAME="garfield-portal"
++GARFIELD_BINARY="garfield"
++PORTAL_FILE="garfield.portal"
++SERVICE_FILE="garfield-portal.service"
++
++# System paths
++SYS_BIN_DIR="/usr/local/bin"
++SYS_PORTAL_DIR="/usr/share/xdg-desktop-portal/portals"
++SYS_PORTALS_CONF_DIR="/usr/share/xdg-desktop-portal"
++
++# User paths
++USER_BIN_DIR="$HOME/.local/bin"
++USER_PORTAL_DIR="$HOME/.local/share/xdg-desktop-portal/portals"
++USER_SERVICE_DIR="$HOME/.config/systemd/user"
++USER_PORTALS_CONF_DIR="$HOME/.config/xdg-desktop-portal"
++
++print_status() {
++    echo -e "${GREEN}[OK]${NC} $1"
++}
++
++print_warning() {
++    echo -e "${YELLOW}[WARN]${NC} $1"
++}
++
++print_error() {
++    echo -e "${RED}[ERROR]${NC} $1"
++}
++
++check_binary() {
++    local name="$1"
++    local binary_path="$SCRIPT_DIR/../target/release/$name"
++    if [[ ! -f "$binary_path" ]]; then
++        binary_path="$SCRIPT_DIR/target/release/$name"
++    fi
++    if [[ ! -f "$binary_path" ]]; then
++        # Try workspace root
++        binary_path="$(dirname "$SCRIPT_DIR")/target/release/$name"
++    fi
++    if [[ ! -f "$binary_path" ]]; then
++        print_error "Binary '$name' not found. Please run 'cargo build --release' first."
++        exit 1
++    fi
++    echo "$binary_path"
++}
++
++install_system() {
++    echo "Installing garfield-portal (system-wide)..."
++
++    local portal_binary garfield_binary
++    portal_binary=$(check_binary "$BINARY_NAME")
++    garfield_binary=$(check_binary "$GARFIELD_BINARY")
++
++    # Install portal daemon binary
++    sudo install -Dm755 "$portal_binary" "$SYS_BIN_DIR/$BINARY_NAME"
++    print_status "Installed binary to $SYS_BIN_DIR/$BINARY_NAME"
++
++    # Install main garfield binary (required for picker mode)
++    sudo install -Dm755 "$garfield_binary" "$SYS_BIN_DIR/$GARFIELD_BINARY"
++    print_status "Installed binary to $SYS_BIN_DIR/$GARFIELD_BINARY"
++
++    # Install portal file
++    sudo install -Dm644 "$SCRIPT_DIR/data/$PORTAL_FILE" "$SYS_PORTAL_DIR/$PORTAL_FILE"
++    print_status "Installed portal config to $SYS_PORTAL_DIR/$PORTAL_FILE"
++
++    # Install systemd service (user service, but to system location)
++    sudo install -Dm644 "$SCRIPT_DIR/data/$SERVICE_FILE" "/usr/lib/systemd/user/$SERVICE_FILE"
++    print_status "Installed systemd service to /usr/lib/systemd/user/$SERVICE_FILE"
++
++    # Install gar-portals.conf
++    sudo install -Dm644 "$SCRIPT_DIR/data/gar-portals.conf" "$SYS_PORTALS_CONF_DIR/gar-portals.conf"
++    print_status "Installed portal preferences to $SYS_PORTALS_CONF_DIR/gar-portals.conf"
++
++    echo ""
++    echo "Installation complete!"
++    echo ""
++    echo "To enable the portal service, run:"
++    echo "  systemctl --user daemon-reload"
++    echo "  systemctl --user enable --now garfield-portal"
++    echo ""
++    echo "To test, run a GTK app with:"
++    echo "  GTK_USE_PORTAL=1 gedit"
++}
++
++install_user() {
++    echo "Installing garfield-portal (user only)..."
++
++    local portal_binary garfield_binary
++    portal_binary=$(check_binary "$BINARY_NAME")
++    garfield_binary=$(check_binary "$GARFIELD_BINARY")
++
++    # Create directories
++    mkdir -p "$USER_BIN_DIR"
++    mkdir -p "$USER_PORTAL_DIR"
++    mkdir -p "$USER_SERVICE_DIR"
++    mkdir -p "$USER_PORTALS_CONF_DIR"
++
++    # Install portal daemon binary
++    install -m755 "$portal_binary" "$USER_BIN_DIR/$BINARY_NAME"
++    print_status "Installed binary to $USER_BIN_DIR/$BINARY_NAME"
++
++    # Install main garfield binary (required for picker mode)
++    install -m755 "$garfield_binary" "$USER_BIN_DIR/$GARFIELD_BINARY"
++    print_status "Installed binary to $USER_BIN_DIR/$GARFIELD_BINARY"
++
++    # Install portal file
++    install -m644 "$SCRIPT_DIR/data/$PORTAL_FILE" "$USER_PORTAL_DIR/$PORTAL_FILE"
++    print_status "Installed portal config to $USER_PORTAL_DIR/$PORTAL_FILE"
++
++    # Install systemd service with modified path
++    sed "s|/usr/local/bin/garfield-portal|$USER_BIN_DIR/garfield-portal|g" \
++        "$SCRIPT_DIR/data/$SERVICE_FILE" > "$USER_SERVICE_DIR/$SERVICE_FILE"
++    print_status "Installed systemd service to $USER_SERVICE_DIR/$SERVICE_FILE"
++
++    # Install gar-portals.conf
++    install -m644 "$SCRIPT_DIR/data/gar-portals.conf" "$USER_PORTALS_CONF_DIR/gar-portals.conf"
++    print_status "Installed portal preferences to $USER_PORTALS_CONF_DIR/gar-portals.conf"
++
++    echo ""
++    echo "Installation complete!"
++    echo ""
++    echo "Make sure $USER_BIN_DIR is in your PATH."
++    echo ""
++    echo "To enable the portal service, run:"
++    echo "  systemctl --user daemon-reload"
++    echo "  systemctl --user enable --now garfield-portal"
++    echo ""
++    echo "To test, run a GTK app with:"
++    echo "  GTK_USE_PORTAL=1 gedit"
++}
++
++uninstall_system() {
++    echo "Uninstalling garfield-portal (system-wide)..."
++
++    # Stop service first
++    systemctl --user stop garfield-portal 2>/dev/null || true
++    systemctl --user disable garfield-portal 2>/dev/null || true
++
++    sudo rm -f "$SYS_BIN_DIR/$BINARY_NAME"
++    sudo rm -f "$SYS_BIN_DIR/$GARFIELD_BINARY"
++    sudo rm -f "/usr/local/sbin/$GARFIELD_BINARY"  # Clean up stray copy
++    sudo rm -f "$SYS_PORTAL_DIR/$PORTAL_FILE"
++    sudo rm -f "/usr/lib/systemd/user/$SERVICE_FILE"
++    sudo rm -f "$SYS_PORTALS_CONF_DIR/gar-portals.conf"
++
++    systemctl --user daemon-reload
++
++    print_status "Uninstalled garfield-portal"
++}
++
++uninstall_user() {
++    echo "Uninstalling garfield-portal (user only)..."
++
++    # Stop service first
++    systemctl --user stop garfield-portal 2>/dev/null || true
++    systemctl --user disable garfield-portal 2>/dev/null || true
++
++    rm -f "$USER_BIN_DIR/$BINARY_NAME"
++    rm -f "$USER_BIN_DIR/$GARFIELD_BINARY"
++    rm -f "$USER_PORTAL_DIR/$PORTAL_FILE"
++    rm -f "$USER_SERVICE_DIR/$SERVICE_FILE"
++    rm -f "$USER_PORTALS_CONF_DIR/gar-portals.conf"
++
++    systemctl --user daemon-reload
++
++    print_status "Uninstalled garfield-portal"
++}
++
++check_installation() {
++    echo "Checking garfield-portal installation..."
++    echo ""
++
++    # Check portal daemon binary
++    if command -v garfield-portal &> /dev/null; then
++        print_status "Portal binary found: $(command -v garfield-portal)"
++    elif [[ -f "$USER_BIN_DIR/$BINARY_NAME" ]]; then
++        print_warning "Portal binary found at $USER_BIN_DIR/$BINARY_NAME (not in PATH)"
++    elif [[ -f "$SYS_BIN_DIR/$BINARY_NAME" ]]; then
++        print_status "Portal binary found at $SYS_BIN_DIR/$BINARY_NAME"
++    else
++        print_error "Portal binary not found"
++    fi
++
++    # Check main garfield binary (required for picker mode)
++    local garfield_path
++    if [[ -f "$SYS_BIN_DIR/$GARFIELD_BINARY" ]]; then
++        garfield_path="$SYS_BIN_DIR/$GARFIELD_BINARY"
++    elif [[ -f "$USER_BIN_DIR/$GARFIELD_BINARY" ]]; then
++        garfield_path="$USER_BIN_DIR/$GARFIELD_BINARY"
++    elif command -v garfield &> /dev/null; then
++        garfield_path="$(command -v garfield)"
++    fi
++
++    if [[ -n "$garfield_path" ]]; then
++        # Check if garfield has picker mode support
++        if "$garfield_path" --help 2>&1 | grep -q "\-\-picker"; then
++            print_status "Garfield binary found with picker support: $garfield_path"
++        else
++            print_error "Garfield binary at $garfield_path does NOT have picker mode!"
++            print_error "The portal will not work. Please reinstall."
++        fi
++    else
++        print_error "Garfield binary not found (required for picker mode)"
++    fi
++
++    # Check portal config
++    if [[ -f "$SYS_PORTAL_DIR/$PORTAL_FILE" ]]; then
++        print_status "Portal config found: $SYS_PORTAL_DIR/$PORTAL_FILE"
++    elif [[ -f "$USER_PORTAL_DIR/$PORTAL_FILE" ]]; then
++        print_status "Portal config found: $USER_PORTAL_DIR/$PORTAL_FILE"
++    else
++        print_error "Portal config not found"
++    fi
++
++    # Check systemd service
++    if systemctl --user is-enabled garfield-portal &> /dev/null; then
++        print_status "Systemd service enabled"
++        if systemctl --user is-active garfield-portal &> /dev/null; then
++            print_status "Systemd service running"
++        else
++            print_warning "Systemd service not running"
++        fi
++    else
++        print_warning "Systemd service not enabled"
++    fi
++
++    # Check D-Bus name
++    if dbus-send --session --print-reply --dest=org.freedesktop.DBus \
++        /org/freedesktop/DBus org.freedesktop.DBus.NameHasOwner \
++        string:"org.freedesktop.impl.portal.desktop.garfield" 2>/dev/null | grep -q "true"; then
++        print_status "D-Bus service registered"
++    else
++        print_warning "D-Bus service not registered (portal may not be running)"
++    fi
++}
++
++show_help() {
++    echo "Usage: $0 [OPTION]"
++    echo ""
++    echo "Install garfield-portal as the system file picker."
++    echo ""
++    echo "Options:"
++    echo "  --user       Install to user directories only (no sudo required)"
++    echo "  --uninstall  Remove system installation"
++    echo "  --uninstall-user  Remove user installation"
++    echo "  --check      Check installation status"
++    echo "  --help       Show this help message"
++    echo ""
++    echo "Without options, installs system-wide (requires sudo)."
++}
++
++case "${1:-}" in
++    --user)
++        install_user
++        ;;
++    --uninstall)
++        uninstall_system
++        ;;
++    --uninstall-user)
++        uninstall_user
++        ;;
++    --check)
++        check_installation
++        ;;
++    --help|-h)
++        show_help
++        ;;
++    "")
++        install_system
++        ;;
++    *)
++        print_error "Unknown option: $1"
++        show_help
++        exit 1
++        ;;
++esac

garfield-portal/src/file_chooser.rsadded

++//! FileChooser portal interface implementation.
++//!
++//! Implements org.freedesktop.impl.portal.FileChooser by spawning
++//! garfield in picker mode.
++
++use crate::request::{build_file_chooser_response, Request, RequestManager, ResponseCode};
++use std::collections::HashMap;
++use std::process::Stdio;
++use tokio::io::{AsyncBufReadExt, BufReader};
++use tokio::process::Command;
++use zbus::zvariant::{ObjectPath, OwnedObjectPath, Value};
++use zbus::{fdo, interface};
++
++/// FileChooser portal backend.
++pub struct FileChooser {
++    request_manager: RequestManager,
++}
++
++impl FileChooser {
++    pub fn new() -> Self {
++        Self {
++            request_manager: RequestManager::new(),
++        }
++    }
++
++    /// Spawn garfield in picker mode and collect results.
++    async fn spawn_picker(
++        &self,
++        handle: OwnedObjectPath,
++        title: &str,
++        directory_mode: bool,
++        multiple: bool,
++        filters: Vec<String>,
++        current_folder: Option<String>,
++    ) -> (u32, HashMap<String, Value<'static>>) {
++        // Use full path to ensure we get the right garfield binary
++        // (user may have old version in ~/.cargo/bin before /usr/local/bin in PATH)
++        let garfield_path = if std::path::Path::new("/usr/local/bin/garfield").exists() {
++            "/usr/local/bin/garfield"
++        } else {
++            "garfield" // Fall back to PATH lookup
++        };
++
++        let mut cmd = Command::new(garfield_path);
++        cmd.arg("--picker");
++
++        if !title.is_empty() {
++            cmd.arg("--title").arg(title);
++        }
++
++        if directory_mode {
++            cmd.arg("--directory");
++        }
++
++        if multiple {
++            cmd.arg("--multiple");
++        }
++
++        if !filters.is_empty() {
++            cmd.arg("--filter").arg(filters.join(";"));
++        }
++
++        if let Some(folder) = current_folder {
++            cmd.arg(&folder);
++        }
++
++        cmd.stdout(Stdio::piped());
++        cmd.stderr(Stdio::inherit()); // Let garfield stderr through for debugging
++
++        tracing::info!("Spawning garfield picker: {:?}", cmd);
++
++        let mut child = match cmd.spawn() {
++            Ok(c) => c,
++            Err(e) => {
++                tracing::error!("Failed to spawn garfield: {}", e);
++                return (ResponseCode::Error as u32, HashMap::new());
++            }
++        };
++
++        tracing::info!("garfield spawned with PID {:?}", child.id());
++
++        // Get stdout handle before adding to manager (we need ownership)
++        let stdout = match child.stdout.take() {
++            Some(s) => s,
++            None => {
++                tracing::error!("Failed to get stdout from garfield");
++                return (ResponseCode::Error as u32, HashMap::new());
++            }
++        };
++
++        // Track the request for cancellation (child still runs, just stdout detached)
++        self.request_manager.add(handle.clone(), child).await;
++
++        // Wait for the child to exit by reading stdout until EOF
++        tracing::info!("Waiting for garfield to complete...");
++        let reader = BufReader::new(stdout);
++        let mut lines = reader.lines();
++        let mut paths = Vec::new();
++
++        while let Ok(Some(line)) = lines.next_line().await {
++            if !line.is_empty() {
++                tracing::debug!("garfield output: {}", line);
++                paths.push(line);
++            }
++        }
++
++        tracing::info!("garfield stdout closed, got {} paths", paths.len());
++
++        // Now remove from manager and check status
++        let request = self.request_manager.remove(&handle.as_ref()).await;
++
++        // Check if cancelled
++        if let Some(req) = &request {
++            if req.cancelled {
++                tracing::info!("Request was cancelled");
++                return (ResponseCode::Cancelled as u32, HashMap::new());
++            }
++        }
++
++        // If we got paths, it's a success
++        if paths.is_empty() {
++            tracing::info!("No paths selected, treating as cancelled");
++            (ResponseCode::Cancelled as u32, HashMap::new())
++        } else {
++            tracing::info!("Returning {} selected paths", paths.len());
++            (ResponseCode::Success as u32, build_file_chooser_response(paths))
++        }
++    }
++
++    /// Parse filter options from the portal format.
++    fn parse_filters(options: &HashMap<&str, Value<'_>>) -> Vec<String> {
++        // Portal filters are: a(sa(us)) - array of (name, array of (type, pattern))
++        // For now, we'll extract glob patterns
++        let mut result = Vec::new();
++
++        if let Some(Value::Array(filters_array)) = options.get("filters") {
++            for filter in filters_array.iter() {
++                // Each filter is (name, patterns_array)
++                if let Value::Structure(s) = filter {
++                    let fields = s.fields();
++                    if fields.len() >= 2 {
++                        if let Value::Array(patterns) = &fields[1] {
++                            for pattern in patterns.iter() {
++                                // Each pattern is (type, pattern_string)
++                                // type 0 = glob, type 1 = mime
++                                if let Value::Structure(ps) = pattern {
++                                    let pfields = ps.fields();
++                                    if pfields.len() >= 2 {
++                                        if let (Value::U32(0), Value::Str(glob)) = (&pfields[0], &pfields[1]) {
++                                            result.push(glob.to_string());
++                                        }
++                                    }
++                                }
++                            }
++                        }
++                    }
++                }
++            }
++        }
++
++        result
++    }
++
++    /// Extract current folder from options.
++    fn parse_current_folder(options: &HashMap<&str, Value<'_>>) -> Option<String> {
++        if let Some(Value::Array(bytes)) = options.get("current_folder") {
++            // current_folder is a byte array (path as bytes)
++            let path_bytes: Vec<u8> = bytes.iter()
++                .filter_map(|v| {
++                    if let Value::U8(b) = v {
++                        Some(*b)
++                    } else {
++                        None
++                    }
++                })
++                .collect();
++
++            // Remove trailing null if present
++            let path_bytes: Vec<u8> = path_bytes.into_iter()
++                .take_while(|&b| b != 0)
++                .collect();
++
++            String::from_utf8(path_bytes).ok()
++        } else {
++            None
++        }
++    }
++}
++
++#[interface(name = "org.freedesktop.impl.portal.FileChooser")]
++impl FileChooser {
++    /// Open a file chooser dialog.
++    ///
++    /// Portal method for opening files.
++    async fn open_file(
++        &self,
++        #[zbus(object_server)] server: &zbus::ObjectServer,
++        handle: ObjectPath<'_>,
++        _app_id: &str,
++        _parent_window: &str,
++        title: &str,
++        options: HashMap<&str, Value<'_>>,
++    ) -> fdo::Result<(u32, HashMap<String, Value<'static>>)> {
++        tracing::info!("OpenFile request: handle={}, title={}", handle, title);
++
++        let handle_owned: OwnedObjectPath = handle.into();
++
++        // Parse options
++        let multiple = options.get("multiple")
++            .and_then(|v| if let Value::Bool(b) = v { Some(*b) } else { None })
++            .unwrap_or(false);
++
++        let directory = options.get("directory")
++            .and_then(|v| if let Value::Bool(b) = v { Some(*b) } else { None })
++            .unwrap_or(false);
++
++        let filters = Self::parse_filters(&options);
++        let current_folder = Self::parse_current_folder(&options);
++
++        tracing::debug!("Registering request object at {}", handle_owned);
++
++        // Register request object for cancellation
++        let request = Request::new(handle_owned.clone(), self.request_manager.clone());
++        server.at(handle_owned.as_ref(), request).await
++            .map_err(|e| fdo::Error::Failed(format!("Failed to register request: {}", e)))?;
++
++        tracing::debug!("Request object registered, spawning picker");
++
++        // Spawn picker and wait for result
++        let result = self.spawn_picker(
++            handle_owned.clone(),
++            title,
++            directory,
++            multiple,
++            filters,
++            current_folder,
++        ).await;
++
++        tracing::debug!("Picker returned: {:?}", result.0);
++
++        // Remove request object
++        let _ = server.remove::<Request, _>(&handle_owned).await;
++
++        tracing::info!("OpenFile returning response code {}", result.0);
++        Ok(result)
++    }
++
++    /// Save a file dialog.
++    ///
++    /// Portal method for saving files.
++    async fn save_file(
++        &self,
++        #[zbus(object_server)] server: &zbus::ObjectServer,
++        handle: ObjectPath<'_>,
++        _app_id: &str,
++        _parent_window: &str,
++        title: &str,
++        options: HashMap<&str, Value<'_>>,
++    ) -> fdo::Result<(u32, HashMap<String, Value<'static>>)> {
++        tracing::info!("SaveFile request: handle={}, title={}", handle, title);
++
++        // For now, save dialogs work like open dialogs but for directories
++        // A full implementation would show a save dialog with filename input
++        let handle_owned: OwnedObjectPath = handle.into();
++        let current_folder = Self::parse_current_folder(&options);
++
++        let request = Request::new(handle_owned.clone(), self.request_manager.clone());
++        server.at(handle_owned.as_ref(), request).await
++            .map_err(|e| fdo::Error::Failed(format!("Failed to register request: {}", e)))?;
++
++        // For save, we pick a directory and the caller handles the filename
++        let result = self.spawn_picker(
++            handle_owned.clone(),
++            title,
++            true, // directory mode for save location
++            false,
++            Vec::new(),
++            current_folder,
++        ).await;
++
++        let _ = server.remove::<Request, _>(&handle_owned).await;
++
++        Ok(result)
++    }
++
++    /// Save multiple files.
++    async fn save_files(
++        &self,
++        #[zbus(object_server)] server: &zbus::ObjectServer,
++        handle: ObjectPath<'_>,
++        _app_id: &str,
++        _parent_window: &str,
++        title: &str,
++        options: HashMap<&str, Value<'_>>,
++    ) -> fdo::Result<(u32, HashMap<String, Value<'static>>)> {
++        tracing::info!("SaveFiles request: handle={}, title={}", handle, title);
++
++        // SaveFiles picks a directory for saving multiple files
++        let handle_owned: OwnedObjectPath = handle.into();
++        let current_folder = Self::parse_current_folder(&options);
++
++        let request = Request::new(handle_owned.clone(), self.request_manager.clone());
++        server.at(handle_owned.as_ref(), request).await
++            .map_err(|e| fdo::Error::Failed(format!("Failed to register request: {}", e)))?;
++
++        let result = self.spawn_picker(
++            handle_owned.clone(),
++            title,
++            true,
++            false,
++            Vec::new(),
++            current_folder,
++        ).await;
++
++        let _ = server.remove::<Request, _>(&handle_owned).await;
++
++        Ok(result)
++    }
++}

garfield-portal/src/main.rsadded

++//! garfield-portal - XDG Desktop Portal backend for garfield file picker.
++//!
++//! This daemon implements the org.freedesktop.impl.portal.FileChooser interface,
++//! spawning garfield in picker mode when applications request file dialogs.
++
++mod file_chooser;
++mod request;
++
++use anyhow::Result;
++use clap::Parser;
++use tracing_subscriber::{fmt, EnvFilter};
++use zbus::connection::Builder;
++
++/// garfield-portal - XDG Desktop Portal backend
++#[derive(Parser, Debug)]
++#[command(name = "garfield-portal", about = "XDG Desktop Portal backend for garfield")]
++struct Args {
++    /// Run in foreground (don't daemonize)
++    #[arg(long, short = 'f')]
++    foreground: bool,
++}
++
++#[tokio::main]
++async fn main() -> Result<()> {
++    // Initialize logging
++    let filter = EnvFilter::try_from_default_env()
++        .unwrap_or_else(|_| EnvFilter::new("info"));
++
++    fmt()
++        .with_env_filter(filter)
++        .with_target(false)
++        .init();
++
++    let _args = Args::parse();
++
++    tracing::info!("Starting garfield-portal");
++
++    // Create the FileChooser interface
++    let file_chooser = file_chooser::FileChooser::new();
++
++    // Connect to session bus and serve the interface
++    let _connection = Builder::session()?
++        .name("org.freedesktop.impl.portal.desktop.garfield")?
++        .serve_at("/org/freedesktop/portal/desktop", file_chooser)?
++        .build()
++        .await?;
++
++    tracing::info!("garfield-portal listening on D-Bus session bus");
++
++    // Keep the service running
++    loop {
++        // The connection handles incoming method calls automatically
++        // We just need to keep the main task alive
++        tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
++    }
++}

garfield-portal/src/request.rsadded

++//! Request tracking for portal dialogs.
++//!
++//! Each portal request gets a unique handle path and can be cancelled.
++
++use std::collections::HashMap;
++use std::sync::Arc;
++use tokio::process::Child;
++use tokio::sync::Mutex;
++use zbus::zvariant::{ObjectPath, OwnedObjectPath, Value};
++use zbus::{interface, fdo};
++
++/// A pending file chooser request.
++pub struct PendingRequest {
++    /// The child process running garfield.
++    pub child: Child,
++    /// Whether the request has been cancelled.
++    pub cancelled: bool,
++}
++
++/// Manages pending requests.
++#[derive(Clone, Default)]
++pub struct RequestManager {
++    requests: Arc<Mutex<HashMap<OwnedObjectPath, PendingRequest>>>,
++}
++
++impl RequestManager {
++    pub fn new() -> Self {
++        Self::default()
++    }
++
++    /// Add a new pending request.
++    pub async fn add(&self, handle: OwnedObjectPath, child: Child) {
++        let mut requests = self.requests.lock().await;
++        requests.insert(handle, PendingRequest {
++            child,
++            cancelled: false,
++        });
++    }
++
++    /// Remove a request and return it.
++    pub async fn remove(&self, handle: &ObjectPath<'_>) -> Option<PendingRequest> {
++        let mut requests = self.requests.lock().await;
++        requests.remove(&handle.to_owned())
++    }
++
++    /// Cancel a request by killing the child process.
++    pub async fn cancel(&self, handle: &ObjectPath<'_>) -> bool {
++        let mut requests = self.requests.lock().await;
++        if let Some(request) = requests.get_mut(&handle.to_owned()) {
++            request.cancelled = true;
++            let _ = request.child.kill().await;
++            true
++        } else {
++            false
++        }
++    }
++
++    /// Check if a request was cancelled.
++    #[allow(dead_code)]
++    pub async fn is_cancelled(&self, handle: &ObjectPath<'_>) -> bool {
++        let requests = self.requests.lock().await;
++        requests.get(&handle.to_owned())
++            .map(|r| r.cancelled)
++            .unwrap_or(false)
++    }
++}
++
++/// Request object that can be exported on D-Bus for cancellation.
++pub struct Request {
++    handle: OwnedObjectPath,
++    manager: RequestManager,
++}
++
++impl Request {
++    pub fn new(handle: OwnedObjectPath, manager: RequestManager) -> Self {
++        Self { handle, manager }
++    }
++}
++
++#[interface(name = "org.freedesktop.impl.portal.Request")]
++impl Request {
++    /// Close/cancel the request.
++    async fn close(&self) -> fdo::Result<()> {
++        // Log with backtrace info
++        tracing::warn!("Close() called on request: {}", self.handle);
++        let cancelled = self.manager.cancel(&self.handle.as_ref()).await;
++        tracing::warn!("Cancel result: {} (true = child was killed)", cancelled);
++        Ok(())
++    }
++}
++
++/// Response codes for portal dialogs.
++#[repr(u32)]
++pub enum ResponseCode {
++    /// User accepted the dialog.
++    Success = 0,
++    /// User cancelled the dialog.
++    Cancelled = 1,
++    /// An error occurred.
++    Error = 2,
++}
++
++/// Build response results for file chooser.
++pub fn build_file_chooser_response(
++    paths: Vec<String>,
++) -> HashMap<String, Value<'static>> {
++    let mut results = HashMap::new();
++
++    // Convert paths to file:// URIs
++    let uris: Vec<Value> = paths
++        .into_iter()
++        .map(|p| Value::from(format!("file://{}", p)))
++        .collect();
++
++    results.insert("uris".to_string(), Value::Array(uris.into()));
++    results
++}

garfield-portal/test-portal.shadded

++#!/bin/bash
++# Test script for garfield-portal
++#
++# This script verifies that the portal is working correctly.
++
++set -e
++
++RED='\033[0;31m'
++GREEN='\033[0;32m'
++YELLOW='\033[1;33m'
++NC='\033[0m'
++
++print_status() { echo -e "${GREEN}[PASS]${NC} $1"; }
++print_warning() { echo -e "${YELLOW}[WARN]${NC} $1"; }
++print_error() { echo -e "${RED}[FAIL]${NC} $1"; }
++
++echo "Testing garfield-portal..."
++echo ""
++
++# Test 1: Check if D-Bus name is registered
++echo "1. Checking D-Bus registration..."
++if busctl --user status org.freedesktop.impl.portal.desktop.garfield &>/dev/null; then
++    print_status "D-Bus name registered"
++else
++    print_error "D-Bus name not registered"
++    echo "   Try: systemctl --user start garfield-portal"
++    exit 1
++fi
++
++# Test 2: Check if FileChooser interface is available
++echo ""
++echo "2. Checking FileChooser interface..."
++if busctl --user introspect org.freedesktop.impl.portal.desktop.garfield /org/freedesktop/portal/desktop 2>/dev/null | grep -q "OpenFile"; then
++    print_status "FileChooser.OpenFile method available"
++else
++    print_error "FileChooser interface not found"
++    exit 1
++fi
++
++# Test 3: Check portal config
++echo ""
++echo "3. Checking portal configuration..."
++if [[ -f /usr/share/xdg-desktop-portal/portals/garfield.portal ]] || \
++   [[ -f ~/.local/share/xdg-desktop-portal/portals/garfield.portal ]]; then
++    print_status "Portal config file exists"
++else
++    print_error "Portal config not found"
++    exit 1
++fi
++
++# Test 4: Check if garfield binary is available
++echo ""
++echo "4. Checking garfield binary..."
++if command -v garfield &>/dev/null; then
++    print_status "garfield binary found: $(command -v garfield)"
++else
++    print_warning "garfield not in PATH (needed for picker mode)"
++fi
++
++echo ""
++echo "All tests passed!"
++echo ""
++echo "To test with a real application:"
++echo ""
++echo "  # With GTK apps:"
++echo "  GTK_USE_PORTAL=1 gedit"
++echo "  GTK_USE_PORTAL=1 firefox"
++echo ""
++echo "  # With Qt apps (KDE):"
++echo "  QT_QPA_PLATFORMTHEME=xdgdesktopportal dolphin"
++echo ""
++echo "  # With Flatpak apps:"
++echo "  flatpak run org.gnome.TextEditor"
++echo ""
++echo "To use garfield as the default file picker in gar desktop,"
++echo "set XDG_CURRENT_DESKTOP=gar in your session."

garfield/Cargo.tomlmodified


 # Fuzzy matching
 nucleo-matcher.workspace = true
 
+# CLI
+clap.workspace = true
+
 # IPC
 garfield-ipc.workspace = true
 

garfield/src/app.rsmodified

  //! Application state and event loop.
++use crate::PickerConfig;
  use garfield::core::{
      Clipboard, ClipboardOperation, DragTarget, FileOperation, FileDragController, ImagePreviewLoader, PdfPreviewLoader, PreviewLoader, UndoStack,
      copy_files, move_files, delete_files, create_directory,
--    trash_files, restore_from_trash,
++    trash_files, restore_from_trash, matches_any_filter,
  };
  use garfield::ui::pane::SplitDirection;
--use garfield::ui::{AddressBar, AppPickerDialog, AppPickerResult, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, ContextMenu, ContextMenuAction, ContextType, DialogResult, HelpModal, IconSize, InputDialog, InputResult, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
++use garfield::ui::{AddressBar, AppPickerDialog, AppPickerResult, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, ContextMenu, ContextMenuAction, ContextType, DialogResult, HelpModal, IconSize, InputDialog, InputResult, Pane, PaneToolbarClick, PickerToolbar, PickerToolbarClick, ProgressDialog, Sidebar, StatusBar, TabBar, TabBarClickResult, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT, PICKER_TOOLBAR_HEIGHT};
  use anyhow::Result;
  use gartk_core::{InputEvent, Key, MouseButton, Point, Rect, Theme};
  use gartk_render::{Renderer, TextStyle};
      pdf_preview_loader: PdfPreviewLoader,
      /// X11 clipboard manager for system clipboard integration.
      x11_clipboard: ClipboardManager,
++    /// Picker mode configuration (None for normal browser).
++    picker_config: PickerConfig,
++    /// Picker toolbar (only used in picker mode).
++    picker_toolbar: Option<PickerToolbar>,
+ }
  /// State for a paste operation with conflicts.
  impl App {
      /// Create a new application.
--    pub fn new(start_dir: Option<PathBuf>) -> Result<Self> {
++    pub fn new(start_dir: Option<PathBuf>, picker_config: PickerConfig) -> Result<Self> {
          // Connect to X11
          let conn = Connection::connect(None)?;
          // Get primary monitor for window sizing
          let monitor = gartk_x11::primary_monitor(&conn)?;
--        // Calculate window size (70% of screen)
++        // Calculate window size (70% of screen, smaller for picker mode)
--        let width = (monitor.rect.width as f64 * 0.7) as u32;
++        let scale = if picker_config.is_picker() { 0.5 } else { 0.7 };
--        let height = (monitor.rect.height as f64 * 0.7) as u32;
++        let width = (monitor.rect.width as f64 * scale) as u32;
++        let height = (monitor.rect.height as f64 * scale) as u32;
          let x = monitor.rect.x + (monitor.rect.width as i32 - width as i32) / 2;
          let y = monitor.rect.y + (monitor.rect.height as i32 - height as i32) / 2;
--        // Create window
++        // Window title depends on mode
--        let window = Window::create(
++        let title = if picker_config.is_picker() {
--            conn.clone(),
++            picker_config.title.clone().unwrap_or_else(|| {
--            WindowConfig::default()
++                if picker_config.mode.is_directory_mode() {
--                .title("garfield")
++                    "Select Folder".to_string()
--                .class("garfield")
++                } else {
--                .position(x, y)
++                    "Open File".to_string()
--                .size(width, height)
++                }
--                .transparent(false),
++            })
--        )?;
++        } else {
++            "garfield".to_string()
++        };
--        window.focus()?;
++        // Create window - use Dialog type for picker mode
++        let mut window_config = WindowConfig::default()
++            .title(&title)
++            .class("garfield")
++            .position(x, y)
++            .size(width, height)
++            .transparent(false);
++
++        // Use Dialog window type for picker mode (better focus handling)
++        if picker_config.is_picker() {
++            window_config = window_config.window_type(gartk_x11::WindowType::Dialog);
++        }
++
++        let window = Window::create(conn.clone(), window_config)?;
++        conn.flush()?;
          // Create X11 clipboard manager for system clipboard integration
          let x11_clipboard = ClipboardManager::new(conn.clone(), window.id())?;
          );
          let toolbar = Toolbar::new(toolbar_bounds);
++        // Create picker toolbar at BOTTOM of window (only if in picker mode)
++        let picker_toolbar = if picker_config.is_picker() {
++            let picker_toolbar_bounds = Rect::new(
++                sidebar_w as i32,
++                (height - PICKER_TOOLBAR_HEIGHT) as i32,
++                width - sidebar_w,
++                PICKER_TOOLBAR_HEIGHT,
++            );
++            let mut pt = PickerToolbar::new(picker_toolbar_bounds, picker_config.accept_label.clone());
++            // Set filter description if we have filters
++            let filters = picker_config.mode.filters();
++            if !filters.is_empty() {
++                let desc = format!("Filter: {}", filters.join(", "));
++                pt.set_filter_description(Some(desc));
++            }
++            Some(pt)
++        } else {
++            None
++        };
++
          // Create breadcrumb (below toolbar)
          let breadcrumb_bounds = Rect::new(
              sidebar_w as i32,
          let app_picker = AppPickerDialog::new(Rect::new(0, 0, width, height));
          // Content area bounds (for panes)
++        // In picker mode, picker toolbar replaces status bar at bottom
++        let footer_height = if picker_config.is_picker() {
++            PICKER_TOOLBAR_HEIGHT
++        } else {
++            STATUS_BAR_HEIGHT
++        };
          let content_bounds = Rect::new(
              sidebar_w as i32,
              header_height as i32,
              width - sidebar_w,
--            height - header_height - STATUS_BAR_HEIGHT,
++            height - header_height - footer_height,
          );
          // Create root pane with initial tab
              image_preview_loader: ImagePreviewLoader::new(),
              pdf_preview_loader: PdfPreviewLoader::new(),
              x11_clipboard,
++            picker_config,
++            picker_toolbar,
          };
          app.update_status_bar();
          self.root_pane.leaf_by_id_mut(self.focused_pane_id)
+     }
++    /// Check if the current selection is valid for picker mode.
++    fn has_valid_picker_selection(&self) -> bool {
++        let Some(pane) = self.focused_pane() else {
++            return false;
++        };
++        let Some(tab) = pane.active_tab() else {
++            return false;
++        };
++
++        let selected = tab.selected_entries();
++        let filters = self.picker_config.mode.filters();
++
++        // In directory mode, we can always accept (use current directory if nothing selected)
++        if self.picker_config.mode.is_directory_mode() {
++            // If nothing selected, the current directory is the selection
++            if selected.is_empty() {
++                return true;
++            }
++            // Otherwise, at least one directory must be selected
++            return selected.iter().any(|e| e.is_dir());
++        }
++
++        // In file mode, we need at least one file selected that matches filters
++        // If multiple is disabled, we need exactly one matching file
++        let matching_file_count = selected.iter()
++            .filter(|e| !e.is_dir() && matches_any_filter(e, filters))
++            .count();
++
++        if matching_file_count == 0 {
++            return false;
++        }
++
++        if !self.picker_config.mode.allows_multiple() && matching_file_count > 1 {
++            return false;
++        }
++
++        true
++    }
++
++    /// Get the selected paths for picker mode.
++    fn get_picker_selection(&self) -> Vec<PathBuf> {
++        let Some(pane) = self.focused_pane() else {
++            return Vec::new();
++        };
++        let Some(tab) = pane.active_tab() else {
++            return Vec::new();
++        };
++
++        let filters = self.picker_config.mode.filters();
++
++        if self.picker_config.mode.is_directory_mode() {
++            // In directory mode, return selected directories or current directory
++            let dirs: Vec<_> = tab.selected_entries().iter()
++                .filter(|e| e.is_dir())
++                .map(|e| e.path.clone())
++                .collect();
++
++            if dirs.is_empty() {
++                // Return current directory
++                vec![tab.current_path().to_path_buf()]
++            } else {
++                dirs
++            }
++        } else {
++            // In file mode, return selected files that match filters
++            tab.selected_entries().iter()
++                .filter(|e| !e.is_dir() && matches_any_filter(e, filters))
++                .map(|e| e.path.clone())
++                .collect()
++        }
++    }
++
++    /// Output picker selection and exit.
++    fn accept_picker_selection(&mut self) {
++        let paths = self.get_picker_selection();
++
++        // Output paths to stdout (one per line)
++        for path in &paths {
++            println!("{}", path.display());
++        }
++
++        self.should_quit = true;
++    }
++
++    /// Cancel picker and exit with no output.
++    fn cancel_picker(&mut self) {
++        // Exit with code 1 to indicate cancellation
++        self.should_quit = true;
++    }
++
      /// Run the application event loop.
      pub fn run(&mut self) -> Result<()> {
          let mut event_loop = EventLoop::new(&self.window, EventLoopConfig::default())?;
                  return;
+             }
--            // Handle tab bar close button clicks (non-drag)
++            // Handle tab bar clicks (non-drag)
--            if let Some((tab_index, is_close)) = self.tab_bar.on_click(pos) {
++            match self.tab_bar.on_click(pos) {
--                if is_close {
++                TabBarClickResult::Tab(tab_index, is_close) => {
--                    self.close_tab(tab_index);
++                    if is_close {
++                        self.close_tab(tab_index);
++                    }
++                    // Tab selection happens on mouse release if not dragged
++                    return;
++                }
++                TabBarClickResult::NewTab => {
++                    self.new_tab();
++                    return;
++                }
++                TabBarClickResult::None => {}
++            }
++        }
++
++        // Check picker toolbar clicks (if in picker mode)
++        if let Some(picker_toolbar) = &self.picker_toolbar {
++            match picker_toolbar.on_click(pos) {
++                PickerToolbarClick::Accept => {
++                    self.accept_picker_selection();
++                    return;
++                }
++                PickerToolbarClick::Cancel => {
++                    self.cancel_picker();
++                    return;
+                 }
--                // Tab selection happens on mouse release if not dragged
++                PickerToolbarClick::None => {}
++            }
++        } else {
++            // Check normal toolbar clicks
++            if let Some(action) = self.toolbar.on_click(pos) {
++                self.handle_toolbar_action(action);
                  return;
+             }
+         }
--        // Check toolbar clicks
++        // Check pane toolbar clicks (view mode buttons)
--        if let Some(action) = self.toolbar.on_click(pos) {
++        if let PaneToolbarClick::ViewMode(_mode) = self.root_pane.on_toolbar_click(pos) {
--            self.handle_toolbar_action(action);
++            self.sync_toolbar_view();
++            self.update_status_bar();
              return;
+         }
+         }
          // Check hover states - only redraw if any changed
--        needs_redraw |= self.toolbar.on_mouse_move(pos);
++        if let Some(picker_toolbar) = &mut self.picker_toolbar {
++            needs_redraw |= picker_toolbar.on_mouse_move(pos);
++        } else {
++            needs_redraw |= self.toolbar.on_mouse_move(pos);
++        }
          needs_redraw |= self.breadcrumb.on_mouse_move(pos);
          needs_redraw |= self.sidebar.on_mouse_move(pos);
          needs_redraw |= self.tab_bar.on_mouse_move(pos);
++        needs_redraw |= self.root_pane.on_toolbar_mouse_move(pos);
          let mut is_dragging = false;
          let mut selection_count = 0;
              return;
+         }
++        // Handle Escape in picker mode (cancel)
++        if *key == Key::Escape && self.picker_config.is_picker() {
++            self.cancel_picker();
++            return;
++        }
++
          // F1 toggles help
          if *key == Key::F1 {
              self.help_modal.show();
      /// Create a new tab in the focused pane.
      fn new_tab(&mut self) {
--        let path = if let Some(pane) = self.focused_pane() {
++        let path = dirs::home_dir().unwrap_or_else(|| PathBuf::from("/"));
--            pane.active_tab().map(|t| t.current_path().clone())
--        } else {
--            None
--        };
--
--        let path = path.unwrap_or_else(|| dirs::home_dir().unwrap_or_else(|| PathBuf::from("/")));
          if let Some(pane) = self.focused_pane_mut() {
              pane.add_tab(path);
      /// Split the focused pane horizontally.
      fn split_horizontal(&mut self) {
--        let path = if let Some(pane) = self.focused_pane() {
++        let (path, view_mode) = if let Some(pane) = self.focused_pane() {
--            pane.active_tab().map(|t| t.current_path().clone())
++            if let Some(tab) = pane.active_tab() {
++                (Some(tab.current_path().clone()), Some(tab.view_mode()))
++            } else {
++                (None, None)
++            }
          } else {
--            None
++            (None, None)
          };
          let path = path.unwrap_or_else(|| dirs::home_dir().unwrap_or_else(|| PathBuf::from("/")));
          let new_id = self.next_pane_id;
          if let Some(pane) = self.focused_pane_mut() {
--            if pane.split(SplitDirection::Horizontal, path, new_id).is_some() {
++            if pane.split(SplitDirection::Horizontal, path, new_id, view_mode).is_some() {
                  self.next_pane_id += 1;
                  self.focused_pane_id = new_id;
+             }
      /// Split the focused pane vertically.
      fn split_vertical(&mut self) {
--        let path = if let Some(pane) = self.focused_pane() {
++        let (path, view_mode) = if let Some(pane) = self.focused_pane() {
--            pane.active_tab().map(|t| t.current_path().clone())
++            if let Some(tab) = pane.active_tab() {
++                (Some(tab.current_path().clone()), Some(tab.view_mode()))
++            } else {
++                (None, None)
++            }
          } else {
--            None
++            (None, None)
          };
          let path = path.unwrap_or_else(|| dirs::home_dir().unwrap_or_else(|| PathBuf::from("/")));
          let new_id = self.next_pane_id;
          if let Some(pane) = self.focused_pane_mut() {
--            if pane.split(SplitDirection::Vertical, path, new_id).is_some() {
++            if pane.split(SplitDirection::Vertical, path, new_id, view_mode).is_some() {
                  self.next_pane_id += 1;
                  self.focused_pane_id = new_id;
+             }
      /// Enter the selected entry.
      fn enter_selected(&mut self) {
          self.status_bar.clear_status_message();
++
++        // In picker mode, check if we should accept the selection instead of navigating
++        if self.picker_config.is_picker() {
++            if let Some(pane) = self.focused_pane() {
++                if let Some(tab) = pane.active_tab() {
++                    let selected = tab.selected_entries();
++                    if !selected.is_empty() {
++                        // If it's a directory in non-directory mode, navigate into it
++                        if !self.picker_config.mode.is_directory_mode() {
++                            let first = &selected[0];
++                            if first.is_dir() {
++                                // Fall through to normal enter behavior
++                            } else {
++                                // File selected - accept it
++                                self.accept_picker_selection();
++                                return;
++                            }
++                        }
++                    }
++                }
++            }
++        }
++
          if let Some(pane) = self.focused_pane_mut() {
              if let Some(tab) = pane.active_tab_mut() {
                  tab.enter_selected();
              TAB_BAR_HEIGHT,
          ));
--        self.toolbar.set_bounds(Rect::new(
++        let toolbar_bounds = Rect::new(
              sidebar_w as i32,
              TAB_BAR_HEIGHT as i32,
              width - sidebar_w,
              TOOLBAR_HEIGHT,
--        ));
++        );
++        self.toolbar.set_bounds(toolbar_bounds);
          let breadcrumb_bounds = Rect::new(
              sidebar_w as i32,
          self.breadcrumb.set_bounds(breadcrumb_bounds);
          self.address_bar.set_bounds(breadcrumb_bounds);
++        // Calculate footer height (status bar + picker toolbar if present)
++        let footer_height = if self.picker_toolbar.is_some() {
++            PICKER_TOOLBAR_HEIGHT  // Picker toolbar replaces status bar
++        } else {
++            STATUS_BAR_HEIGHT
++        };
++
          let content_bounds = Rect::new(
              sidebar_w as i32,
              header_height as i32,
              width - sidebar_w,
--            height - header_height - STATUS_BAR_HEIGHT,
++            height - header_height - footer_height,
          );
          self.root_pane.set_bounds(content_bounds);
--        self.status_bar.set_bounds(Rect::new(
++        // Update picker toolbar bounds at bottom (if in picker mode)
--            sidebar_w as i32,
++        if let Some(ref mut picker_toolbar) = self.picker_toolbar {
--            (height - STATUS_BAR_HEIGHT) as i32,
++            picker_toolbar.set_bounds(Rect::new(
--            width - sidebar_w,
++                sidebar_w as i32,
--            STATUS_BAR_HEIGHT,
++                (height - PICKER_TOOLBAR_HEIGHT) as i32,
--        ));
++                width - sidebar_w,
++                PICKER_TOOLBAR_HEIGHT,
++            ));
++        } else {
++            // Only show status bar when not in picker mode
++            self.status_bar.set_bounds(Rect::new(
++                sidebar_w as i32,
++                (height - STATUS_BAR_HEIGHT) as i32,
++                width - sidebar_w,
++                STATUS_BAR_HEIGHT,
++            ));
++        }
          self.help_modal.set_bounds(Rect::new(0, 0, width, height));
          self.confirm_dialog.set_bounds(Rect::new(0, 0, width, height));
          // Draw tab bar
          self.tab_bar.render(&self.renderer)?;
--        // Update and draw toolbar
++        // Update and draw toolbar (or picker toolbar)
          let (can_back, can_forward) = if let Some(pane) = self.focused_pane() {
              if let Some(tab) = pane.active_tab() {
                  (tab.can_go_back(), tab.can_go_forward())
          } else {
              (false, false)
          };
++
++        // Always render the regular toolbar
          self.toolbar.set_nav_state(can_back, can_forward);
          self.toolbar.render(&self.renderer)?;
          // Draw pane content
          self.root_pane.render(&self.renderer, Some(self.focused_pane_id))?;
--        // Draw status bar
++        // Draw status bar or picker toolbar at bottom
--        self.status_bar.render(&self.renderer)?;
++        if self.picker_toolbar.is_some() {
++            // Picker mode: draw picker toolbar instead of status bar
++            let has_valid_selection = self.has_valid_picker_selection();
++            let picker_toolbar = self.picker_toolbar.as_mut().unwrap();
++            picker_toolbar.set_accept_enabled(has_valid_selection);
++            picker_toolbar.render(&self.renderer)?;
++        } else {
++            // Normal mode: draw status bar
++            self.status_bar.render(&self.renderer)?;
++        }
          // Draw toolbar tooltip overlay (on top of other UI)
          self.toolbar.render_tooltip_overlay(&self.renderer)?;

garfield/src/core/entry.rsmodified

      });
+ }
++/// Check if a filename matches a glob pattern.
++///
++/// Supports simple patterns:
++/// - `*.ext` - matches any file ending with `.ext`
++/// - `name.*` - matches any file starting with `name.`
++/// - `exact` - matches exact filename
++pub fn matches_filter(filename: &str, pattern: &str) -> bool {
++    let filename_lower = filename.to_lowercase();
++    let pattern_lower = pattern.to_lowercase();
++
++    if pattern_lower == "*" {
++        return true;
++    }
++
++    if let Some(suffix) = pattern_lower.strip_prefix("*.") {
++        // *.ext pattern
++        filename_lower.ends_with(&format!(".{}", suffix))
++    } else if let Some(prefix) = pattern_lower.strip_suffix(".*") {
++        // name.* pattern
++        filename_lower.starts_with(&format!("{}.", prefix))
++    } else if pattern_lower.contains('*') {
++        // More complex patterns - split by * and check if parts exist in order
++        let parts: Vec<&str> = pattern_lower.split('*').collect();
++        let mut pos = 0;
++        for (i, part) in parts.iter().enumerate() {
++            if part.is_empty() {
++                continue;
++            }
++            if i == 0 && !filename_lower.starts_with(part) {
++                return false;
++            }
++            if i == parts.len() - 1 && !filename_lower.ends_with(part) {
++                return false;
++            }
++            if let Some(found_pos) = filename_lower[pos..].find(part) {
++                pos += found_pos + part.len();
++            } else {
++                return false;
++            }
++        }
++        true
++    } else {
++        // Exact match
++        filename_lower == pattern_lower
++    }
++}
++
++/// Check if a file entry matches any of the given filter patterns.
++/// Directories always match (for navigation).
++/// Empty filters match everything.
++pub fn matches_any_filter(entry: &FileEntry, filters: &[String]) -> bool {
++    // Directories always visible for navigation
++    if entry.is_dir() {
++        return true;
++    }
++
++    // No filters means show everything
++    if filters.is_empty() {
++        return true;
++    }
++
++    // Check each filter
++    filters.iter().any(|pattern| matches_filter(&entry.name, pattern))
++}
++
  /// Format bytes as human-readable string.
  fn format_bytes(bytes: u64) -> String {
      const KB: u64 = 1024;

garfield/src/core/mod.rsmodified


 
 pub use clipboard::{Clipboard, ClipboardOperation};
 pub use entry::{
+    matches_any_filter, matches_filter, read_directory, sort_entries, EntryType, FileEntry, SortDirection, SortOrder,
 };
 pub use file_drag::{DragTarget, FileDragController, FileDragState, FlashState};
 pub use history::History;

garfield/src/main.rsmodified

  mod app;
  use anyhow::Result;
++use clap::Parser;
  use std::path::PathBuf;
  use tracing_subscriber::{fmt, EnvFilter};
++/// garfield - gar file explorer
++#[derive(Parser, Debug)]
++#[command(name = "garfield", about = "gar file explorer", version)]
++pub struct Args {
++    /// Starting directory
++    #[arg(value_name = "PATH")]
++    pub start_dir: Option<PathBuf>,
++
++    /// Enable file picker mode
++    #[arg(long, short = 'p')]
++    pub picker: bool,
++
++    /// Select directories only (not files), requires --picker
++    #[arg(long, short = 'd', requires = "picker")]
++    pub directory: bool,
++
++    /// Allow multiple selection, requires --picker
++    #[arg(long, short = 'm', requires = "picker")]
++    pub multiple: bool,
++
++    /// File filter patterns (semicolon-separated, e.g., "*.rs;*.toml")
++    #[arg(long, short = 'f', requires = "picker")]
++    pub filter: Option<String>,
++
++    /// Dialog title, requires --picker
++    #[arg(long, short = 't', requires = "picker")]
++    pub title: Option<String>,
++
++    /// Custom accept button text (default: "Open")
++    #[arg(long, requires = "picker")]
++    pub accept_label: Option<String>,
++}
++
++/// Picker mode configuration parsed from CLI args.
++#[derive(Debug, Clone)]
++pub enum PickerMode {
++    /// Normal file browser mode.
++    None,
++    /// Open file picker.
++    OpenFile {
++        multiple: bool,
++        filters: Vec<String>,
++    },
++    /// Open directory picker.
++    OpenDirectory {
++        multiple: bool,
++    },
++}
++
++impl PickerMode {
++    /// Whether this is a picker mode (not normal browser).
++    pub fn is_picker(&self) -> bool {
++        !matches!(self, PickerMode::None)
++    }
++
++    /// Whether multiple selection is allowed.
++    pub fn allows_multiple(&self) -> bool {
++        match self {
++            PickerMode::None => true,
++            PickerMode::OpenFile { multiple, .. } => *multiple,
++            PickerMode::OpenDirectory { multiple } => *multiple,
++        }
++    }
++
++    /// Get file filters if any.
++    pub fn filters(&self) -> &[String] {
++        match self {
++            PickerMode::OpenFile { filters, .. } => filters,
++            _ => &[],
++        }
++    }
++
++    /// Whether we're picking directories only.
++    pub fn is_directory_mode(&self) -> bool {
++        matches!(self, PickerMode::OpenDirectory { .. })
++    }
++}
++
++/// Picker configuration derived from Args.
++#[derive(Debug, Clone)]
++pub struct PickerConfig {
++    /// The picker mode.
++    pub mode: PickerMode,
++    /// Dialog title.
++    pub title: Option<String>,
++    /// Accept button label.
++    pub accept_label: String,
++}
++
++impl PickerConfig {
++    /// Create from command line arguments.
++    pub fn from_args(args: &Args) -> Self {
++        let mode = if args.picker {
++            if args.directory {
++                PickerMode::OpenDirectory {
++                    multiple: args.multiple,
++                }
++            } else {
++                let filters = args.filter
++                    .as_ref()
++                    .map(|f| f.split(';').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect())
++                    .unwrap_or_default();
++                PickerMode::OpenFile {
++                    multiple: args.multiple,
++                    filters,
++                }
++            }
++        } else {
++            PickerMode::None
++        };
++
++        Self {
++            mode,
++            title: args.title.clone(),
++            accept_label: args.accept_label.clone().unwrap_or_else(|| "Open".to_string()),
++        }
++    }
++
++    /// Whether this is picker mode.
++    pub fn is_picker(&self) -> bool {
++        self.mode.is_picker()
++    }
++}
++
  fn main() -> Result<()> {
--    // Initialize logging
++    // Parse command line arguments first (before logging setup)
++    let args = Args::parse();
++    let picker_config = PickerConfig::from_args(&args);
++
++    // Initialize logging - use stderr in picker mode to keep stdout clean for results
      let filter = EnvFilter::try_from_default_env()
          .unwrap_or_else(|_| EnvFilter::new("info"));
--    fmt()
++    if picker_config.is_picker() {
--        .with_env_filter(filter)
++        // Picker mode: log to stderr so stdout is clean for path output
--        .with_target(false)
++        fmt()
--        .init();
++            .with_env_filter(filter)
--
++            .with_target(false)
--    tracing::info!("Starting garfield");
++            .with_writer(std::io::stderr)
--
++            .init();
--    // Parse command line arguments (simple for now)
++        tracing::info!("Starting garfield in picker mode");
--    let start_dir = std::env::args()
++    } else {
--        .nth(1)
++        // Normal mode: log to stdout
--        .map(PathBuf::from);
++        fmt()
++            .with_env_filter(filter)
++            .with_target(false)
++            .init();
++        tracing::info!("Starting garfield");
++    }
      // Create and run app
--    let mut app = app::App::new(start_dir)?;
++    let mut app = app::App::new(args.start_dir, picker_config)?;
      app.run()?;
      tracing::info!("garfield exiting");

garfield/src/ui/mod.rsmodified

  pub mod help_modal;
  pub mod list_view;
  pub mod pane;
++pub mod picker_toolbar;
  pub mod sidebar;
  pub mod status_bar;
  pub mod tab;
  pub use grid_view::{GridView, IconSize};
  pub use help_modal::HelpModal;
  pub use list_view::ListView;
--pub use pane::Pane;
++pub use pane::{Pane, PaneToolbarClick};
++pub use picker_toolbar::{PickerToolbar, PickerToolbarClick, PICKER_TOOLBAR_HEIGHT};
  pub use sidebar::Sidebar;
  pub use status_bar::StatusBar;
  pub use tab::{RenameState, Tab, ViewMode};
--pub use tab_bar::{TabBar, TabInfo, TAB_BAR_HEIGHT};
++pub use tab_bar::{TabBar, TabBarClickResult, TabInfo, TAB_BAR_HEIGHT};
  pub use toolbar::{Toolbar, ToolbarAction, TOOLBAR_HEIGHT};

garfield/src/ui/pane.rsmodified

  //! Pane management with split support.
--use crate::ui::tab::Tab;
++use crate::ui::tab::{Tab, ViewMode};
  use gartk_core::{Point, Rect};
--use gartk_render::Renderer;
++use gartk_render::{Renderer, TextStyle};
  use std::path::PathBuf;
  /// Split direction for panes.
      Vertical,
+ }
++/// Result of clicking on the pane toolbar.
++#[derive(Debug, Clone, Copy, PartialEq, Eq)]
++pub enum PaneToolbarClick {
++    /// Set view mode.
++    ViewMode(ViewMode),
++    /// No action.
++    None,
++}
++
  /// Minimum pane size (width or height).
  pub const MIN_PANE_SIZE: u32 = 100;
  /// Divider size for split panes.
  const DIVIDER_SIZE: u32 = 4;
++/// Height of the pane toolbar.
++const PANE_TOOLBAR_HEIGHT: u32 = 24;
++
++/// Width of each view mode button.
++const VIEW_BUTTON_WIDTH: u32 = 24;
++
  /// A pane that can be a leaf (with tabs) or a split (with two child panes).
  pub enum Pane {
      /// Leaf pane containing tabs.
          tabs: Vec<Tab>,
          /// Active tab index.
          active_tab: usize,
--        /// Pane bounds.
++        /// Pane bounds (full bounds including toolbar).
          bounds: Rect,
          /// Unique pane ID.
          id: u32,
++        /// Hovered view mode button (0=List, 1=Grid, 2=Columns).
++        hovered_view_button: Option<usize>,
      },
      /// Split pane containing two child panes.
      Split {
  impl Pane {
      /// Create a new leaf pane with a single tab.
      pub fn new_leaf(path: PathBuf, bounds: Rect, id: u32) -> Self {
--        let tab = Tab::new(path, bounds);
++        // Content bounds exclude the toolbar
++        let content_bounds = Self::content_bounds_from_pane_bounds(bounds);
++        let tab = Tab::new(path, content_bounds);
          Pane::Leaf {
              tabs: vec![tab],
              active_tab: 0,
              bounds,
              id,
++            hovered_view_button: None,
+         }
+     }
++    /// Calculate content bounds (for tabs) from pane bounds, accounting for toolbar.
++    fn content_bounds_from_pane_bounds(bounds: Rect) -> Rect {
++        Rect::new(
++            bounds.x,
++            bounds.y + PANE_TOOLBAR_HEIGHT as i32,
++            bounds.width,
++            bounds.height.saturating_sub(PANE_TOOLBAR_HEIGHT),
++        )
++    }
++
++    /// Get the toolbar bounds for a leaf pane.
++    fn toolbar_bounds(bounds: Rect) -> Rect {
++        Rect::new(bounds.x, bounds.y, bounds.width, PANE_TOOLBAR_HEIGHT)
++    }
++
++    /// Get bounds for a view mode button (0=List, 1=Grid, 2=Columns).
++    fn view_button_bounds(bounds: Rect, index: usize) -> Rect {
++        let toolbar = Self::toolbar_bounds(bounds);
++        // Position buttons on the right side of the toolbar
++        let x = toolbar.x + toolbar.width as i32 - ((3 - index as i32) * VIEW_BUTTON_WIDTH as i32) - 4;
++        Rect::new(x, toolbar.y + 2, VIEW_BUTTON_WIDTH, PANE_TOOLBAR_HEIGHT - 4)
++    }
++
      /// Get pane bounds.
      pub fn bounds(&self) -> Rect {
          match self {
          match self {
              Pane::Leaf { bounds, tabs, .. } => {
                  *bounds = new_bounds;
++                let content_bounds = Self::content_bounds_from_pane_bounds(new_bounds);
                  for tab in tabs {
--                    tab.set_bounds(new_bounds);
++                    tab.set_bounds(content_bounds);
+                 }
+             }
              Pane::Split {
      /// Split this pane. Only works on leaf panes.
      /// Returns the new pane ID if successful.
--    pub fn split(&mut self, direction: SplitDirection, new_path: PathBuf, new_id: u32) -> Option<u32> {
++    /// The new pane will inherit the specified view mode.
++    pub fn split(&mut self, direction: SplitDirection, new_path: PathBuf, new_id: u32, view_mode: Option<ViewMode>) -> Option<u32> {
          let current_bounds = self.bounds();
          match self {
--            Pane::Leaf { tabs, active_tab, bounds, id } => {
++            Pane::Leaf { tabs, active_tab, bounds, id, .. } => {
                  // Create new leaf from current state
                  let first_pane = Pane::Leaf {
                      tabs: std::mem::take(tabs),
                      active_tab: *active_tab,
                      bounds: *bounds,
                      id: *id,
++                    hovered_view_button: None,
                  };
                  // Create second leaf with new tab
--                let second_pane = Pane::new_leaf(new_path, *bounds, new_id);
++                let mut second_pane = Pane::new_leaf(new_path, *bounds, new_id);
++
++                // Set the view mode on the new pane's tab if specified
++                if let (Some(mode), Pane::Leaf { tabs, .. }) = (view_mode, &mut second_pane) {
++                    if let Some(tab) = tabs.first_mut() {
++                        tab.set_view_mode(mode);
++                    }
++                }
                  // Replace self with split
                  *self = Pane::Split {
      /// Render the pane.
      pub fn render(&self, renderer: &Renderer, focused_id: Option<u32>) -> anyhow::Result<()> {
          match self {
--            Pane::Leaf { tabs, active_tab, bounds, id } => {
++            Pane::Leaf { tabs, active_tab, bounds, id, hovered_view_button } => {
++                // Render the pane toolbar
++                self.render_toolbar(renderer, *bounds, tabs.get(*active_tab), *hovered_view_button)?;
++
++                // Render the active tab
                  if let Some(tab) = tabs.get(*active_tab) {
                      tab.render(renderer)?;
+                 }
                  // Draw focus indicator if this pane is focused
                  if focused_id == Some(*id) {
                      let theme = renderer.theme();
--                    renderer.stroke_rect(*bounds, theme.selection_background, 2.0)?;
++                    let content_bounds = Self::content_bounds_from_pane_bounds(*bounds);
++                    renderer.stroke_rect(content_bounds, theme.selection_background, 2.0)?;
+                 }
+             }
              Pane::Split {
--                direction,
                  first,
                  second,
                  ..
          Ok(())
+     }
++    /// Render the pane toolbar with view mode buttons.
++    fn render_toolbar(&self, renderer: &Renderer, bounds: Rect, active_tab: Option<&Tab>, hovered_button: Option<usize>) -> anyhow::Result<()> {
++        let theme = renderer.theme();
++        let toolbar_bounds = Self::toolbar_bounds(bounds);
++
++        // Draw toolbar background
++        renderer.fill_rect(toolbar_bounds, theme.item_background.darken(0.02))?;
++
++        // Draw bottom border
++        renderer.line(
++            toolbar_bounds.x as f64,
++            (toolbar_bounds.y + toolbar_bounds.height as i32) as f64,
++            (toolbar_bounds.x + toolbar_bounds.width as i32) as f64,
++            (toolbar_bounds.y + toolbar_bounds.height as i32) as f64,
++            theme.border.with_alpha(0.3),
++            1.0,
++        )?;
++
++        // Get current view mode
++        let current_mode = active_tab.map(|t| t.view_mode()).unwrap_or(ViewMode::List);
++
++        // Draw view mode buttons
++        let buttons = [
++            (ViewMode::List, "≡"),    // List icon
++            (ViewMode::Grid, "⊞"),    // Grid icon
++            (ViewMode::Columns, "⫼"), // Columns icon
++        ];
++
++        for (i, (mode, icon)) in buttons.iter().enumerate() {
++            let btn_bounds = Self::view_button_bounds(bounds, i);
++            let is_active = *mode == current_mode;
++            let is_hovered = hovered_button == Some(i);
++
++            // Button background
++            if is_active {
++                renderer.fill_rounded_rect(btn_bounds, 3.0, theme.selection_background.with_alpha(0.4))?;
++            } else if is_hovered {
++                renderer.fill_rounded_rect(btn_bounds, 3.0, theme.item_background)?;
++            }
++
++            // Button icon
++            let color = if is_active {
++                theme.foreground
++            } else if is_hovered {
++                theme.foreground.with_alpha(0.8)
++            } else {
++                theme.foreground.with_alpha(0.5)
++            };
++
++            let text_style = TextStyle::new()
++                .font_family(&theme.font_family)
++                .font_size(theme.font_size)
++                .color(color);
++
++            renderer.text_in_rect(icon, btn_bounds, &text_style)?;
++        }
++
++        Ok(())
++    }
++
      // === Tab operations (for leaf panes) ===
      /// Get active tab (for leaf panes).
      /// Add a new tab to a leaf pane.
      pub fn add_tab(&mut self, path: PathBuf) {
          if let Pane::Leaf { tabs, active_tab, bounds, .. } = self {
--            let tab = Tab::new(path, *bounds);
++            let content_bounds = Self::content_bounds_from_pane_bounds(*bounds);
++            let tab = Tab::new(path, content_bounds);
              tabs.push(tab);
              *active_tab = tabs.len() - 1;
+         }
+     }
++    /// Handle mouse move on the pane toolbar. Returns true if hover state changed.
++    pub fn on_toolbar_mouse_move(&mut self, pos: Point) -> bool {
++        match self {
++            Pane::Leaf { bounds, hovered_view_button, .. } => {
++                let old_hovered = *hovered_view_button;
++                *hovered_view_button = None;
++
++                let toolbar_bounds = Self::toolbar_bounds(*bounds);
++                if !toolbar_bounds.contains_point(pos) {
++                    return old_hovered != *hovered_view_button;
++                }
++
++                // Check which button is hovered
++                for i in 0..3 {
++                    let btn_bounds = Self::view_button_bounds(*bounds, i);
++                    if btn_bounds.contains_point(pos) {
++                        *hovered_view_button = Some(i);
++                        break;
++                    }
++                }
++
++                old_hovered != *hovered_view_button
++            }
++            Pane::Split { first, second, .. } => {
++                first.on_toolbar_mouse_move(pos) || second.on_toolbar_mouse_move(pos)
++            }
++        }
++    }
++
++    /// Clear toolbar hover state.
++    pub fn clear_toolbar_hover(&mut self) {
++        match self {
++            Pane::Leaf { hovered_view_button, .. } => {
++                *hovered_view_button = None;
++            }
++            Pane::Split { first, second, .. } => {
++                first.clear_toolbar_hover();
++                second.clear_toolbar_hover();
++            }
++        }
++    }
++
++    /// Handle click on the pane toolbar. Returns the action if any.
++    pub fn on_toolbar_click(&mut self, pos: Point) -> PaneToolbarClick {
++        match self {
++            Pane::Leaf { bounds, tabs, active_tab, .. } => {
++                let toolbar_bounds = Self::toolbar_bounds(*bounds);
++                if !toolbar_bounds.contains_point(pos) {
++                    return PaneToolbarClick::None;
++                }
++
++                // Check which button was clicked
++                let modes = [ViewMode::List, ViewMode::Grid, ViewMode::Columns];
++                for (i, mode) in modes.iter().enumerate() {
++                    let btn_bounds = Self::view_button_bounds(*bounds, i);
++                    if btn_bounds.contains_point(pos) {
++                        // Set the view mode on the active tab
++                        if let Some(tab) = tabs.get_mut(*active_tab) {
++                            tab.set_view_mode(*mode);
++                        }
++                        return PaneToolbarClick::ViewMode(*mode);
++                    }
++                }
++
++                PaneToolbarClick::None
++            }
++            Pane::Split { first, second, .. } => {
++                let result = first.on_toolbar_click(pos);
++                if result != PaneToolbarClick::None {
++                    return result;
++                }
++                second.on_toolbar_click(pos)
++            }
++        }
++    }
++
++    /// Check if a point is within the toolbar area.
++    pub fn is_in_toolbar(&self, pos: Point) -> bool {
++        match self {
++            Pane::Leaf { bounds, .. } => {
++                let toolbar_bounds = Self::toolbar_bounds(*bounds);
++                toolbar_bounds.contains_point(pos)
++            }
++            Pane::Split { first, second, .. } => {
++                first.is_in_toolbar(pos) || second.is_in_toolbar(pos)
++            }
++        }
++    }
++
      /// Close the active tab. Returns true if pane should be removed (no tabs left).
      pub fn close_active_tab(&mut self) -> bool {
          if let Pane::Leaf { tabs, active_tab, .. } = self {

garfield/src/ui/picker_toolbar.rsadded

++//! Picker toolbar component with Accept/Cancel buttons.
++//!
++//! This toolbar replaces the normal toolbar when garfield runs in picker mode.
++
++use anyhow::Result;
++use gartk_core::{Point, Rect};
++use gartk_render::{Renderer, TextStyle};
++
++/// Height of the picker toolbar (same as normal toolbar).
++pub const PICKER_TOOLBAR_HEIGHT: u32 = 36;
++
++/// Button width.
++const BUTTON_WIDTH: u32 = 100;
++
++/// Button height.
++const BUTTON_HEIGHT: u32 = 28;
++
++/// Picker toolbar click result.
++#[derive(Debug, Clone, Copy, PartialEq, Eq)]
++pub enum PickerToolbarClick {
++    /// Accept button clicked.
++    Accept,
++    /// Cancel button clicked.
++    Cancel,
++    /// Nothing clicked.
++    None,
++}
++
++/// Picker toolbar with Accept and Cancel buttons.
++pub struct PickerToolbar {
++    /// Toolbar bounds.
++    bounds: Rect,
++    /// Accept button label.
++    accept_label: String,
++    /// Cancel button label.
++    cancel_label: String,
++    /// Accept button bounds.
++    accept_bounds: Rect,
++    /// Cancel button bounds.
++    cancel_bounds: Rect,
++    /// Hovered button (0 = accept, 1 = cancel).
++    hovered: Option<usize>,
++    /// Focused button for keyboard navigation (0 = accept, 1 = cancel).
++    focused: usize,
++    /// Whether accept button is enabled (has valid selection).
++    accept_enabled: bool,
++    /// Filter description shown in toolbar.
++    filter_description: Option<String>,
++}
++
++impl PickerToolbar {
++    /// Create a new picker toolbar.
++    pub fn new(bounds: Rect, accept_label: String) -> Self {
++        let mut toolbar = Self {
++            bounds,
++            accept_label,
++            cancel_label: "Cancel".to_string(),
++            accept_bounds: Rect::default(),
++            cancel_bounds: Rect::default(),
++            hovered: None,
++            focused: 0,
++            accept_enabled: false,
++            filter_description: None,
++        };
++        toolbar.layout_buttons();
++        toolbar
++    }
++
++    /// Set bounds.
++    pub fn set_bounds(&mut self, bounds: Rect) {
++        self.bounds = bounds;
++        self.layout_buttons();
++    }
++
++    /// Layout buttons.
++    fn layout_buttons(&mut self) {
++        // Buttons are right-aligned
++        let padding = 8;
++        let button_gap = 12;
++
++        // Cancel button (rightmost)
++        let cancel_x = self.bounds.x + self.bounds.width as i32 - BUTTON_WIDTH as i32 - padding;
++        let button_y = self.bounds.y + (self.bounds.height as i32 - BUTTON_HEIGHT as i32) / 2;
++        self.cancel_bounds = Rect::new(cancel_x, button_y, BUTTON_WIDTH, BUTTON_HEIGHT);
++
++        // Accept button (to the left of cancel)
++        let accept_x = cancel_x - BUTTON_WIDTH as i32 - button_gap;
++        self.accept_bounds = Rect::new(accept_x, button_y, BUTTON_WIDTH, BUTTON_HEIGHT);
++    }
++
++    /// Set whether accept button is enabled.
++    pub fn set_accept_enabled(&mut self, enabled: bool) {
++        self.accept_enabled = enabled;
++    }
++
++    /// Set filter description shown in toolbar.
++    pub fn set_filter_description(&mut self, desc: Option<String>) {
++        self.filter_description = desc;
++    }
++
++    /// Handle mouse move. Returns true if hovered state changed.
++    pub fn on_mouse_move(&mut self, pos: Point) -> bool {
++        if !self.bounds.contains_point(pos) {
++            if self.hovered.is_some() {
++                self.hovered = None;
++                return true;
++            }
++            return false;
++        }
++
++        let new_hovered = if self.accept_bounds.contains_point(pos) {
++            Some(0)
++        } else if self.cancel_bounds.contains_point(pos) {
++            Some(1)
++        } else {
++            None
++        };
++
++        let changed = new_hovered != self.hovered;
++        self.hovered = new_hovered;
++        changed
++    }
++
++    /// Handle click. Returns the action if a button was clicked.
++    pub fn on_click(&self, pos: Point) -> PickerToolbarClick {
++        if self.accept_bounds.contains_point(pos) && self.accept_enabled {
++            PickerToolbarClick::Accept
++        } else if self.cancel_bounds.contains_point(pos) {
++            PickerToolbarClick::Cancel
++        } else {
++            PickerToolbarClick::None
++        }
++    }
++
++    /// Cycle focus between buttons.
++    pub fn cycle_focus(&mut self) {
++        self.focused = 1 - self.focused;
++    }
++
++    /// Activate focused button.
++    pub fn activate_focused(&self) -> PickerToolbarClick {
++        if self.focused == 0 && self.accept_enabled {
++            PickerToolbarClick::Accept
++        } else if self.focused == 1 {
++            PickerToolbarClick::Cancel
++        } else {
++            PickerToolbarClick::None
++        }
++    }
++
++    /// Check if point is within toolbar bounds.
++    pub fn contains_point(&self, pos: Point) -> bool {
++        self.bounds.contains_point(pos)
++    }
++
++    /// Render the toolbar.
++    pub fn render(&self, renderer: &Renderer) -> Result<()> {
++        let theme = renderer.theme();
++
++        // Toolbar background
++        renderer.fill_rect(self.bounds, theme.item_background)?;
++
++        // Filter description (left side)
++        if let Some(desc) = &self.filter_description {
++            let text_style = TextStyle::new()
++                .font_family(&theme.font_family)
++                .font_size(theme.font_size - 1.0)
++                .color(theme.item_foreground);
++
++            renderer.text(
++                desc,
++                (self.bounds.x + 12) as f64,
++                (self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2) as f64,
++                &text_style,
++            )?;
++        }
++
++        // Accept button
++        let accept_hovered = self.hovered == Some(0);
++        let accept_focused = self.focused == 0;
++        let (accept_bg, accept_fg) = if !self.accept_enabled {
++            // Disabled state - use input_background for visibility
++            (theme.input_background.with_alpha(0.5), theme.item_foreground.with_alpha(0.5))
++        } else if accept_hovered || accept_focused {
++            // Active state - use accent color
++            (theme.selection_background, theme.foreground)
++        } else {
++            // Normal state - accent color slightly dimmed
++            (theme.selection_background.with_alpha(0.8), theme.foreground)
++        };
++
++        renderer.fill_rounded_rect(self.accept_bounds, 4.0, accept_bg)?;
++        if accept_focused && self.accept_enabled {
++            renderer.stroke_rounded_rect(self.accept_bounds, 4.0, theme.foreground, 2.0)?;
++        }
++
++        let button_style = TextStyle::new()
++            .font_family(&theme.font_family)
++            .font_size(theme.font_size)
++            .color(accept_fg);
++
++        let accept_metrics = renderer.measure_text(&self.accept_label, &button_style)?;
++        let accept_text_x = self.accept_bounds.x + (self.accept_bounds.width as i32 - accept_metrics.width as i32) / 2;
++        let accept_text_y = self.accept_bounds.y + (self.accept_bounds.height as i32 - accept_metrics.height as i32) / 2;
++        renderer.text(&self.accept_label, accept_text_x as f64, accept_text_y as f64, &button_style)?;
++
++        // Cancel button - use input_background for visibility
++        let cancel_hovered = self.hovered == Some(1);
++        let cancel_focused = self.focused == 1;
++        let cancel_bg = if cancel_hovered || cancel_focused {
++            theme.item_hover_background
++        } else {
++            theme.input_background
++        };
++
++        renderer.fill_rounded_rect(self.cancel_bounds, 4.0, cancel_bg)?;
++        if cancel_focused {
++            renderer.stroke_rounded_rect(self.cancel_bounds, 4.0, theme.foreground, 2.0)?;
++        }
++        renderer.stroke_rounded_rect(self.cancel_bounds, 4.0, theme.border, 1.0)?;
++
++        let cancel_style = TextStyle::new()
++            .font_family(&theme.font_family)
++            .font_size(theme.font_size)
++            .color(theme.foreground);
++
++        let cancel_metrics = renderer.measure_text(&self.cancel_label, &cancel_style)?;
++        let cancel_text_x = self.cancel_bounds.x + (self.cancel_bounds.width as i32 - cancel_metrics.width as i32) / 2;
++        let cancel_text_y = self.cancel_bounds.y + (self.cancel_bounds.height as i32 - cancel_metrics.height as i32) / 2;
++        renderer.text(&self.cancel_label, cancel_text_x as f64, cancel_text_y as f64, &cancel_style)?;
++
++        // Bottom border
++        let border_y = self.bounds.y + self.bounds.height as i32 - 1;
++        renderer.fill_rect(
++            Rect::new(self.bounds.x, border_y, self.bounds.width, 1),
++            theme.border,
++        )?;
++
++        Ok(())
++    }
++}

garfield/src/ui/tab.rsmodified


         }
     }
 
+    /// Get all selected entries.
+    pub fn selected_entries(&self) -> Vec<&FileEntry> {
         match self.view_mode {
+            ViewMode::List => self.list_view.selected_entries(),
+            ViewMode::Grid => self.grid_view.selected_entries(),
+            ViewMode::Columns => self.column_view.selected_entries(),
         }
     }
 
+    /// Get paths of all selected entries.
+    pub fn selected_paths(&self) -> Vec<std::path::PathBuf> {
+        self.selected_entries().iter().map(|e| e.path.clone()).collect()
+    }
+
     /// Check if a path is in the current selection.
     pub fn is_path_selected(&self, path: &std::path::Path) -> bool {
         self.selected_paths().iter().any(|p| p == path)

garfield/src/ui/tab_bar.rsmodified

  /// Padding inside tabs.
  const TAB_PADDING: u32 = 12;
++/// Width of the new tab button.
++const NEW_TAB_BUTTON_WIDTH: u32 = 32;
++
++/// Result of clicking on the tab bar.
++#[derive(Debug, Clone, Copy, PartialEq, Eq)]
++pub enum TabBarClickResult {
++    /// Clicked on a tab (index, is_close_button).
++    Tab(usize, bool),
++    /// Clicked on the new tab button.
++    NewTab,
++    /// No click target.
++    None,
++}
++
  /// Information about a tab for rendering.
  #[derive(Clone)]
  pub struct TabInfo {
      hovered_tab: Option<usize>,
      /// Hovered close button index.
      hovered_close: Option<usize>,
++    /// Hovered new tab button.
++    hovered_new_tab: bool,
      /// Cached tab bounds.
      tab_bounds: Vec<Rect>,
++    /// Bounds of the new tab button.
++    new_tab_bounds: Option<Rect>,
      /// Tab being dragged (index).
      dragging_tab: Option<usize>,
      /// Drag start position.
              active_index: 0,
              hovered_tab: None,
              hovered_close: None,
++            hovered_new_tab: false,
              tab_bounds: Vec::new(),
++            new_tab_bounds: None,
              dragging_tab: None,
              drag_start: None,
              drag_active: false,
      /// Recalculate tab bounds based on number of tabs.
      fn recalculate_tab_bounds(&mut self) {
          self.tab_bounds.clear();
++        self.new_tab_bounds = None;
++
++        // Reserve space for the new tab button
++        let available_width = self.bounds.width.saturating_sub(NEW_TAB_BUTTON_WIDTH + 4);
          if self.tabs.is_empty() {
++            // Even with no tabs, show the + button
++            self.new_tab_bounds = Some(Rect::new(
++                self.bounds.x + 4,
++                self.bounds.y + 4,
++                NEW_TAB_BUTTON_WIDTH,
++                TAB_BAR_HEIGHT - 8,
++            ));
              return;
+         }
--        let available_width = self.bounds.width;
          let tab_count = self.tabs.len() as u32;
          // Calculate tab width (equal distribution, clamped)
              self.tab_bounds.push(Rect::new(x, self.bounds.y, tab_width, TAB_BAR_HEIGHT));
              x += tab_width as i32;
+         }
++
++        // Position the new tab button after the last tab
++        self.new_tab_bounds = Some(Rect::new(
++            x + 4,
++            self.bounds.y + 4,
++            NEW_TAB_BUTTON_WIDTH,
++            TAB_BAR_HEIGHT - 8,
++        ));
+     }
      /// Get the close button bounds for a tab.
      pub fn on_mouse_move(&mut self, pos: Point) -> bool {
          let old_hovered_tab = self.hovered_tab;
          let old_hovered_close = self.hovered_close;
++        let old_hovered_new_tab = self.hovered_new_tab;
          self.hovered_tab = None;
          self.hovered_close = None;
++        self.hovered_new_tab = false;
          if !self.bounds.contains_point(pos) {
--            return self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close;
++            return self.hovered_tab != old_hovered_tab
++                || self.hovered_close != old_hovered_close
++                || self.hovered_new_tab != old_hovered_new_tab;
++        }
++
++        // Check new tab button
++        if let Some(new_tab_bounds) = self.new_tab_bounds {
++            if new_tab_bounds.contains_point(pos) {
++                self.hovered_new_tab = true;
++                return self.hovered_tab != old_hovered_tab
++                    || self.hovered_close != old_hovered_close
++                    || self.hovered_new_tab != old_hovered_new_tab;
++            }
+         }
          for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {
                  if let Some(close_bounds) = self.close_button_bounds(i) {
                      if close_bounds.contains_point(pos) {
                          self.hovered_close = Some(i);
--                        return self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close;
++                        return self.hovered_tab != old_hovered_tab
++                            || self.hovered_close != old_hovered_close
++                            || self.hovered_new_tab != old_hovered_new_tab;
+                     }
+                 }
                  self.hovered_tab = Some(i);
--                return self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close;
++                return self.hovered_tab != old_hovered_tab
++                    || self.hovered_close != old_hovered_close
++                    || self.hovered_new_tab != old_hovered_new_tab;
+             }
+         }
--        self.hovered_tab != old_hovered_tab || self.hovered_close != old_hovered_close
++        self.hovered_tab != old_hovered_tab
++            || self.hovered_close != old_hovered_close
++            || self.hovered_new_tab != old_hovered_new_tab
+     }
--    /// Handle click. Returns (clicked_tab, is_close_button).
++    /// Handle click. Returns the click result.
--    pub fn on_click(&self, pos: Point) -> Option<(usize, bool)> {
++    pub fn on_click(&self, pos: Point) -> TabBarClickResult {
          if !self.bounds.contains_point(pos) {
--            return None;
++            return TabBarClickResult::None;
++        }
++
++        // Check new tab button
++        if let Some(new_tab_bounds) = self.new_tab_bounds {
++            if new_tab_bounds.contains_point(pos) {
++                return TabBarClickResult::NewTab;
++            }
+         }
          for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {
                  // Check if clicking close button
                  if let Some(close_bounds) = self.close_button_bounds(i) {
                      if close_bounds.contains_point(pos) {
--                        return Some((i, true));
++                        return TabBarClickResult::Tab(i, true);
+                     }
+                 }
--                return Some((i, false));
++                return TabBarClickResult::Tab(i, false);
+             }
+         }
--        None
++        TabBarClickResult::None
+     }
      /// Clear hover state.
      pub fn clear_hover(&mut self) {
          self.hovered_tab = None;
          self.hovered_close = None;
++        self.hovered_new_tab = false;
+     }
      /// Start potential tab drag.
+             }
+         }
++        // Draw new tab button
++        if let Some(bounds) = self.new_tab_bounds {
++            // Background on hover
++            if self.hovered_new_tab {
++                renderer.fill_rounded_rect(bounds, 4.0, theme.item_background)?;
++            }
++
++            // Draw + symbol
++            let cx = bounds.x + bounds.width as i32 / 2;
++            let cy = bounds.y + bounds.height as i32 / 2;
++            let size = 6;
++            let color = if self.hovered_new_tab {
++                theme.foreground
++            } else {
++                theme.foreground.with_alpha(0.6)
++            };
++
++            // Horizontal line
++            renderer.line(
++                (cx - size) as f64,
++                cy as f64,
++                (cx + size) as f64,
++                cy as f64,
++                color,
++                1.5,
++            )?;
++            // Vertical line
++            renderer.line(
++                cx as f64,
++                (cy - size) as f64,
++                cx as f64,
++                (cy + size) as f64,
++                color,
++                1.5,
++            )?;
++        }
++
          Ok(())
+     }
+ }

gardesk/garfield / `587b538`

22 changed files

`@@ -42,6 +42,9 @@` freedesktop_entry_parser.workspace = true
42	# Fuzzy matching	42	# Fuzzy matching
43	nucleo-matcher.workspace = true	43	nucleo-matcher.workspace = true
44		44
		45	+# CLI
		46	+clap.workspace = true
		47	+
45	# IPC	48	# IPC
46	garfield-ipc.workspace = true	49	garfield-ipc.workspace = true
47		50

`@@ -14,7 +14,7 @@` pub mod undo;
14		14
15	pub use clipboard::{Clipboard, ClipboardOperation};	15	pub use clipboard::{Clipboard, ClipboardOperation};
16	pub use entry::{	16	pub use entry::{
17	- read_directory, sort_entries, EntryType, FileEntry, SortDirection, SortOrder,	17	+ matches_any_filter, matches_filter, read_directory, sort_entries, EntryType, FileEntry, SortDirection, SortOrder,
18	};	18	};
19	pub use file_drag::{DragTarget, FileDragController, FileDragState, FlashState};	19	pub use file_drag::{DragTarget, FileDragController, FileDragState, FlashState};
20	pub use history::History;	20	pub use history::History;

`@@ -255,15 +255,20 @@` impl Tab {
255	}	255	}
256	}	256	}
257		257
258	- /// Get paths of all selected entries.	258	+ /// Get all selected entries.
259	- pub fn selected_paths(&self) -> Vec<std::path::PathBuf> {	259	+ pub fn selected_entries(&self) -> Vec<&FileEntry> {
260	match self.view_mode {	260	match self.view_mode {
261	- ViewMode::List => self.list_view.selected_entries().iter().map(\|e\| e.path.clone()).collect(),	261	+ ViewMode::List => self.list_view.selected_entries(),
262	- ViewMode::Grid => self.grid_view.selected_entries().iter().map(\|e\| e.path.clone()).collect(),	262	+ ViewMode::Grid => self.grid_view.selected_entries(),
263	- ViewMode::Columns => self.column_view.selected_entries().iter().map(\|e\| e.path.clone()).collect(),	263	+ ViewMode::Columns => self.column_view.selected_entries(),
264	}	264	}
265	}	265	}
266		266
		267	+ /// Get paths of all selected entries.
		268	+ pub fn selected_paths(&self) -> Vec<std::path::PathBuf> {
		269	+ self.selected_entries().iter().map(\|e\| e.path.clone()).collect()
		270	+ }
		271	+
267	/// Check if a path is in the current selection.	272	/// Check if a path is in the current selection.
268	pub fn is_path_selected(&self, path: &std::path::Path) -> bool {	273	pub fn is_path_selected(&self, path: &std::path::Path) -> bool {
269	self.selected_paths().iter().any(\|p\| p == path)	274	self.selected_paths().iter().any(\|p\| p == path)