`587b538`

add xdg-desktop-portal backend and picker mode UI

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 587b53800df203edf5a817a409c42add09f1fa6c
Parents: b121406
Tree: 67004a7

22 changed files

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_msvc",
 - "windows_i686_gnu",
 - "windows_i686_gnullvm",
 - "windows_i686_msvc",
 - "windows_x86_64_gnu",
 - "windows_x86_64_gnullvm",
 - "windows_x86_64_msvc",
 + "windows_aarch64_gnullvm 0.52.6",
 + "windows_aarch64_msvc 0.52.6",
 + "windows_i686_gnu 0.52.6",
 + "windows_i686_gnullvm 0.52.6",
 + "windows_i686_msvc 0.52.6",
 + "windows_x86_64_gnu 0.52.6",
 + "windows_x86_64_gnullvm 0.52.6",
 + "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)
 -        let width = (monitor.rect.width as f64 * 0.7) as u32;
 -        let height = (monitor.rect.height as f64 * 0.7) as u32;
 +        // Calculate window size (70% of screen, smaller for picker mode)
 +        let scale = if picker_config.is_picker() { 0.5 } else { 0.7 };
 +        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
 -        let window = Window::create(
 -            conn.clone(),
 -            WindowConfig::default()
 -                .title("garfield")
 -                .class("garfield")
 -                .position(x, y)
 -                .size(width, height)
 -                .transparent(false),
 -        )?;
 +        // Window title depends on mode
 +        let title = if picker_config.is_picker() {
 +            picker_config.title.clone().unwrap_or_else(|| {
 +                if picker_config.mode.is_directory_mode() {
 +                    "Select Folder".to_string()
 +                } else {
 +                    "Open File".to_string()
 +                }
 +            })
 +        } 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)
 -            if let Some((tab_index, is_close)) = self.tab_bar.on_click(pos) {
 -                if is_close {
 -                    self.close_tab(tab_index);
 +            // Handle tab bar clicks (non-drag)
 +            match self.tab_bar.on_click(pos) {
 +                TabBarClickResult::Tab(tab_index, is_close) => {
 +                    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
 -        if let Some(action) = self.toolbar.on_click(pos) {
 -            self.handle_toolbar_action(action);
 +        // Check pane toolbar clicks (view mode buttons)
 +        if let PaneToolbarClick::ViewMode(_mode) = self.root_pane.on_toolbar_click(pos) {
 +            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() {
 -            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("/")));
 +        let path = 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() {
 -            pane.active_tab().map(|t| t.current_path().clone())
 +        let (path, view_mode) = if let Some(pane) = self.focused_pane() {
 +            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() {
 -            pane.active_tab().map(|t| t.current_path().clone())
 +        let (path, view_mode) = if let Some(pane) = self.focused_pane() {
 +            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(
 -            sidebar_w as i32,
 -            (height - STATUS_BAR_HEIGHT) as i32,
 -            width - sidebar_w,
 -            STATUS_BAR_HEIGHT,
 -        ));
 +        // Update picker toolbar bounds at bottom (if in picker mode)
 +        if let Some(ref mut picker_toolbar) = self.picker_toolbar {
 +            picker_toolbar.set_bounds(Rect::new(
 +                sidebar_w as i32,
 +                (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
 -        self.status_bar.render(&self.renderer)?;
 +        // Draw status bar or picker toolbar at bottom
 +        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::{
 -    read_directory, sort_entries, EntryType, FileEntry, SortDirection, SortOrder,
 +    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()
 -        .with_env_filter(filter)
 -        .with_target(false)
 -        .init();
+-
 -    tracing::info!("Starting garfield");
+-
 -    // Parse command line arguments (simple for now)
 -    let start_dir = std::env::args()
 -        .nth(1)
 -        .map(PathBuf::from);
 +    if picker_config.is_picker() {
 +        // Picker mode: log to stderr so stdout is clean for path output
 +        fmt()
 +            .with_env_filter(filter)
 +            .with_target(false)
 +            .with_writer(std::io::stderr)
 +            .init();
 +        tracing::info!("Starting garfield in picker mode");
 +    } else {
 +        // Normal mode: log to stdout
 +        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 paths of all selected entries.
 -    pub fn selected_paths(&self) -> Vec<std::path::PathBuf> {
 +    /// Get all selected entries.
 +    pub fn selected_entries(&self) -> Vec<&FileEntry> {
          match self.view_mode {
 -            ViewMode::List => self.list_view.selected_entries().iter().map(|e| e.path.clone()).collect(),
 -            ViewMode::Grid => self.grid_view.selected_entries().iter().map(|e| e.path.clone()).collect(),
 -            ViewMode::Columns => self.column_view.selected_entries().iter().map(|e| e.path.clone()).collect(),
 +            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).
 -    pub fn on_click(&self, pos: Point) -> Option<(usize, bool)> {
 +    /// Handle click. Returns the click result.
 +    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(())
+     }
+ }