├── .gitignore
├── src
    ├── ui
    │   └── mod.rs
    ├── protos
    │   ├── activate.proto
    │   ├── subscribe.proto
    │   ├── query.proto
    │   └── mod.rs
    ├── providers
    │   ├── default_provider.rs
    │   ├── dmenu.rs
    │   ├── archlinuxpkgs.rs
    │   ├── symbols.rs
    │   ├── unicode.rs
    │   ├── providerlist.rs
    │   ├── calc.rs
    │   ├── todo.rs
    │   ├── files.rs
    │   ├── clipboard.rs
    │   └── mod.rs
    ├── preview
    │   ├── mod.rs
    │   ├── clipboard_preview.rs
    │   └── files_preview.rs
    ├── renderers
    │   └── mod.rs
    ├── theme
    │   └── mod.rs
    ├── state
    │   └── mod.rs
    ├── keybinds.rs
    ├── config.rs
    └── main.rs
├── rust-toolchain.toml
├── .github
    ├── FUNDING.yml
    ├── ISSUE_TEMPLATE
    │   ├── config.yml
    │   ├── feature_request.md
    │   └── bug_report.md
    └── workflows
    │   ├── nix.yml
    │   ├── nix_git.yml
    │   └── build.yml
├── resources
    ├── screenshot.png
    ├── themes
    │   └── default
    │   │   ├── preview.xml
    │   │   ├── keybind.xml
    │   │   ├── item_dmenu.xml
    │   │   ├── item_symbols.xml
    │   │   ├── item_unicode.xml
    │   │   ├── item_files.xml
    │   │   ├── item_todo.xml
    │   │   ├── item_archlinuxpkgs.xml
    │   │   ├── item_clipboard.xml
    │   │   ├── item_calc.xml
    │   │   ├── item.xml
    │   │   ├── item_providerlist.xml
    │   │   ├── style.css
    │   │   └── layout.xml
    └── config.toml
├── Cargo.toml
├── nix
    ├── package.nix
    └── modules
    │   ├── home-manager.nix
    │   └── nixos.nix
├── flake.nix
├── flake.lock
├── makefile
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | .zed
3 | 


--------------------------------------------------------------------------------
/src/ui/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod window;
2 | 


--------------------------------------------------------------------------------
/rust-toolchain.toml:
--------------------------------------------------------------------------------
1 | [toolchain]
2 | channel = "stable"
3 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [abenz1267]
2 | ko_fi: andrejbenz
3 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/config.yml:
--------------------------------------------------------------------------------
1 | blank_issues_enabled: false
2 | 


--------------------------------------------------------------------------------
/resources/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/scottmckendry/walker/master/resources/screenshot.png


--------------------------------------------------------------------------------
/src/protos/activate.proto:
--------------------------------------------------------------------------------
 1 | syntax = "proto3";
 2 | 
 3 | package pb;
 4 | 
 5 | option go_package = "./pb";
 6 | 
 7 | message ActivateRequest {
 8 |   string provider = 1;
 9 |   string identifier = 2;
10 |   string action = 3;
11 |   string query = 4;
12 |   string arguments = 5;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/protos/subscribe.proto:
--------------------------------------------------------------------------------
 1 | syntax = "proto3";
 2 | 
 3 | package pb;
 4 | 
 5 | option go_package = "./pb";
 6 | 
 7 | message SubscribeRequest {
 8 |   int32 interval = 1;
 9 |   string provider = 2;
10 |   string query = 3;
11 | }
12 | 
13 | message SubscribeResponse {
14 |   string value = 2;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/providers/default_provider.rs:
--------------------------------------------------------------------------------
 1 | use crate::providers::Provider;
 2 | 
 3 | #[derive(Debug)]
 4 | pub struct DefaultProvider {
 5 |     name: String,
 6 | }
 7 | 
 8 | impl DefaultProvider {
 9 |     pub fn new(name: String) -> Self {
10 |         Self { name }
11 |     }
12 | }
13 | 
14 | impl Provider for DefaultProvider {
15 |     fn get_name(&self) -> &str {
16 |         self.name.as_str()
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Describe a feature you'd like to see in Walker
 4 | title: ""
 5 | labels: ""
 6 | assignees: ""
 7 | ---
 8 | 
 9 | **Describe the feature**
10 | A clear and concise description of what the feature is.
11 | 
12 | **Alternatives**
13 | Possible alternatives.
14 | 
15 | **Describe the behaviour**
16 | Step by step description of the desired behaviour.
17 | 


--------------------------------------------------------------------------------
/src/providers/dmenu.rs:
--------------------------------------------------------------------------------
 1 | use crate::providers::Provider;
 2 | 
 3 | #[derive(Debug)]
 4 | pub struct Dmenu {
 5 |     name: &'static str,
 6 | }
 7 | 
 8 | impl Dmenu {
 9 |     pub fn new() -> Self {
10 |         Self { name: "dmenu" }
11 |     }
12 | }
13 | 
14 | impl Provider for Dmenu {
15 |     fn get_name(&self) -> &str {
16 |         self.name
17 |     }
18 | 
19 |     fn get_item_layout(&self) -> String {
20 |         include_str!("../../resources/themes/default/item_dmenu.xml").to_string()
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/providers/archlinuxpkgs.rs:
--------------------------------------------------------------------------------
 1 | use crate::providers::Provider;
 2 | 
 3 | #[derive(Debug)]
 4 | pub struct ArchLinuxPkgs {
 5 |     name: &'static str,
 6 | }
 7 | 
 8 | impl ArchLinuxPkgs {
 9 |     pub fn new() -> Self {
10 |         Self {
11 |             name: "archlinuxpkgs",
12 |         }
13 |     }
14 | }
15 | 
16 | impl Provider for ArchLinuxPkgs {
17 |     fn get_name(&self) -> &str {
18 |         self.name
19 |     }
20 | 
21 |     fn get_item_layout(&self) -> String {
22 |         include_str!("../../resources/themes/default/item_archlinuxpkgs.xml").to_string()
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/resources/themes/default/preview.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="PreviewBox">
 5 |     <style>
 6 |       <class name="preview-box"></class>
 7 |     </style>
 8 |     <property name="height-request">300</property>
 9 |     <property name="width-request">500</property>
10 |     <child>
11 |       <object class="GtkStack" id="PreviewStack">
12 |         <style>
13 |           <class name="preview-stack"></class>
14 |         </style>
15 |         <property name="hexpand">true</property>
16 |         <property name="vexpand">true</property>
17 |       </object>
18 |     </child>
19 |   </object>
20 | </interface>
21 | 


--------------------------------------------------------------------------------
/resources/themes/default/keybind.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="Keybind">
 5 |     <style>
 6 |       <class name="keybind"></class>
 7 |     </style>
 8 |     <property name="orientation">vertical</property>
 9 |     <child>
10 |       <object class="GtkLabel" id="KeybindBind">
11 |         <style>
12 |           <class name="keybind-bind"></class>
13 |         </style>
14 |       </object>
15 |     </child>
16 |     <child>
17 |       <object class="GtkLabel" id="KeybindLabel">
18 |         <style>
19 |           <class name="keybind-label"></class>
20 |         </style>
21 |       </object>
22 |     </child>
23 |   </object>
24 | </interface>
25 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "walker"
 3 | version = "2.7.3"
 4 | edition = "2024"
 5 | 
 6 | [dependencies]
 7 | gtk4 = { version = "^0.9.7", features = ["v4_6", "v4_12", "gio_v2_80"] }
 8 | gtk4-layer-shell = "0.5.0"
 9 | protobuf = "3.7.2"
10 | serde = { version = "1.0.219", features = ["derive"] }
11 | chrono = { version = "0.4", features = ["clock"] }
12 | config = "0.15.14"
13 | dirs = "6.0.0"
14 | notify = "8.2.0"
15 | poppler-rs = "0.25.0"
16 | cairo-rs = "0.21.1"
17 | gdk-pixbuf = "0.21.1"
18 | nucleo-matcher = "0.3.1"
19 | which = "8.0"
20 | new_mime_guess = "4.0.4"
21 | mime = "0.3.17"
22 | tokio = { version = "1.47.1", features = ["full"] }
23 | xdg = "3.0.0"
24 | 
25 | [build-dependencies]
26 | protobuf-codegen = "3.4"
27 | protoc-bin-vendored = "3.0"
28 | 


--------------------------------------------------------------------------------
/.github/workflows/nix.yml:
--------------------------------------------------------------------------------
 1 | name: Nix
 2 | 
 3 | on:
 4 |   push:
 5 |     tags:
 6 |       - v*
 7 |   workflow_dispatch:
 8 | 
 9 | jobs:
10 |   build:
11 |     name: Build
12 |     runs-on: ubuntu-latest
13 | 
14 |     permissions:
15 |       contents: read
16 |       id-token: write
17 | 
18 |     steps:
19 |       - name: Checkout
20 |         uses: actions/checkout@v4
21 | 
22 |       - name: Install Nix
23 |         uses: DeterminateSystems/nix-installer-action@main
24 | 
25 |       - name: Set up Cachix
26 |         uses: cachix/cachix-action@v16
27 |         with:
28 |           name: walker
29 |           authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
30 | 
31 |       - name: Build default package
32 |         run: nix build -L --extra-substituters "https://walker.cachix.org" .#default --print-out-paths | cachix push walker


--------------------------------------------------------------------------------
/.github/workflows/nix_git.yml:
--------------------------------------------------------------------------------
 1 | name: Nix-Git
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |   workflow_dispatch:
 8 | 
 9 | jobs:
10 |   build:
11 |     name: Build
12 |     runs-on: ubuntu-latest
13 | 
14 |     permissions:
15 |       contents: read
16 |       id-token: write
17 | 
18 |     steps:
19 |       - name: Checkout
20 |         uses: actions/checkout@v4
21 | 
22 |       - name: Install Nix
23 |         uses: DeterminateSystems/nix-installer-action@main
24 | 
25 |       - name: Set up Cachix
26 |         uses: cachix/cachix-action@v16
27 |         with:
28 |           name: walker-git
29 |           authToken: '${{ secrets.CACHIX_GIT_AUTH_TOKEN }}'
30 | 
31 |       - name: Build default package
32 |         run: nix build -L --extra-substituters "https://walker-git.cachix.org" .#default --print-out-paths | cachix push walker-git


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ""
 5 | labels: ""
 6 | assignees: ""
 7 | ---
 8 | 
 9 | **Describe the bug**
10 | A clear and concise description of what the bug is.
11 | 
12 | **Configs**
13 | Relevant config to reproduce.
14 | 
15 | **To Reproduce**
16 | Steps to reproduce the behavior:
17 | 
18 | 1. Go to '...'
19 | 2. Click on '....'
20 | 3. Scroll down to '....'
21 | 4. See error
22 | 
23 | **Expected behavior**
24 | A clear and concise description of what you expected to happen.
25 | 
26 | **Screenshots**
27 | If applicable, add screenshots to help explain your problem.
28 | 
29 | **Desktop (please complete the following information):**
30 | 
31 | - OS: [e.g. iOS]
32 | - Walker version
33 | - Elephant version
34 | 
35 | **Additional context**
36 | Add any other context about the problem here.
37 | 


--------------------------------------------------------------------------------
/src/providers/symbols.rs:
--------------------------------------------------------------------------------
 1 | use gtk4::{Builder, Label, ListItem};
 2 | 
 3 | use crate::{protos::generated_proto::query::query_response::Item, providers::Provider};
 4 | 
 5 | #[derive(Debug)]
 6 | pub struct Symbols {
 7 |     name: &'static str,
 8 | }
 9 | 
10 | impl Symbols {
11 |     pub fn new() -> Self {
12 |         Self { name: "symbols" }
13 |     }
14 | }
15 | 
16 | impl Provider for Symbols {
17 |     fn get_name(&self) -> &str {
18 |         self.name
19 |     }
20 | 
21 |     fn get_item_layout(&self) -> String {
22 |         include_str!("../../resources/themes/default/item_symbols.xml").to_string()
23 |     }
24 | 
25 |     fn image_transformer(&self, b: &Builder, _: &ListItem, item: &Item) {
26 |         if let Some(image) = b.object::<Label>("ItemImage")
27 |             && !item.icon.is_empty()
28 |         {
29 |             image.set_label(&item.icon);
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/protos/query.proto:
--------------------------------------------------------------------------------
 1 | syntax = "proto3";
 2 | 
 3 | package pb;
 4 | 
 5 | option go_package = "./pb";
 6 | 
 7 | message QueryRequest {
 8 |   repeated string providers = 1;
 9 |   string query = 2;
10 |   int32 maxresults = 3;
11 |   bool exactsearch = 4;
12 | }
13 | 
14 | message QueryResponse {
15 |   string query = 1;
16 | 
17 |   enum Type {
18 |       REGULAR = 0;
19 |       FILE = 1;
20 |   }
21 | 
22 |   message Item {
23 |     message FuzzyInfo {
24 |       int32 start = 1;
25 |       string field = 2;
26 |       repeated int32 positions = 3;
27 |     }
28 | 
29 | 	string identifier = 1;
30 | 	string text = 2;
31 | 	string subtext = 3;
32 | 	string icon = 4;
33 | 	string provider = 5;
34 | 	int32 score = 6;
35 | 	FuzzyInfo fuzzyinfo = 7;
36 |     Type type = 8;
37 |     string mimetype = 9;
38 |     string preview = 10;
39 |     repeated string state = 11;
40 |     repeated string actions = 12;
41 |   }
42 | 
43 |    Item item = 2;
44 |    int32 qid =3;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/providers/unicode.rs:
--------------------------------------------------------------------------------
 1 | use gtk4::{Builder, Label, ListItem};
 2 | 
 3 | use crate::{protos::generated_proto::query::query_response::Item, providers::Provider};
 4 | 
 5 | #[derive(Debug)]
 6 | pub struct Unicode {
 7 |     name: &'static str,
 8 | }
 9 | 
10 | impl Unicode {
11 |     pub fn new() -> Self {
12 |         Self { name: "unicode" }
13 |     }
14 | }
15 | 
16 | impl Provider for Unicode {
17 |     fn get_name(&self) -> &str {
18 |         self.name
19 |     }
20 | 
21 |     fn get_item_layout(&self) -> String {
22 |         include_str!("../../resources/themes/default/item_unicode.xml").to_string()
23 |     }
24 | 
25 |     fn image_transformer(&self, b: &Builder, _: &ListItem, item: &Item) {
26 |         if let Some(image) = b.object::<Label>("ItemImage")
27 |             && !item.icon.is_empty()
28 |             && let Ok(code_point) = u32::from_str_radix(&item.icon, 16)
29 |             && let Some(unicode_char) = char::from_u32(code_point)
30 |         {
31 |             image.set_label(&format!("{unicode_char}"));
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/providers/providerlist.rs:
--------------------------------------------------------------------------------
 1 | use crate::{
 2 |     config::get_config, protos::generated_proto::query::query_response::Item, providers::Provider,
 3 | };
 4 | 
 5 | #[derive(Debug)]
 6 | pub struct Providerlist {
 7 |     name: &'static str,
 8 | }
 9 | 
10 | impl Providerlist {
11 |     pub fn new() -> Self {
12 |         Self {
13 |             name: "providerlist",
14 |         }
15 |     }
16 | }
17 | 
18 | impl Provider for Providerlist {
19 |     fn get_name(&self) -> &str {
20 |         self.name
21 |     }
22 | 
23 |     fn subtext_transformer(&self, item: &Item, label: &gtk4::Label) {
24 |         let cfg = get_config();
25 | 
26 |         if let Some(prefix) = cfg
27 |             .providers
28 |             .prefixes
29 |             .iter()
30 |             .find(|p| p.provider == item.identifier)
31 |         {
32 |             label.set_text(format!("( {} )", &prefix.prefix).as_str());
33 |         }
34 |     }
35 | 
36 |     fn get_item_layout(&self) -> String {
37 |         include_str!("../../resources/themes/default/item_providerlist.xml").to_string()
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/providers/calc.rs:
--------------------------------------------------------------------------------
 1 | use std::path::Path;
 2 | 
 3 | use gtk4::{Builder, Image, ListItem, prelude::WidgetExt};
 4 | 
 5 | use crate::{protos::generated_proto::query::query_response::Item, providers::Provider};
 6 | 
 7 | #[derive(Debug)]
 8 | pub struct Calc {
 9 |     name: &'static str,
10 | }
11 | 
12 | impl Calc {
13 |     pub fn new() -> Self {
14 |         Self { name: "calc" }
15 |     }
16 | }
17 | 
18 | impl Provider for Calc {
19 |     fn get_name(&self) -> &str {
20 |         self.name
21 |     }
22 | 
23 |     fn get_item_layout(&self) -> String {
24 |         include_str!("../../resources/themes/default/item_calc.xml").to_string()
25 |     }
26 | 
27 |     fn image_transformer(&self, b: &Builder, _: &ListItem, item: &Item) {
28 |         let Some(image) = b.object::<Image>("ItemImage") else {
29 |             return;
30 |         };
31 | 
32 |         if !item.state.contains(&"current".to_string()) {
33 |             image.set_visible(false);
34 |             return;
35 |         }
36 | 
37 |         let function = if !item.icon.is_empty() && Path::new(&item.icon).is_absolute() {
38 |             Image::set_from_file
39 |         } else if !item.icon.is_empty() {
40 |             Image::set_icon_name
41 |         } else {
42 |             return;
43 |         };
44 |         function(&image, Some(&item.icon))
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/providers/todo.rs:
--------------------------------------------------------------------------------
 1 | use std::path::Path;
 2 | 
 3 | use gtk4::{Builder, Image, ListItem, prelude::WidgetExt};
 4 | 
 5 | use crate::{protos::generated_proto::query::query_response::Item, providers::Provider};
 6 | 
 7 | #[derive(Debug)]
 8 | pub struct Todo {
 9 |     name: &'static str,
10 | }
11 | 
12 | impl Todo {
13 |     pub fn new() -> Self {
14 |         Self { name: "todo" }
15 |     }
16 | }
17 | 
18 | impl Provider for Todo {
19 |     fn get_name(&self) -> &str {
20 |         self.name
21 |     }
22 | 
23 |     fn get_item_layout(&self) -> String {
24 |         include_str!("../../resources/themes/default/item_todo.xml").to_string()
25 |     }
26 | 
27 |     fn image_transformer(&self, b: &Builder, _: &ListItem, item: &Item) {
28 |         let Some(image) = b.object::<Image>("ItemImage") else {
29 |             return;
30 |         };
31 | 
32 |         if !item.state.contains(&"creating".to_string()) {
33 |             image.set_visible(false);
34 |             return;
35 |         }
36 | 
37 |         let function = if !item.icon.is_empty() && Path::new(&item.icon).is_absolute() {
38 |             Image::set_from_file
39 |         } else if !item.icon.is_empty() {
40 |             Image::set_icon_name
41 |         } else {
42 |             return;
43 |         };
44 | 
45 |         function(&image, Some(&item.icon))
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/nix/package.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   rustPlatform,
 3 |   lib,
 4 |   pkg-config,
 5 |   protobuf,
 6 |   glib,
 7 |   gobject-introspection,
 8 |   gtk4,
 9 |   gtk4-layer-shell,
10 |   gdk-pixbuf,
11 |   graphene,
12 |   cairo,
13 |   pango,
14 |   wrapGAppsHook3,
15 |   poppler,
16 | }:
17 | rustPlatform.buildRustPackage rec {
18 |   pname = "walker";
19 |   version = (builtins.fromTOML (builtins.readFile ../Cargo.toml)).package.version;
20 | 
21 |   src = lib.fileset.toSource {
22 |     root = ../.;
23 |     fileset = lib.fileset.unions [
24 |       ../Cargo.toml
25 |       ../Cargo.lock
26 |       ../src
27 |       ../build.rs
28 |       ../resources
29 |     ];
30 |   };
31 | 
32 |   cargoLock.lockFile = "${src}/Cargo.lock";
33 | 
34 |   nativeBuildInputs = [
35 |     gobject-introspection
36 |     pkg-config
37 |     protobuf
38 |     wrapGAppsHook3
39 |   ];
40 | 
41 |   buildInputs = [
42 |     glib
43 |     gtk4
44 |     gtk4-layer-shell
45 |     gdk-pixbuf
46 |     graphene
47 |     cairo
48 |     pango
49 |     poppler
50 |   ];
51 | 
52 |   meta = {
53 |     description = "Wayland-native application runner";
54 |     homepage = "https://github.com/abenz1267/walker";
55 |     license = lib.licenses.mit;
56 |     maintainers = with lib.maintainers; [diniamo NotAShelf];
57 |     platforms = lib.platforms.linux;
58 |     mainProgram = "walker";
59 |   };
60 | }
61 | 


--------------------------------------------------------------------------------
/src/providers/files.rs:
--------------------------------------------------------------------------------
 1 | use std::env;
 2 | 
 3 | use gtk4::{
 4 |     Builder, Image, ListItem,
 5 |     gio::{self, prelude::FileExt},
 6 | };
 7 | 
 8 | use crate::{protos::generated_proto::query::query_response::Item, providers::Provider};
 9 | 
10 | #[derive(Debug)]
11 | pub struct Files {
12 |     name: &'static str,
13 | }
14 | 
15 | impl Files {
16 |     pub fn new() -> Self {
17 |         Self { name: "files" }
18 |     }
19 | }
20 | 
21 | impl Provider for Files {
22 |     fn get_name(&self) -> &str {
23 |         self.name
24 |     }
25 | 
26 |     fn get_item_layout(&self) -> String {
27 |         include_str!("../../resources/themes/default/item_files.xml").to_string()
28 |     }
29 | 
30 |     fn text_transformer(&self, item: &Item, label: &gtk4::Label) {
31 |         if let Ok(home) = env::var("HOME")
32 |             && let Some(stripped) = item.text.strip_prefix(&home)
33 |         {
34 |             label.set_label(stripped);
35 |         }
36 |     }
37 | 
38 |     fn image_transformer(&self, b: &Builder, _: &ListItem, item: &Item) {
39 |         let Some(image) = b.object::<Image>("ItemImage") else {
40 |             return;
41 |         };
42 | 
43 |         let file = gio::File::for_path(&item.text);
44 | 
45 |         let info = file.query_info(
46 |             "standard::icon",
47 |             gio::FileQueryInfoFlags::NONE,
48 |             gio::Cancellable::NONE,
49 |         );
50 | 
51 |         if let Ok(info) = info
52 |             && let Some(icon) = info.icon()
53 |         {
54 |             image.set_from_gicon(&icon);
55 |         }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/protos/mod.rs:
--------------------------------------------------------------------------------
 1 | use gtk4::glib::{self, subclass::types::ObjectSubclassIsExt};
 2 | 
 3 | pub mod generated_proto {
 4 |     include!(concat!(env!("OUT_DIR"), "/generated_proto/mod.rs"));
 5 | }
 6 | 
 7 | // GObject wrapper for QueryResponse
 8 | mod imp {
 9 |     use crate::protos::generated_proto::query::QueryResponse;
10 | 
11 |     use super::*;
12 |     use gtk4::subclass::prelude::*;
13 |     use std::cell::RefCell;
14 | 
15 |     #[derive(Debug, Default)]
16 |     pub struct QueryResponseObject {
17 |         pub response: RefCell<Option<QueryResponse>>,
18 |         pub dmenu_score: RefCell<u32>,
19 |     }
20 | 
21 |     #[glib::object_subclass]
22 |     impl ObjectSubclass for QueryResponseObject {
23 |         const NAME: &'static str = "QueryResponseObject";
24 |         type Type = super::QueryResponseObject;
25 |     }
26 | 
27 |     impl ObjectImpl for QueryResponseObject {}
28 | }
29 | 
30 | glib::wrapper! {
31 |     pub struct QueryResponseObject(ObjectSubclass<imp::QueryResponseObject>);
32 | }
33 | 
34 | impl QueryResponseObject {
35 |     pub fn new(response: crate::protos::generated_proto::query::QueryResponse) -> Self {
36 |         let obj: Self = glib::Object::builder().build();
37 |         obj.imp().response.replace(Some(response));
38 |         obj
39 |     }
40 | 
41 |     pub fn response(&self) -> crate::protos::generated_proto::query::QueryResponse {
42 |         self.imp().response.borrow().as_ref().unwrap().clone()
43 |     }
44 | 
45 |     pub fn dmenu_score(&self) -> u32 {
46 |         *self.imp().dmenu_score.borrow()
47 |     }
48 | 
49 |     pub fn set_dmenu_score(&self, val: u32) {
50 |         *self.imp().dmenu_score.borrow_mut() = val;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   description = ''
 3 |     Multi-Purpose Launcher with a lot of features. Highly Customizable and fast.
 4 |   '';
 5 | 
 6 |   inputs = {
 7 |     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
 8 |     systems.url = "github:nix-systems/default-linux";
 9 |     elephant.url = "github:abenz1267/elephant";
10 |     elephant.inputs.nixpkgs.follows = "nixpkgs";
11 |     elephant.inputs.systems.follows = "systems";
12 |   };
13 | 
14 |   outputs = {
15 |     self,
16 |     nixpkgs,
17 |     systems,
18 |     elephant,
19 |     ...
20 |   }: let
21 |     inherit (nixpkgs) lib;
22 |     eachSystem = f:
23 |       lib.genAttrs (import systems)
24 |       (system: f nixpkgs.legacyPackages.${system});
25 |   in {
26 |     formatter = eachSystem (pkgs: pkgs.alejandra);
27 | 
28 |     devShells = eachSystem (pkgs: {
29 |       default = pkgs.mkShell {
30 |         name = "walker";
31 |         inputsFrom = [self.packages.${pkgs.stdenv.system}.walker];
32 |       };
33 |     });
34 | 
35 |     packages = eachSystem (pkgs: {
36 |       default = self.packages.${pkgs.stdenv.system}.walker;
37 |       walker = pkgs.callPackage ./nix/package.nix {};
38 |     });
39 | 
40 |     homeManagerModules = {
41 |       default = self.homeManagerModules.walker;
42 |       walker = import ./nix/modules/home-manager.nix {inherit self elephant;};
43 |     };
44 | 
45 |     nixosModules = {
46 |       default = self.nixosModules.walker;
47 |       walker = import ./nix/modules/nixos.nix {inherit self elephant;};
48 |     };
49 | 
50 |     nixConfig = {
51 |       extra-substituters = ["https://walker-git.cachix.org"];
52 |       extra-trusted-public-keys = ["walker-git.cachix.org-1:vmC0ocfPWh0S/vRAQGtChuiZBTAe4wiKDeyyXM0/7pM="];
53 |     };
54 |   };
55 | }
56 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_dmenu.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkBox" id="ItemTextBox">
12 |         <style>
13 |           <class name="item-text-box"></class>
14 |         </style>
15 |         <property name="orientation">vertical</property>
16 |         <property name="hexpand">true</property>
17 |         <property name="vexpand">true</property>
18 |         <property name="vexpand-set">true</property>
19 |         <property name="spacing">0</property>
20 |         <child>
21 |           <object class="GtkLabel" id="ItemText">
22 |             <style>
23 |               <class name="item-text"></class>
24 |             </style>
25 |             <property name="vexpand">true</property>
26 |             <property name="xalign">0</property>
27 |             <property name="lines">1</property>
28 |             <property name="ellipsize">3</property>
29 |             <property name="single-line-mode">true</property>
30 |           </object>
31 |         </child>
32 |       </object>
33 |     </child>
34 |     <child>
35 |       <object class="GtkLabel" id="QuickActivation">
36 |         <style>
37 |           <class name="item-quick-activation"></class>
38 |         </style>
39 |         <property name="wrap">false</property>
40 |         <property name="valign">center</property>
41 |         <property name="xalign">0</property>
42 |         <property name="yalign">0.5</property>
43 |       </object>
44 |     </child>
45 |   </object>
46 | </interface>
47 | 


--------------------------------------------------------------------------------
/src/providers/clipboard.rs:
--------------------------------------------------------------------------------
 1 | use chrono::DateTime;
 2 | 
 3 | use crate::{
 4 |     config::get_config, protos::generated_proto::query::query_response::Item, providers::Provider,
 5 | };
 6 | 
 7 | #[derive(Debug)]
 8 | pub struct Clipboard {
 9 |     name: &'static str,
10 | }
11 | 
12 | impl Clipboard {
13 |     pub fn new() -> Self {
14 |         Self { name: "clipboard" }
15 |     }
16 | }
17 | 
18 | impl Provider for Clipboard {
19 |     fn get_name(&self) -> &str {
20 |         self.name
21 |     }
22 | 
23 |     fn get_item_layout(&self) -> String {
24 |         include_str!("../../resources/themes/default/item_clipboard.xml").to_string()
25 |     }
26 | 
27 |     fn text_transformer(&self, item: &Item, label: &gtk4::Label) {
28 |         if !item.icon.is_empty() {
29 |             let Ok(dt) = DateTime::parse_from_rfc2822(&item.subtext) else {
30 |                 label.set_label(&item.subtext);
31 |                 return;
32 |             };
33 | 
34 |             let formatted = dt
35 |                 .format(&get_config().providers.clipboard.time_format)
36 |                 .to_string();
37 |             label.set_label(&formatted);
38 | 
39 |             return;
40 |         }
41 | 
42 |         label.set_label(item.text.trim());
43 |     }
44 | 
45 |     fn subtext_transformer(&self, item: &Item, label: &gtk4::Label) {
46 |         if !item.icon.is_empty() {
47 |             label.set_label("Image");
48 |             return;
49 |         }
50 | 
51 |         let Ok(dt) = DateTime::parse_from_rfc2822(&item.subtext) else {
52 |             label.set_label(&item.subtext);
53 |             return;
54 |         };
55 | 
56 |         let formatted = dt
57 |             .format(&get_config().providers.clipboard.time_format)
58 |             .to_string();
59 |         label.set_label(&formatted);
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/flake.lock:
--------------------------------------------------------------------------------
 1 | {
 2 |   "nodes": {
 3 |     "elephant": {
 4 |       "inputs": {
 5 |         "nixpkgs": [
 6 |           "nixpkgs"
 7 |         ],
 8 |         "systems": [
 9 |           "systems"
10 |         ]
11 |       },
12 |       "locked": {
13 |         "lastModified": 1759675127,
14 |         "narHash": "sha256-AsYUdOukKNXIu47CpQNJeAccu524sIj9UTuP9Aadycs=",
15 |         "owner": "abenz1267",
16 |         "repo": "elephant",
17 |         "rev": "abfa18c844f1028b0b2beef456fee6d40e98dfad",
18 |         "type": "github"
19 |       },
20 |       "original": {
21 |         "owner": "abenz1267",
22 |         "repo": "elephant",
23 |         "type": "github"
24 |       }
25 |     },
26 |     "nixpkgs": {
27 |       "locked": {
28 |         "lastModified": 1757068644,
29 |         "narHash": "sha256-NOrUtIhTkIIumj1E/Rsv1J37Yi3xGStISEo8tZm3KW4=",
30 |         "owner": "NixOS",
31 |         "repo": "nixpkgs",
32 |         "rev": "8eb28adfa3dc4de28e792e3bf49fcf9007ca8ac9",
33 |         "type": "github"
34 |       },
35 |       "original": {
36 |         "owner": "NixOS",
37 |         "ref": "nixos-unstable",
38 |         "repo": "nixpkgs",
39 |         "type": "github"
40 |       }
41 |     },
42 |     "root": {
43 |       "inputs": {
44 |         "elephant": "elephant",
45 |         "nixpkgs": "nixpkgs",
46 |         "systems": "systems"
47 |       }
48 |     },
49 |     "systems": {
50 |       "locked": {
51 |         "lastModified": 1689347949,
52 |         "narHash": "sha256-12tWmuL2zgBgZkdoB6qXZsgJEH9LR3oUgpaQq2RbI80=",
53 |         "owner": "nix-systems",
54 |         "repo": "default-linux",
55 |         "rev": "31732fcf5e8fea42e59c2488ad31a0e651500f68",
56 |         "type": "github"
57 |       },
58 |       "original": {
59 |         "owner": "nix-systems",
60 |         "repo": "default-linux",
61 |         "type": "github"
62 |       }
63 |     }
64 |   },
65 |   "root": "root",
66 |   "version": 7
67 | }
68 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_symbols.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkLabel" id="ItemImage">
12 |         <style>
13 |           <class name="item-image"></class>
14 |         </style>
15 |         <property name="width-chars">3</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkBox" id="ItemTextBox">
20 |         <style>
21 |           <class name="item-text-box"></class>
22 |         </style>
23 |         <property name="orientation">vertical</property>
24 |         <property name="hexpand">true</property>
25 |         <property name="vexpand">true</property>
26 |         <property name="vexpand-set">true</property>
27 |         <property name="spacing">0</property>
28 |         <child>
29 |           <object class="GtkLabel" id="ItemText">
30 |             <style>
31 |               <class name="item-text"></class>
32 |             </style>
33 |             <property name="wrap">false</property>
34 |             <property name="vexpand_set">true</property>
35 |             <property name="vexpand">true</property>
36 |             <property name="xalign">0</property>
37 |           </object>
38 |         </child>
39 |       </object>
40 |     </child>
41 |     <child>
42 |       <object class="GtkLabel" id="QuickActivation">
43 |         <style>
44 |           <class name="item-quick-activation"></class>
45 |         </style>
46 |         <property name="wrap">false</property>
47 |         <property name="valign">center</property>
48 |         <property name="xalign">0</property>
49 |         <property name="yalign">0.5</property>
50 |       </object>
51 |     </child>
52 |   </object>
53 | </interface>
54 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_unicode.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkLabel" id="ItemImage">
12 |         <style>
13 |           <class name="item-image"></class>
14 |         </style>
15 |         <property name="width-chars">3</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkBox" id="ItemTextBox">
20 |         <style>
21 |           <class name="item-text-box"></class>
22 |         </style>
23 |         <property name="orientation">vertical</property>
24 |         <property name="hexpand">true</property>
25 |         <property name="vexpand">true</property>
26 |         <property name="vexpand-set">true</property>
27 |         <property name="spacing">0</property>
28 |         <child>
29 |           <object class="GtkLabel" id="ItemText">
30 |             <style>
31 |               <class name="item-text"></class>
32 |             </style>
33 |             <property name="wrap">false</property>
34 |             <property name="vexpand_set">true</property>
35 |             <property name="vexpand">true</property>
36 |             <property name="xalign">0</property>
37 |           </object>
38 |         </child>
39 |       </object>
40 |     </child>
41 |     <child>
42 |       <object class="GtkLabel" id="QuickActivation">
43 |         <style>
44 |           <class name="item-quick-activation"></class>
45 |         </style>
46 |         <property name="wrap">false</property>
47 |         <property name="valign">center</property>
48 |         <property name="xalign">0</property>
49 |         <property name="yalign">0.5</property>
50 |       </object>
51 |     </child>
52 |   </object>
53 | </interface>
54 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_files.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkImage" id="ItemImage">
12 |         <style>
13 |           <class name="item-image"></class>
14 |         </style>
15 |         <property name="icon-size">large</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkBox" id="ItemTextBox">
20 |         <style>
21 |           <class name="item-text-box"></class>
22 |         </style>
23 |         <property name="orientation">vertical</property>
24 |         <property name="hexpand">true</property>
25 |         <property name="vexpand">true</property>
26 |         <property name="vexpand-set">true</property>
27 |         <property name="spacing">0</property>
28 |         <child>
29 |           <object class="GtkLabel" id="ItemText">
30 |             <style>
31 |               <class name="item-text"></class>
32 |             </style>
33 |             <property name="wrap">false</property>
34 |             <property name="vexpand_set">true</property>
35 |             <property name="vexpand">true</property>
36 |             <property name="xalign">0</property>
37 |             <property name="ellipsize">1</property>
38 |           </object>
39 |         </child>
40 |       </object>
41 |     </child>
42 |     <child>
43 |       <object class="GtkLabel" id="QuickActivation">
44 |         <style>
45 |           <class name="item-quick-activation"></class>
46 |         </style>
47 |         <property name="wrap">false</property>
48 |         <property name="valign">center</property>
49 |         <property name="xalign">0</property>
50 |         <property name="yalign">0.5</property>
51 |       </object>
52 |     </child>
53 |   </object>
54 | </interface>
55 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_todo.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkImage" id="ItemImage">
12 |         <style>
13 |           <class name="item-image"></class>
14 |         </style>
15 |         <property name="pixel-size">48</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkBox" id="ItemTextBox">
20 |         <style>
21 |           <class name="item-text-box"></class>
22 |         </style>
23 |         <property name="orientation">vertical</property>
24 |         <property name="vexpand">true</property>
25 |         <property name="vexpand-set">true</property>
26 |         <property name="spacing">0</property>
27 |         <child>
28 |           <object class="GtkLabel" id="ItemText">
29 |             <style>
30 |               <class name="item-text"></class>
31 |             </style>
32 |             <property name="wrap">true</property>
33 |             <property name="vexpand_set">true</property>
34 |             <property name="vexpand">true</property>
35 |             <property name="hexpand">true</property>
36 |             <property name="xalign">0</property>
37 |           </object>
38 |         </child>
39 |         <child>
40 |           <object class="GtkLabel" id="ItemSubtext">
41 |             <style>
42 |               <class name="item-subtext"></class>
43 |             </style>
44 |             <property name="wrap">true</property>
45 |             <property name="vexpand_set">true</property>
46 |             <property name="vexpand">true</property>
47 |             <property name="xalign">0</property>
48 |             <property name="yalign">0</property>
49 |           </object>
50 |         </child>
51 |       </object>
52 |     </child>
53 |   </object>
54 | </interface>
55 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_archlinuxpkgs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkBox" id="ItemTextBox">
12 |         <style>
13 |           <class name="item-text-box"></class>
14 |         </style>
15 |         <property name="orientation">vertical</property>
16 |         <property name="vexpand">true</property>
17 |         <property name="hexpand">true</property>
18 |         <property name="vexpand-set">true</property>
19 |         <property name="spacing">0</property>
20 |         <child>
21 |           <object class="GtkLabel" id="ItemText">
22 |             <style>
23 |               <class name="item-text"></class>
24 |             </style>
25 |             <property name="wrap">false</property>
26 |             <property name="vexpand_set">true</property>
27 |             <property name="vexpand">true</property>
28 |             <property name="xalign">0</property>
29 |           </object>
30 |         </child>
31 |         <child>
32 |           <object class="GtkLabel" id="ItemSubtext">
33 |             <style>
34 |               <class name="item-subtext"></class>
35 |             </style>
36 |             <property name="wrap">true</property>
37 |             <property name="vexpand_set">true</property>
38 |             <property name="vexpand">true</property>
39 |             <property name="xalign">0</property>
40 |             <property name="yalign">0</property>
41 |           </object>
42 |         </child>
43 |       </object>
44 |     </child>
45 |     <child>
46 |       <object class="GtkLabel" id="QuickActivation">
47 |         <style>
48 |           <class name="item-quick-activation"></class>
49 |         </style>
50 |         <property name="wrap">false</property>
51 |         <property name="valign">center</property>
52 |         <property name="xalign">0</property>
53 |         <property name="yalign">0.5</property>
54 |       </object>
55 |     </child>
56 |   </object>
57 | </interface>
58 | 


--------------------------------------------------------------------------------
/src/preview/mod.rs:
--------------------------------------------------------------------------------
 1 | mod files_preview;
 2 | mod clipboard_preview;
 3 | 
 4 | use crate::config::get_config;
 5 | use crate::protos::generated_proto::query::query_response::Item;
 6 | pub use files_preview::FilesPreviewHandler;
 7 | pub use clipboard_preview::ClipboardPreviewHandler;
 8 | use gtk4::{Box as GtkBox, Builder};
 9 | use std::cell::LazyCell;
10 | use std::collections::HashMap;
11 | use std::fmt::Debug;
12 | 
13 | pub trait PreviewHandler: Debug {
14 |     fn handle(&self, item: &Item, preview: &GtkBox, builder: &Builder);
15 |     fn clear_cache(&self) {}
16 | }
17 | 
18 | thread_local! {
19 |     static PREVIEWERS: LazyCell<HashMap<String, Box<dyn PreviewHandler>>> = LazyCell::new(|| {
20 |         let mut previewers: HashMap<String, Box<dyn PreviewHandler>> = HashMap::new();
21 | 
22 |         get_config().providers.previews.iter().for_each(|p| {
23 |             let b: Option<Box<dyn PreviewHandler>> = match p.as_str() {
24 |                 "files"|"menus" => {
25 |                     Some(Box::new(FilesPreviewHandler::new()))
26 |                 },
27 |                 "clipboard" => {
28 |                     Some(Box::new(ClipboardPreviewHandler::new()))
29 |                 },
30 |                 _ => {
31 |                     None
32 |                 }
33 |             };
34 | 
35 |             if let Some(b) = b {
36 |                 previewers.insert(p.to_string(), b);
37 |             } else {
38 |                 eprintln!("preview not implemented for {}", p);
39 |             }
40 |         });
41 | 
42 |         previewers
43 |     });
44 | }
45 | 
46 | pub fn get_previewer<F, R>(provider: &str, f: F) -> Option<R>
47 | where
48 |     F: FnOnce(&dyn PreviewHandler) -> R,
49 | {
50 |     PREVIEWERS.with(|previewers| previewers.get(provider).map(Box::as_ref).map(f))
51 | }
52 | 
53 | pub fn handle_preview(provider: &str, item: &Item, preview: &GtkBox, builder: &Builder) {
54 |     get_previewer(provider, |handler| handler.handle(item, preview, builder));
55 | }
56 | 
57 | pub fn has_previewer(provider: &str) -> bool {
58 |     PREVIEWERS.with(|previewers| previewers.contains_key(provider))
59 | }
60 | 
61 | pub fn clear_all_caches() {
62 |     PREVIEWERS.with(|previewers| {
63 |         for handler in previewers.values() {
64 |             handler.clear_cache();
65 |         }
66 |     });
67 | }
68 | 


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | PREFIX ?= /usr/local
 2 | DESTDIR ?=
 3 | BINDIR = $(DESTDIR)$(PREFIX)/bin
 4 | LICENSEDIR = $(DESTDIR)$(PREFIX)/share/licenses/walker
 5 | CONFIGDIR = $(DESTDIR)/etc/xdg/walker
 6 | THEMEDIR = $(CONFIGDIR)/themes/default
 7 | 
 8 | CARGO_TARGET_DIR ?= target
 9 | RUSTUP_TOOLCHAIN ?= stable
10 | 
11 | .PHONY: all build install uninstall clean
12 | 
13 | all: build
14 | 
15 | build:
16 | 	export RUSTUP_TOOLCHAIN=$(RUSTUP_TOOLCHAIN) && \
17 | 	export CARGO_TARGET_DIR=$(CARGO_TARGET_DIR) && \
18 | 	cargo build --release
19 | 
20 | install: build
21 | 	install -Dm 755 $(CARGO_TARGET_DIR)/release/walker $(BINDIR)/walker
22 | 	install -Dm 644 LICENSE $(LICENSEDIR)/LICENSE
23 | 	install -Dm 644 resources/config.toml $(CONFIGDIR)/config.toml
24 | 	install -Dm 644 resources/themes/default/item.xml $(THEMEDIR)/item.xml
25 | 	install -Dm 644 resources/themes/default/item_calc.xml $(THEMEDIR)/item_calc.xml
26 | 	install -Dm 644 resources/themes/default/item_clipboard.xml $(THEMEDIR)/item_clipboard.xml
27 | 	install -Dm 644 resources/themes/default/item_dmenu.xml $(THEMEDIR)/item_dmenu.xml
28 | 	install -Dm 644 resources/themes/default/item_files.xml $(THEMEDIR)/item_files.xml
29 | 	install -Dm 644 resources/themes/default/item_providerlist.xml $(THEMEDIR)/item_providerlist.xml
30 | 	install -Dm 644 resources/themes/default/item_symbols.xml $(THEMEDIR)/item_symbols.xml
31 | 	install -Dm 644 resources/themes/default/layout.xml $(THEMEDIR)/layout.xml
32 | 	install -Dm 644 resources/themes/default/preview.xml $(THEMEDIR)/preview.xml
33 | 	install -Dm 644 resources/themes/default/style.css $(THEMEDIR)/style.css
34 | 
35 | uninstall:
36 | 	rm -f $(BINDIR)/walker
37 | 	rm -rf $(LICENSEDIR)
38 | 	rm -rf $(CONFIGDIR)
39 | 
40 | clean:
41 | 	cargo clean
42 | 
43 | dev-install: PREFIX = /usr/local
44 | dev-install: install
45 | 
46 | help:
47 | 	@echo "Available targets:"
48 | 	@echo "  all       - Build the application (default)"
49 | 	@echo "  build     - Build the application"
50 | 	@echo "  install   - Install the application and resources"
51 | 	@echo "  uninstall - Remove installed files"
52 | 	@echo "  clean     - Clean build artifacts"
53 | 	@echo "  help      - Show this help"
54 | 	@echo ""
55 | 	@echo "Variables:"
56 | 	@echo "  PREFIX    - Installation prefix (default: /usr/local)"
57 | 	@echo "  DESTDIR   - Destination directory for staged installs"
58 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_clipboard.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkBox">
12 |         <property name="orientation">vertical</property>
13 |         <property name="spacing">5</property>
14 |         <child>
15 |           <object class="GtkBox" id="ItemTextBox">
16 |             <style>
17 |               <class name="item-text-box"></class>
18 |             </style>
19 |             <property name="orientation">vertical</property>
20 |             <property name="hexpand">true</property>
21 |             <property name="vexpand">true</property>
22 |             <property name="vexpand-set">true</property>
23 |             <property name="spacing">0</property>
24 |             <child>
25 |               <object class="GtkLabel" id="ItemText">
26 |                 <style>
27 |                   <class name="item-text"></class>
28 |                 </style>
29 |                 <property name="vexpand">true</property>
30 |                 <property name="xalign">0</property>
31 |                 <property name="lines">1</property>
32 |                 <property name="wrap">true</property>
33 |                 <property name="ellipsize">3</property>
34 |                 <property name="single-line-mode">true</property>
35 |               </object>
36 |             </child>
37 |             <child>
38 |               <object class="GtkLabel" id="ItemSubtext">
39 |                 <style>
40 |                   <class name="item-subtext"></class>
41 |                 </style>
42 |                 <property name="xalign">0</property>
43 |               </object>
44 |             </child>
45 |           </object>
46 |         </child>
47 |       </object>
48 |     </child>
49 |     <child>
50 |       <object class="GtkLabel" id="QuickActivation">
51 |         <style>
52 |           <class name="item-quick-activation"></class>
53 |         </style>
54 |         <property name="wrap">false</property>
55 |         <property name="valign">center</property>
56 |         <property name="xalign">0</property>
57 |         <property name="yalign">0.5</property>
58 |       </object>
59 |     </child>
60 |   </object>
61 | </interface>
62 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_calc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkImage" id="ItemImage">
12 |         <style>
13 |           <class name="item-image"></class>
14 |         </style>
15 |         <property name="pixel-size">48</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkBox" id="ItemTextBox">
20 |         <style>
21 |           <class name="item-text-box"></class>
22 |         </style>
23 |         <property name="orientation">vertical</property>
24 |         <property name="hexpand">true</property>
25 |         <property name="vexpand">true</property>
26 |         <property name="vexpand-set">true</property>
27 |         <property name="spacing">0</property>
28 |         <child>
29 |           <object class="GtkLabel" id="ItemText">
30 |             <style>
31 |               <class name="item-text"></class>
32 |             </style>
33 |             <property name="wrap">false</property>
34 |             <property name="vexpand_set">true</property>
35 |             <property name="vexpand">true</property>
36 |             <property name="xalign">0</property>
37 |           </object>
38 |         </child>
39 |         <child>
40 |           <object class="GtkLabel" id="ItemSubtext">
41 |             <style>
42 |               <class name="item-subtext"></class>
43 |             </style>
44 |             <property name="wrap">true</property>
45 |             <property name="vexpand_set">true</property>
46 |             <property name="vexpand">true</property>
47 |             <property name="xalign">0</property>
48 |             <property name="yalign">0</property>
49 |           </object>
50 |         </child>
51 |       </object>
52 |     </child>
53 |     <child>
54 |       <object class="GtkLabel" id="QuickActivation">
55 |         <style>
56 |           <class name="item-quick-activation"></class>
57 |         </style>
58 |         <property name="wrap">false</property>
59 |         <property name="valign">center</property>
60 |         <property name="xalign">0</property>
61 |         <property name="yalign">0.5</property>
62 |       </object>
63 |     </child>
64 |   </object>
65 | </interface>
66 | 


--------------------------------------------------------------------------------
/resources/themes/default/item.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkLabel" id="ItemImageFont">
12 |         <style>
13 |           <class name="item-image-text"></class>
14 |         </style>
15 |         <property name="width-chars">2</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkImage" id="ItemImage">
20 |         <style>
21 |           <class name="item-image"></class>
22 |         </style>
23 |         <property name="icon-size">large</property>
24 |       </object>
25 |     </child>
26 |     <child>
27 |       <object class="GtkBox" id="ItemTextBox">
28 |         <style>
29 |           <class name="item-text-box"></class>
30 |         </style>
31 |         <property name="orientation">vertical</property>
32 |         <property name="vexpand">true</property>
33 |         <property name="hexpand">true</property>
34 |         <property name="vexpand-set">true</property>
35 |         <property name="spacing">0</property>
36 |         <child>
37 |           <object class="GtkLabel" id="ItemText">
38 |             <style>
39 |               <class name="item-text"></class>
40 |             </style>
41 |             <property name="ellipsize">end</property>
42 |             <property name="vexpand_set">true</property>
43 |             <property name="vexpand">true</property>
44 |             <property name="xalign">0</property>
45 |           </object>
46 |         </child>
47 |         <child>
48 |           <object class="GtkLabel" id="ItemSubtext">
49 |             <style>
50 |               <class name="item-subtext"></class>
51 |             </style>
52 |             <property name="ellipsize">end</property>
53 |             <property name="vexpand_set">true</property>
54 |             <property name="vexpand">true</property>
55 |             <property name="xalign">0</property>
56 |             <property name="yalign">0</property>
57 |           </object>
58 |         </child>
59 |       </object>
60 |     </child>
61 |     <child>
62 |       <object class="GtkLabel" id="QuickActivation">
63 |         <style>
64 |           <class name="item-quick-activation"></class>
65 |         </style>
66 |         <property name="wrap">false</property>
67 |         <property name="valign">center</property>
68 |         <property name="xalign">0</property>
69 |         <property name="yalign">0.5</property>
70 |       </object>
71 |     </child>
72 |   </object>
73 | </interface>
74 | 


--------------------------------------------------------------------------------
/resources/themes/default/item_providerlist.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <interface>
 3 |   <requires lib="gtk" version="4.0"></requires>
 4 |   <object class="GtkBox" id="ItemBox">
 5 |     <style>
 6 |       <class name="item-box"></class>
 7 |     </style>
 8 |     <property name="orientation">horizontal</property>
 9 |     <property name="spacing">10</property>
10 |     <child>
11 |       <object class="GtkLabel" id="ItemImageFont">
12 |         <style>
13 |           <class name="item-image-text"></class>
14 |         </style>
15 |         <property name="width-chars">2</property>
16 |       </object>
17 |     </child>
18 |     <child>
19 |       <object class="GtkImage" id="ItemImage">
20 |         <style>
21 |           <class name="item-image"></class>
22 |         </style>
23 |         <property name="icon-size">large</property>
24 |       </object>
25 |     </child>
26 |     <child>
27 |       <object class="GtkBox" id="ItemTextBox">
28 |         <style>
29 |           <class name="item-text-box"></class>
30 |         </style>
31 |         <property name="orientation">horizontal</property>
32 |         <property name="hexpand">true</property>
33 |         <property name="vexpand">true</property>
34 |         <property name="vexpand-set">true</property>
35 |         <property name="spacing">5</property>
36 |         <child>
37 |           <object class="GtkLabel" id="ItemText">
38 |             <style>
39 |               <class name="item-text"></class>
40 |             </style>
41 |             <property name="wrap">false</property>
42 |             <property name="vexpand_set">true</property>
43 |             <property name="vexpand">true</property>
44 |             <property name="xalign">0</property>
45 |           </object>
46 |         </child>
47 |         <child>
48 |           <object class="GtkLabel" id="ItemSubtext">
49 |             <style>
50 |               <class name="item-subtext"></class>
51 |             </style>
52 |             <property name="ellipsize">end</property>
53 |             <property name="vexpand_set">true</property>
54 |             <property name="vexpand">true</property>
55 |             <property name="xalign">0</property>
56 |             <property name="yalign">0.5</property>
57 |           </object>
58 |         </child>
59 |       </object>
60 |     </child>
61 |     <child>
62 |       <object class="GtkLabel" id="QuickActivation">
63 |         <style>
64 |           <class name="item-quick-activation"></class>
65 |         </style>
66 |         <property name="wrap">false</property>
67 |         <property name="valign">center</property>
68 |         <property name="xalign">0</property>
69 |         <property name="yalign">0.5</property>
70 |       </object>
71 |     </child>
72 |   </object>
73 | </interface>
74 | 


--------------------------------------------------------------------------------
/resources/themes/default/style.css:
--------------------------------------------------------------------------------
  1 | @define-color window_bg_color #1f1f28;
  2 | @define-color accent_bg_color #54546d;
  3 | @define-color theme_fg_color #f2ecbc;
  4 | @define-color error_bg_color #C34043;
  5 | @define-color error_fg_color #DCD7BA;
  6 | 
  7 | * {
  8 |   all: unset;
  9 | }
 10 | 
 11 | .normal-icons {
 12 |   -gtk-icon-size: 16px;
 13 | }
 14 | 
 15 | .large-icons {
 16 |   -gtk-icon-size: 32px;
 17 | }
 18 | 
 19 | scrollbar {
 20 |   opacity: 0;
 21 | }
 22 | 
 23 | .box-wrapper {
 24 |   box-shadow:
 25 |     0 19px 38px rgba(0, 0, 0, 0.3),
 26 |     0 15px 12px rgba(0, 0, 0, 0.22);
 27 |   background: @window_bg_color;
 28 |   padding: 20px;
 29 |   border-radius: 20px;
 30 |   border: 1px solid darker(@accent_bg_color);
 31 | }
 32 | 
 33 | .preview-box,
 34 | .elephant-hint,
 35 | .placeholder {
 36 |   color: @theme_fg_color;
 37 | }
 38 | 
 39 | .box {
 40 | }
 41 | 
 42 | .search-container {
 43 |   border-radius: 10px;
 44 | }
 45 | 
 46 | .input placeholder {
 47 |   opacity: 0.5;
 48 | }
 49 | 
 50 | .input {
 51 |   caret-color: @theme_fg_color;
 52 |   background: lighter(@window_bg_color);
 53 |   padding: 10px;
 54 |   color: @theme_fg_color;
 55 | }
 56 | 
 57 | .input:focus,
 58 | .input:active {
 59 | }
 60 | 
 61 | .content-container {
 62 | }
 63 | 
 64 | .placeholder {
 65 | }
 66 | 
 67 | .scroll {
 68 | }
 69 | 
 70 | .list {
 71 |   color: @theme_fg_color;
 72 | }
 73 | 
 74 | child {
 75 | }
 76 | 
 77 | .item-box {
 78 |   border-radius: 10px;
 79 |   padding: 10px;
 80 | }
 81 | 
 82 | .item-quick-activation {
 83 |   background: alpha(@accent_bg_color, 0.25);
 84 |   border-radius: 5px;
 85 |   padding: 10px;
 86 | }
 87 | 
 88 | child:hover .item-box,
 89 | child:selected .item-box {
 90 |   background: alpha(@accent_bg_color, 0.25);
 91 | }
 92 | 
 93 | .item-text-box {
 94 | }
 95 | 
 96 | .item-subtext {
 97 |   font-size: 12px;
 98 |   opacity: 0.5;
 99 | }
100 | 
101 | .providerlist .item-subtext {
102 |   font-size: unset;
103 |   opacity: 0.75;
104 | }
105 | 
106 | .item-image-text {
107 |   font-size: 28px;
108 | }
109 | 
110 | .preview {
111 |   border: 1px solid alpha(@accent_bg_color, 0.25);
112 |   padding: 10px;
113 |   border-radius: 10px;
114 |   color: @theme_fg_color;
115 | }
116 | 
117 | .calc .item-text {
118 |   font-size: 24px;
119 | }
120 | 
121 | .calc .item-subtext {
122 | }
123 | 
124 | .symbols .item-image {
125 |   font-size: 24px;
126 | }
127 | 
128 | .todo.done .item-text-box {
129 |   opacity: 0.25;
130 | }
131 | 
132 | .todo.urgent {
133 |   font-size: 24px;
134 | }
135 | 
136 | .todo.active {
137 |   font-weight: bold;
138 | }
139 | 
140 | .bluetooth.disconnected {
141 |   opacity: 0.5;
142 | }
143 | 
144 | .preview .large-icons {
145 |   -gtk-icon-size: 64px;
146 | }
147 | 
148 | .keybinds-wrapper {
149 |   border-top: 1px solid lighter(@window_bg_color);
150 |   font-size: 12px;
151 |   opacity: 0.5;
152 |   color: @theme_fg_color;
153 | }
154 | 
155 | .keybinds {
156 | }
157 | 
158 | .keybind {
159 | }
160 | 
161 | .keybind-bind {
162 |   /* color: lighter(@window_bg_color); */
163 |   font-weight: bold;
164 |   text-transform: lowercase;
165 | }
166 | 
167 | .keybind-label {
168 | }
169 | 
170 | .error {
171 |   padding: 10px;
172 |   background: @error_bg_color;
173 |   color: @error_fg_color;
174 | }
175 | 
176 | :not(.calc).current {
177 |   font-style: italic;
178 | }
179 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
  1 | name: Release
  2 | 
  3 | on:
  4 |   push:
  5 |     tags:
  6 |       - 'v*'
  7 | 
  8 | permissions:
  9 |   contents: write
 10 | 
 11 | jobs:
 12 |   build-x86_64:
 13 |     runs-on: ubuntu-latest
 14 |     steps:
 15 |     - uses: actions/checkout@v4
 16 | 
 17 |     - name: Install system dependencies
 18 |       run: |
 19 |         sudo apt-get update
 20 |         sudo apt-get install -y \
 21 |           libgtk-4-dev \
 22 |           protobuf-compiler \
 23 |           meson \
 24 |           ninja-build \
 25 |           libwayland-dev \
 26 |           wayland-protocols \
 27 |           gobject-introspection \
 28 |           libgirepository1.0-dev \
 29 |           gtk-doc-tools \
 30 |           libpoppler-glib-dev \
 31 |           valac
 32 | 
 33 |         # Install gtk4-layer-shell from source
 34 |         git clone https://github.com/wmww/gtk4-layer-shell.git /tmp/gtk4-layer-shell
 35 |         cd /tmp/gtk4-layer-shell
 36 |         meson setup build --prefix=/usr
 37 |         ninja -C build
 38 |         sudo ninja -C build install
 39 |         sudo ldconfig
 40 | 
 41 |     - name: Install Rust
 42 |       uses: dtolnay/rust-toolchain@stable
 43 | 
 44 |     - name: Build
 45 |       run: cargo build --release --target x86_64-unknown-linux-gnu
 46 | 
 47 |     - name: Strip binary
 48 |       run: strip target/x86_64-unknown-linux-gnu/release/walker
 49 | 
 50 |     - name: Create archive
 51 |       run: |
 52 |         cd target/x86_64-unknown-linux-gnu/release
 53 |         tar -czf walker-${{ github.ref_name }}-x86_64-unknown-linux-gnu.tar.gz walker
 54 |         mv walker-${{ github.ref_name }}-x86_64-unknown-linux-gnu.tar.gz ../../../
 55 | 
 56 |     - name: Upload artifact
 57 |       uses: actions/upload-artifact@v4
 58 |       with:
 59 |         name: walker-x86_64-unknown-linux-gnu
 60 |         path: walker-${{ github.ref_name }}-x86_64-unknown-linux-gnu.tar.gz
 61 | 
 62 |   release:
 63 |     needs: [build-x86_64]
 64 |     runs-on: ubuntu-latest
 65 |     steps:
 66 |     - uses: actions/checkout@v4
 67 |       with:
 68 |         fetch-depth: 0
 69 | 
 70 |     - name: Download all artifacts
 71 |       uses: actions/download-artifact@v4
 72 | 
 73 |     - name: Generate changelog
 74 |       run: |
 75 |         # Get previous tag
 76 |         PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
 77 | 
 78 |         # Generate changelog
 79 |         echo "# Changes in ${{ github.ref_name }}" > CHANGELOG.md
 80 |         echo "" >> CHANGELOG.md
 81 | 
 82 |         if [ -n "$PREV_TAG" ]; then
 83 |           echo "## Commits since $PREV_TAG:" >> CHANGELOG.md
 84 |           git log --pretty=format:"- %s (%h)" $PREV_TAG..HEAD >> CHANGELOG.md
 85 |         else
 86 |           echo "## All commits:" >> CHANGELOG.md
 87 |           git log --pretty=format:"- %s (%h)" >> CHANGELOG.md
 88 |         fi
 89 | 
 90 |         if [ -f "BREAKING.md" ]; then
 91 |           echo "" >> CHANGELOG.md
 92 |           echo "## ⚠️ Breaking Changes" >> CHANGELOG.md
 93 |           echo "" >> CHANGELOG.md
 94 |           cat BREAKING.md >> CHANGELOG.md
 95 |           echo "" >> CHANGELOG.md
 96 |         fi
 97 | 
 98 |     - name: Create release
 99 |       uses: softprops/action-gh-release@v1
100 |       with:
101 |         files: |
102 |           walker-x86_64-unknown-linux-gnu/walker-${{ github.ref_name }}-x86_64-unknown-linux-gnu.tar.gz
103 |         body_path: CHANGELOG.md
104 |         draft: false
105 |         prerelease: ${{ contains(github.ref_name, 'beta') || contains(github.ref_name, 'alpha') || contains(github.ref_name, 'rc') }}
106 |       env:
107 |         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
108 | 


--------------------------------------------------------------------------------
/src/renderers/mod.rs:
--------------------------------------------------------------------------------
  1 | use crate::config::get_config;
  2 | use crate::protos::generated_proto::query::query_response::Item;
  3 | use crate::providers::PROVIDERS;
  4 | use crate::state::{get_dmenu_current, is_hide_qa, set_error};
  5 | use crate::theme::{Theme, with_themes};
  6 | use crate::ui::window::{quit, with_window};
  7 | use gtk4::gdk::ContentProvider;
  8 | use gtk4::gio::File;
  9 | use gtk4::gio::prelude::FileExt;
 10 | use gtk4::prelude::{ListItemExt, WidgetExt};
 11 | use gtk4::{Box, Builder, DragSource, Label, ListItem, glib};
 12 | use std::path::Path;
 13 | 
 14 | pub fn create_item(list_item: &ListItem, item: &Item, theme: &Theme) {
 15 |     let mut b = Builder::new();
 16 | 
 17 |     let _ = b.add_from_string(
 18 |         theme
 19 |             .items
 20 |             .get(&item.provider)
 21 |             .expect("failed to get item layout"),
 22 |     );
 23 | 
 24 |     let itembox: Box = match b.object("ItemBox") {
 25 |         Some(w) => w,
 26 |         None => {
 27 |             set_error("Theme: missing 'ItemBox' object".to_string());
 28 | 
 29 |             b = Builder::new();
 30 | 
 31 |             with_themes(|t| {
 32 |                 let theme = t.get("default").unwrap();
 33 |                 let _ = b.add_from_string(
 34 |                     theme
 35 |                         .items
 36 |                         .get(&item.provider)
 37 |                         .expect("failed to get item layout"),
 38 |                 );
 39 |             });
 40 | 
 41 |             b.object("ItemBox").unwrap()
 42 |         }
 43 |     };
 44 | 
 45 |     itembox.add_css_class(&item.provider.replace("menus:", "menus-"));
 46 | 
 47 |     item.state
 48 |         .iter()
 49 |         .filter(|i| !i.is_empty())
 50 |         .for_each(|i| itembox.add_css_class(i));
 51 | 
 52 |     if get_dmenu_current() != 0 && get_dmenu_current() as u32 == list_item.position() + 1 {
 53 |         itembox.add_css_class("current");
 54 |     }
 55 | 
 56 |     list_item.set_child(Some(&itembox));
 57 | 
 58 |     if Path::new(&item.text).is_absolute() {
 59 |         itembox.add_controller(create_drag_source(&item.text));
 60 |     }
 61 | 
 62 |     let p = PROVIDERS.get().unwrap().get(&item.provider).unwrap();
 63 | 
 64 |     if let Some(text) = b.object::<Label>("ItemText") {
 65 |         p.text_transformer(&item, &text);
 66 |     }
 67 | 
 68 |     if let Some(text) = b.object::<Label>("ItemSubtext") {
 69 |         p.subtext_transformer(item, &text);
 70 |     }
 71 | 
 72 |     p.image_transformer(&b, list_item, item);
 73 | 
 74 |     if let Some(text) = b.object::<Label>("QuickActivation") {
 75 |         if is_hide_qa() {
 76 |             text.set_visible(false);
 77 |             return;
 78 |         }
 79 | 
 80 |         if let Some(qa) = &get_config().keybinds.quick_activate {
 81 |             let i = list_item.position();
 82 | 
 83 |             if let Some(val) = qa.get(i as usize) {
 84 |                 text.set_label(val);
 85 |             } else {
 86 |                 text.set_visible(false);
 87 |             }
 88 |         }
 89 |     }
 90 | }
 91 | 
 92 | pub fn create_drag_source(text: &str) -> DragSource {
 93 |     let drag_source = DragSource::new();
 94 |     let text = text.to_string();
 95 | 
 96 |     drag_source.connect_prepare(move |_, _, _| {
 97 |         let file = File::for_path(&text);
 98 |         let uri_string = format!("{}\n", file.uri());
 99 |         let b = glib::Bytes::from(uri_string.as_bytes());
100 | 
101 |         let cp = ContentProvider::for_bytes("text/uri-list", &b);
102 |         Some(cp)
103 |     });
104 | 
105 |     drag_source.connect_drag_begin(|_, _| with_window(|w| w.window.set_visible(false)));
106 |     drag_source.connect_drag_end(|_, _, _| with_window(|w| quit(&w.app, false)));
107 |     drag_source
108 | }
109 | 


--------------------------------------------------------------------------------
/resources/themes/default/layout.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <interface>
  3 |   <requires lib="gtk" version="4.0"></requires>
  4 |   <object class="GtkWindow" id="Window">
  5 |     <style>
  6 |       <class name="window"></class>
  7 |     </style>
  8 |     <property name="resizable">true</property>
  9 |     <property name="title">Walker</property>
 10 |     <child>
 11 |       <object class="GtkBox" id="BoxWrapper">
 12 |         <style>
 13 |           <class name="box-wrapper"></class>
 14 |         </style>
 15 |         <property name="overflow">hidden</property>
 16 |         <property name="orientation">horizontal</property>
 17 |         <property name="valign">center</property>
 18 |         <property name="halign">center</property>
 19 |         <property name="width-request">600</property>
 20 |         <property name="height-request">550</property>
 21 |         <child>
 22 |           <object class="GtkBox" id="Box">
 23 |             <style>
 24 |               <class name="box"></class>
 25 |             </style>
 26 |             <property name="orientation">vertical</property>
 27 |             <property name="hexpand-set">true</property>
 28 |             <property name="hexpand">true</property>
 29 |             <property name="spacing">10</property>
 30 |             <child>
 31 |               <object class="GtkBox" id="SearchContainer">
 32 |                 <style>
 33 |                   <class name="search-container"></class>
 34 |                 </style>
 35 |                 <property name="overflow">hidden</property>
 36 |                 <property name="orientation">horizontal</property>
 37 |                 <property name="halign">fill</property>
 38 |                 <property name="hexpand-set">true</property>
 39 |                 <property name="hexpand">true</property>
 40 |                 <child>
 41 |                   <object class="GtkEntry" id="Input">
 42 |                     <style>
 43 |                       <class name="input"></class>
 44 |                     </style>
 45 |                     <property name="halign">fill</property>
 46 |                     <property name="hexpand-set">true</property>
 47 |                     <property name="hexpand">true</property>
 48 |                   </object>
 49 |                 </child>
 50 |               </object>
 51 |             </child>
 52 |             <child>
 53 |               <object class="GtkBox" id="ContentContainer">
 54 |                 <style>
 55 |                   <class name="content-container"></class>
 56 |                 </style>
 57 |                 <property name="orientation">horizontal</property>
 58 |                 <property name="spacing">10</property>
 59 |                 <child>
 60 |                   <object class="GtkLabel" id="ElephantHint">
 61 |                     <style>
 62 |                       <class name="elephant-hint"></class>
 63 |                     </style>
 64 |                     <property name="label">Waiting for elephant...</property>
 65 |                     <property name="hexpand">true</property>
 66 |                     <property name="vexpand">true</property>
 67 |                     <property name="valign">0.5</property>
 68 |                   </object>
 69 |                 </child>
 70 |                 <child>
 71 |                   <object class="GtkLabel" id="Placeholder">
 72 |                     <style>
 73 |                       <class name="placeholder"></class>
 74 |                     </style>
 75 |                     <property name="label">No Results</property>
 76 |                     <property name="hexpand">true</property>
 77 |                     <property name="vexpand">true</property>
 78 |                     <property name="valign">0.5</property>
 79 |                   </object>
 80 |                 </child>
 81 |                 <child>
 82 |                   <object class="GtkScrolledWindow" id="Scroll">
 83 |                     <style>
 84 |                       <class name="scroll"></class>
 85 |                     </style>
 86 |                     <property name="can_focus">false</property>
 87 |                     <property name="overlay-scrolling">true</property>
 88 |                     <property name="hexpand">true</property>
 89 |                     <property name="vexpand">true</property>
 90 |                     <property name="max-content-width">500</property>
 91 |                     <property name="min-content-width">500</property>
 92 |                     <property name="max-content-height">400</property>
 93 |                     <property name="propagate-natural-height">true</property>
 94 |                     <property name="propagate-natural-width">true</property>
 95 |                     <property name="hscrollbar-policy">automatic</property>
 96 |                     <property name="vscrollbar-policy">automatic</property>
 97 |                     <child>
 98 |                       <object class="GtkGridView" id="List">
 99 |                         <style>
100 |                           <class name="list"></class>
101 |                         </style>
102 |                         <property name="max_columns">1</property>
103 |                         <property name="can_focus">false</property>
104 |                       </object>
105 |                     </child>
106 |                   </object>
107 |                 </child>
108 |                 <child>
109 |                   <object class="GtkBox" id="Preview">
110 |                     <style>
111 |                       <class name="preview"></class>
112 |                     </style>
113 |                   </object>
114 |                 </child>
115 |               </object>
116 |             </child>
117 |             <child>
118 |               <object class="GtkBox" id="KeybindsWrapper">
119 |                 <property name="hexpand">true</property>
120 |                 <style>
121 |                   <class name="keybinds-wrapper"></class>
122 |                 </style>
123 |                 <child>
124 |                   <object class="GtkBox" id="Keybinds">
125 |                     <property name="hexpand">true</property>
126 |                     <property name="halign">end</property>
127 |                     <property name="spacing">10</property>
128 |                     <property name="margin-top">10</property>
129 |                     <style>
130 |                       <class name="keybinds"></class>
131 |                     </style>
132 |                   </object>
133 |                 </child>
134 |               </object>
135 |             </child>
136 |             <child>
137 |               <object class="GtkLabel" id="Error">
138 |                 <style>
139 |                   <class name="error"></class>
140 |                 </style>
141 |                 <property name="xalign">0</property>
142 |                <property name="visible">false</property>
143 |               </object>
144 |             </child>
145 |           </object>
146 |         </child>
147 |       </object>
148 |     </child>
149 |   </object>
150 | </interface>
151 | 


--------------------------------------------------------------------------------
/resources/config.toml:
--------------------------------------------------------------------------------
  1 | force_keyboard_focus = false    # forces keyboard forcus to stay in Walker
  2 | close_when_open = true          # close walker when invoking while already opened
  3 | click_to_close = true           # closes walker if clicking outside of the main content area
  4 | selection_wrap = false          # wrap list if at bottom or top
  5 | global_argument_delimiter = "#" # query: firefox#https://benz.dev => part after delimiter will be ignored when querying. this should be the same as in the elephant config
  6 | exact_search_prefix = "'"       # disable fuzzy searching
  7 | theme = "default"               # theme to use
  8 | disable_mouse = false           # disable mouse (on input and list only)
  9 | debug = false                   # enables debug printing for some stuff, f.e. keybinds
 10 | page_jump_items = 10            # number of items to skip with Page Up/Down
 11 | 
 12 | [shell]
 13 | anchor_top = true
 14 | anchor_bottom = true
 15 | anchor_left = true
 16 | anchor_right = true
 17 | 
 18 | [placeholders]
 19 | "default" = { input = "Search", list = "No Results" } # placeholders for input and empty list, key is the providers name, so f.e. "desktopapplications" or "menus:other"
 20 | 
 21 | [keybinds]
 22 | close = ["Escape"]
 23 | next = ["Down"]
 24 | previous = ["Up"]
 25 | toggle_exact = ["ctrl e"]
 26 | resume_last_query = ["ctrl r"]
 27 | quick_activate = ["F1", "F2", "F3", "F4"]
 28 | page_down = ["Page_Down"]
 29 | page_up = ["Page_Up"]
 30 | 
 31 | [providers]
 32 | default = [
 33 |   "desktopapplications",
 34 |   "calc",
 35 |   "runner",
 36 |   "websearch",
 37 | ] # providers to be queried by default
 38 | empty = ["desktopapplications"] # providers to be queried when query is empty
 39 | previews = [
 40 |   "files",
 41 |   "clipboard",
 42 |   "menus",
 43 | ] # providers that have previews enabled. Caution: not every provider has an implementation for previews
 44 | max_results = 50 # global max results
 45 | 
 46 | [providers.sets] # define your own defaults/empty sets of providers
 47 | [providers.max_results_provider] # define max results per provider in here
 48 | 
 49 | [[providers.prefixes]]
 50 | prefix = ";"
 51 | provider = "providerlist"
 52 | 
 53 | [[providers.prefixes]]
 54 | prefix = ">"
 55 | provider = "runner"
 56 | 
 57 | [[providers.prefixes]]
 58 | prefix = "/"
 59 | provider = "files"
 60 | 
 61 | [[providers.prefixes]]
 62 | prefix = "."
 63 | provider = "symbols"
 64 | 
 65 | [[providers.prefixes]]
 66 | prefix = "!"
 67 | provider = "todo"
 68 | 
 69 | [[providers.prefixes]]
 70 | prefix = "="
 71 | provider = "calc"
 72 | 
 73 | [[providers.prefixes]]
 74 | prefix = "@"
 75 | provider = "websearch"
 76 | 
 77 | [[providers.prefixes]]
 78 | prefix = ":"
 79 | provider = "clipboard"
 80 | 
 81 | [[providers.prefixes]]
 82 | prefix = "$"
 83 | provider = "windows"
 84 | 
 85 | [providers.clipboard]
 86 | time_format = "%d.%m. - %H:%M" # format for the clipboard item date
 87 | 
 88 | [providers.actions] # This will be MERGED/OVEWRITTEN with what the user specifies
 89 | fallback = [
 90 |   { action = "menus:open", label = "open", after = "Nothing" },
 91 |   { action = "menus:default", label = "run", after = "Close" },
 92 |   { action = "erase_history", label = "clear hist", bind = "ctrl h", after = "AsyncReload" },
 93 | ]
 94 | 
 95 | dmenu = [{ action = "select", default = true, bind = "Return" }]
 96 | 
 97 | providerlist = [
 98 |   { action = "activate", default = true, bind = "Return", after = "ClearReload" },
 99 | ]
100 | 
101 | bluetooth = [
102 |   { action = "find", global = true, bind = "ctrl f", after = "AsyncClearReload" },
103 |   { action = "trust", bind = "ctrl t", after = "AsyncReload" },
104 |   { action = "untrust", bind = "ctrl t", after = "AsyncReload" },
105 |   { action = "pair", bind = "Return", after = "AsyncReload" },
106 |   { action = "remove", bind = "ctrl d", after = "AsyncReload" },
107 |   { action = "connect", bind = "Return", after = "AsyncReload" },
108 |   { action = "disconnect", bind = "Return", after = "AsyncReload" },
109 | ]
110 | 
111 | archlinuxpkgs = [
112 |   { action = "install", bind = "Return", default = true },
113 |   { action = "remove", bind = "Return" },
114 | ]
115 | 
116 | calc = [
117 |   { action = "copy", default = true, bind = "Return" },
118 |   { action = "delete", bind = "ctrl d", after = "AsyncReload" },
119 |   { action = "save", bind = "ctrl s", after = "AsyncClearReload" },
120 | ]
121 | 
122 | websearch = [{ action = "search", default = true, bind = "Return" }]
123 | 
124 | desktopapplications = [
125 |   { action = "start", default = true, bind = "Return" },
126 |   { action = "start:keep", label = "open+next", bind = "shift Return", after = "KeepOpen" },
127 | 
128 |   { action = "new_instance", label = "new instance", bind = "ctrl Return" },
129 |   { action = "new_instance:keep", label = "new+next", bind = "ctrl alt Return", after = "KeepOpen" },
130 |   { action = "pin", bind = "ctrl p", after = "AsyncReload" },
131 |   { action = "unpin", bind = "ctrl p", after = "AsyncReload" },
132 |   { action = "pinup", bind = "ctrl n", after = "AsyncReload" },
133 |   { action = "pindown", bind = "ctrl m", after = "AsyncReload" },
134 | ]
135 | 
136 | files = [
137 |   { action = "open", default = true, bind = "Return" },
138 |   { action = "opendir", label = "open dir", bind = "ctrl Return" },
139 |   { action = "copypath", label = "copy path", bind = "ctrl shift c" },
140 |   { action = "copyfile", label = "copy file", bind = "ctrl c" },
141 | ]
142 | 
143 | todo = [
144 |   { action = "save", default = true, bind = "Return", after = "ClearReload" },
145 |   { action = "delete", bind = "ctrl d", after = "ClearReload" },
146 |   { action = "active", bind = "Return", after = "ClearReload" },
147 |   { action = "inactive", bind = "Return", after = "ClearReload" },
148 |   { action = "done", bind = "ctrl f", after = "ClearReload" },
149 |   { action = "change_category", bind = "ctrl y", label = "change category", after = "AsyncClearReload" },
150 |   { action = "clear", bind = "ctrl x", after = "ClearReload", global = true },
151 | ]
152 | 
153 | runner = [
154 |   { action = "run", default = true, bind = "Return" },
155 |   { action = "runterminal", label = "run in terminal", bind = "shift Return" },
156 | ]
157 | 
158 | symbols = [
159 |   { action = "run_cmd", label = "select", default = true, bind = "Return" },
160 | ]
161 | 
162 | unicode = [
163 |   { action = "run_cmd", label = "select", default = true, bind = "Return" },
164 | ]
165 | 
166 | nirisessions = [
167 |   { action = "start", label = "start", default = true, bind = "Return" },
168 |   { action = "start_new", label = "start blank", bind = "ctrl Return" },
169 | ]
170 | 
171 | clipboard = [
172 |   { action = "copy", default = true, bind = "Return" },
173 |   { action = "remove", bind = "ctrl d", after = "AsyncClearReload" },
174 |   { action = "remove_all", global = true, label = "clear", bind = "ctrl shift d", after = "AsyncClearReload" },
175 |   { action = "toggle_images", global = true, label = "toggle images", bind = "ctrl i", after = "AsyncClearReload" },
176 |   { action = "edit", bind = "ctrl o" },
177 | ]
178 | 


--------------------------------------------------------------------------------
/nix/modules/home-manager.nix:
--------------------------------------------------------------------------------
  1 | {
  2 |   self,
  3 |   elephant,
  4 | }: {
  5 |   config,
  6 |   lib,
  7 |   pkgs,
  8 |   ...
  9 | }: let
 10 |   inherit (lib.modules) mkIf mkMerge;
 11 |   inherit (lib.options) mkOption mkEnableOption mkPackageOption;
 12 |   inherit (lib.trivial) importTOML;
 13 |   inherit (lib.meta) getExe;
 14 |   inherit (lib.types) nullOr bool;
 15 |   inherit (lib) optional types mapAttrs' mapAttrsToList nameValuePair mkDefault literalExpression;
 16 | 
 17 |   cfg = config.programs.walker;
 18 | 
 19 |   tomlFormat = pkgs.formats.toml {};
 20 | in {
 21 |   imports = [
 22 |     elephant.homeManagerModules.default
 23 |   ];
 24 | 
 25 |   options = {
 26 |     programs.walker = {
 27 |       enable = mkEnableOption "walker";
 28 | 
 29 |       package = mkPackageOption self.packages.${pkgs.stdenv.system} "walker" {
 30 |         default = "default";
 31 |         pkgsText = "walker.packages.\${pkgs.stdenv.system}";
 32 |       };
 33 | 
 34 |       runAsService = mkOption {
 35 |         type = bool;
 36 |         default = false;
 37 |         description = "Run walker as a service for faster launch times.";
 38 |       };
 39 | 
 40 |       config = mkOption {
 41 |         inherit (tomlFormat) type;
 42 |         default = importTOML ../../resources/config.toml;
 43 |         defaultText = "importTOML ../../resources/config.toml";
 44 |         description = ''
 45 |           Configuration options for walker.
 46 | 
 47 |           See the default configuration for available options: <https://github.com/abenz1267/walker/blob/master/resources/config.toml>
 48 |         '';
 49 |       };
 50 | 
 51 |       themes = mkOption {
 52 |         type = types.attrsOf (types.submodule {
 53 |           options = {
 54 |             style = mkOption {
 55 |               type = types.lines;
 56 |               default = "";
 57 |               description = ''
 58 |                 The GTK CSS stylesheet used by this theme.
 59 | 
 60 |                 See the default style sheet for available classes: <https://github.com/abenz1267/walker/blob/master/resources/themes/default/style.css>
 61 |               '';
 62 |             };
 63 | 
 64 |             layouts = mkOption {
 65 |               type = types.attrsOf types.str;
 66 |               default = {};
 67 |               description = ''
 68 |                 The GTK xml layouts used for each provider.
 69 | 
 70 |                 See the default layouts for correct names and structure: <https://github.com/abenz1267/walker/tree/master/resources/themes/default>
 71 |               '';
 72 |             };
 73 |           };
 74 |         });
 75 |         default = {};
 76 |         example = literalExpression ''
 77 |           themes."your-theme-name" = {
 78 |             style = \'\'
 79 |               /* CSS */
 80 |             \'\';
 81 |             layouts = {
 82 |               "layout" = \'\'
 83 |                 <!-- XML Layout -->
 84 |               \'\';
 85 |               "item_calc" = \'\'
 86 |                 <!-- XML Layout -->
 87 |               \'\';
 88 |             };
 89 |           };
 90 |         '';
 91 |         description = "Set of themes usable by walker";
 92 |       };
 93 | 
 94 |       elephant = mkOption {
 95 |         inherit (tomlFormat) type;
 96 |         default = {};
 97 |         description = "Configuration for elephant";
 98 |       };
 99 | 
100 |       # The `theme` option will is deprecated please use the above `themes` option instead.
101 |       theme = mkOption {
102 |         type = with types;
103 |           nullOr (submodule {
104 |             options = {
105 |               name = mkOption {
106 |                 type = types.str;
107 |                 default = "nixos";
108 |                 description = "The theme name.";
109 |               };
110 | 
111 |               style = mkOption {
112 |                 type = lines;
113 |                 default = "";
114 |                 description = "The styling of the theme, written in GTK CSS.";
115 |               };
116 |             };
117 |           });
118 |         default = null;
119 |         description = "The custom theme used by walker. Setting this option overrides `programs.walker.config.theme`.";
120 |       };
121 |     };
122 |   };
123 | 
124 |   config = mkIf cfg.enable {
125 |     warnings = optional (cfg.theme != null) ''
126 |       The option `programs.walker.theme` is deprecated. Please migrate to `programs.walker.themes` instead.
127 | 
128 |       From
129 | 
130 |       programs.walker.theme = {
131 |         name = "${cfg.theme.name}";
132 |         style = " /* CSS */ ";
133 |       };
134 | 
135 |       to
136 | 
137 |       programs.walker = {
138 |         config.theme = "${cfg.theme.name}";
139 |         themes."${cfg.theme.name}" = {
140 |           style = " /* CSS */ ";
141 |         };
142 |       };
143 |     '';
144 | 
145 |     programs.elephant = mkMerge [
146 |       {enable = true;}
147 |       cfg.elephant
148 |     ];
149 | 
150 |     home.packages = [cfg.package];
151 | 
152 |     # deprecated functions start
153 |     programs.walker = mkIf (cfg.theme != null) {
154 |       themes = {
155 |         "${cfg.theme.name}" = mkDefault {
156 |           style = cfg.theme.style;
157 |         };
158 |       };
159 | 
160 |       config.theme = mkDefault cfg.theme.name;
161 |     };
162 |     # deprecated functions end
163 | 
164 |     xdg.configFile = mkMerge [
165 |       # Generate config file
166 |       (
167 |         mkIf (cfg.config != {}) {
168 |           "walker/config.toml".source = tomlFormat.generate "walker-config.toml" cfg.config;
169 |         }
170 |       )
171 | 
172 |       # Generate theme files
173 |       (
174 |         mkMerge (
175 |           mapAttrsToList
176 |           (
177 |             themeName: theme:
178 |               {
179 |                 "walker/themes/${themeName}/style.css".text = theme.style;
180 |               }
181 |               // (
182 |                 mapAttrs'
183 |                 (
184 |                   layoutName: layoutContent:
185 |                     nameValuePair "walker/themes/${themeName}/${layoutName}.xml" {
186 |                       text = layoutContent;
187 |                     }
188 |                 )
189 |                 theme.layouts
190 |               )
191 |           )
192 |           cfg.themes
193 |         )
194 |       )
195 |     ];
196 | 
197 |     systemd.user.services.walker = mkIf cfg.runAsService {
198 |       Unit = {
199 |         Description = "Walker - Application Runner";
200 |         ConditionEnvironment = "WAYLAND_DISPLAY";
201 |         After = [
202 |           "graphical-session.target"
203 |           "elephant.service"
204 |         ];
205 |         Requires = ["elephant.service"];
206 |         PartOf = ["graphical-session.target"];
207 |         X-Restart-Triggers = [
208 |           (builtins.hashString "sha256" (builtins.toJSON {
209 |             inherit (cfg) config themes elephant;
210 |           }))
211 |         ];
212 |       };
213 |       Service = {
214 |         ExecStart = "${getExe cfg.package} --gapplication-service";
215 |         Restart = "on-failure";
216 |       };
217 |       Install.WantedBy = ["graphical-session.target"];
218 |     };
219 |   };
220 | }
221 | 


--------------------------------------------------------------------------------
/nix/modules/nixos.nix:
--------------------------------------------------------------------------------
  1 | {
  2 |   self,
  3 |   elephant,
  4 | }: {
  5 |   config,
  6 |   lib,
  7 |   pkgs,
  8 |   ...
  9 | }: let
 10 |   inherit (lib.modules) mkIf mkMerge;
 11 |   inherit (lib.options) mkOption mkEnableOption mkPackageOption;
 12 |   inherit (lib.trivial) importTOML;
 13 |   inherit (lib.meta) getExe;
 14 |   inherit (lib.types) nullOr bool;
 15 |   inherit (lib) optionalString types mapAttrs' mapAttrsToList nameValuePair mkDefault literalExpression;
 16 | 
 17 |   cfg = config.programs.walker;
 18 | 
 19 |   tomlFormat = pkgs.formats.toml {};
 20 | in {
 21 |   imports = [
 22 |     elephant.nixosModules.default
 23 |   ];
 24 | 
 25 |   options = {
 26 |     programs.walker = {
 27 |       enable = mkEnableOption "walker";
 28 | 
 29 |       package = mkPackageOption self.packages.${pkgs.stdenv.system} "walker" {
 30 |         default = "default";
 31 |         pkgsText = "walker.packages.\${pkgs.stdenv.system}";
 32 |       };
 33 | 
 34 |       # This option doesn't work in the NixOS module
 35 |       runAsService = mkOption {
 36 |         type = bool;
 37 |         default = false;
 38 |         description = "Run walker as a service for faster launch times.";
 39 |       };
 40 | 
 41 |       config = mkOption {
 42 |         inherit (tomlFormat) type;
 43 |         default = importTOML ../../resources/config.toml;
 44 |         defaultText = "importTOML ../../resources/config.toml";
 45 |         description = ''
 46 |           Configuration options for walker.
 47 | 
 48 |           See the default configuration for available options: <https://github.com/abenz1267/walker/blob/master/resources/config.toml>
 49 |         '';
 50 |       };
 51 | 
 52 |       themes = mkOption {
 53 |         type = types.attrsOf (types.submodule {
 54 |           options = {
 55 |             style = mkOption {
 56 |               type = types.lines;
 57 |               default = "";
 58 |               description = ''
 59 |                 The GTK CSS stylesheet used by this theme.
 60 | 
 61 |                 See the default style sheet for available classes: <https://github.com/abenz1267/walker/blob/master/resources/themes/default/style.css>
 62 |               '';
 63 |             };
 64 | 
 65 |             layouts = mkOption {
 66 |               type = types.attrsOf types.str;
 67 |               default = {};
 68 |               description = ''
 69 |                 The GTK xml layouts used for each provider.
 70 | 
 71 |                 See the default layouts for correct names and structure: <https://github.com/abenz1267/walker/tree/master/resources/themes/default>
 72 |               '';
 73 |             };
 74 |           };
 75 |         });
 76 |         default = {};
 77 |         example = literalExpression ''
 78 |           themes."your-theme-name" = {
 79 |             style = \'\'
 80 |               /* CSS */
 81 |             \'\';
 82 |             layouts = {
 83 |               "layout" = \'\'
 84 |                 <!-- XML Layout -->
 85 |               \'\';
 86 |               "item_calc" = \'\'
 87 |                 <!-- XML Layout -->
 88 |               \'\';
 89 |             };
 90 |           };
 91 |         '';
 92 |         description = "Set of themes usable by walker";
 93 |       };
 94 | 
 95 |       elephant = mkOption {
 96 |         inherit (tomlFormat) type;
 97 |         default = {};
 98 |         description = "Configuration for elephant";
 99 |       };
100 | 
101 |       # The `theme` option will soon be deprecated please use the above `themes` option instead.
102 |       theme = mkOption {
103 |         type = with types;
104 |           nullOr (submodule {
105 |             options = {
106 |               name = mkOption {
107 |                 type = types.str;
108 |                 default = "nixos";
109 |                 description = "The theme name.";
110 |               };
111 | 
112 |               style = mkOption {
113 |                 type = lines;
114 |                 default = "";
115 |                 description = "The styling of the theme, written in GTK CSS.";
116 |               };
117 |             };
118 |           });
119 |         default = null;
120 |         description = "The custom theme used by walker. Setting this option overrides `programs.walker.config.theme`.";
121 |       };
122 |     };
123 |   };
124 | 
125 |   config = mkIf cfg.enable {
126 |     warnings = [
127 |       (optionalString (cfg.theme != null) ''
128 |         The option `programs.walker.theme` is deprecated. Please migrate to `programs.walker.themes` instead.
129 | 
130 |         From
131 | 
132 |         programs.walker.theme = {
133 |           name = "${cfg.theme.name}";
134 |           style = " /* CSS */ ";
135 |         };
136 | 
137 |         to
138 | 
139 |         programs.walker = {
140 |           config.theme = "${cfg.theme.name}";
141 |           themes."${cfg.theme.name}" = {
142 |             style = " /* CSS */ ";
143 |           };
144 |         };
145 |       '')
146 | 
147 |       (optionalString cfg.runAsService ''
148 |         The option `programs.walker.runAsService` is not supported in the NixOS module. It is recommended that you launch the elephant and walker services using your desktop instead.
149 | 
150 |         elephant
151 | 
152 |         walker --gapplication-service
153 |       '')
154 |     ];
155 | 
156 |     services.elephant = mkMerge [
157 |       {
158 |         enable = true;
159 |         installService = false; # Disable service option since its broken
160 |       }
161 |       cfg.elephant
162 |     ];
163 | 
164 |     environment.systemPackages = [cfg.package];
165 | 
166 |     # deprecated functions start
167 | 
168 |     programs.walker = mkIf (cfg.theme != null) {
169 |       themes = {
170 |         "${cfg.theme.name}" = mkDefault {
171 |           style = cfg.theme.style;
172 |         };
173 |       };
174 | 
175 |       config.theme = mkDefault cfg.theme.name;
176 |     };
177 |     # deprecated functions end
178 | 
179 |     environment.etc = mkMerge [
180 |       # Generate config file
181 |       (
182 |         mkIf (cfg.config != {}) {
183 |           "xdg/walker/config.toml".source = tomlFormat.generate "walker-config.toml" cfg.config;
184 |         }
185 |       )
186 | 
187 |       # Generate theme files
188 |       (
189 |         mkMerge (
190 |           mapAttrsToList
191 |           (
192 |             themeName: theme:
193 |               {
194 |                 "xdg/walker/themes/${themeName}/style.css".text = theme.style;
195 |               }
196 |               // (
197 |                 mapAttrs'
198 |                 (
199 |                   layoutName: layoutContent:
200 |                     nameValuePair "xdg/walker/themes/${themeName}/${layoutName}.xml" {
201 |                       text = layoutContent;
202 |                     }
203 |                 )
204 |                 theme.layouts
205 |               )
206 |           )
207 |           cfg.themes
208 |         )
209 |       )
210 |     ];
211 | 
212 |     # systemd.services.walker = mkIf cfg.runAsService {
213 |     #   description = "Walker - Application Runner";
214 |     #   unitConfig = {
215 |     #     ConditionEnvironment = "WAYLAND_DISPLAY";
216 |     #   };
217 |     #   after = [
218 |     #     "graphical-session.target"
219 |     #     "elephant.service"
220 |     #   ];
221 |     #   requires = ["elephant.service"];
222 |     #   partOf = ["graphical-session.target"];
223 |     #   wantedBy = ["graphical-session.target"];
224 |     #   serviceConfig = {
225 |     #     ExecStart = "${getExe cfg.package} --gapplication-service";
226 |     #     Restart = "on-failure";
227 |     #   };
228 |     # };
229 |   };
230 | }
231 | 


--------------------------------------------------------------------------------
/src/theme/mod.rs:
--------------------------------------------------------------------------------
  1 | use crate::config::get_config;
  2 | use crate::providers::PROVIDERS;
  3 | use crate::state::add_theme;
  4 | use crate::ui::window::{set_css_provider, with_css_provider};
  5 | use gtk4::gdk::Display;
  6 | use gtk4::prelude::GtkWindowExt;
  7 | use gtk4::{CssProvider, Window, gio};
  8 | use gtk4_layer_shell::{Edge, KeyboardMode, Layer, LayerShell};
  9 | use std::cell::OnceCell;
 10 | use std::collections::HashMap;
 11 | use std::path::PathBuf;
 12 | use std::{env, fs};
 13 | 
 14 | thread_local! {
 15 |     pub static THEMES: OnceCell<HashMap<String, Theme>> = OnceCell::new();
 16 | }
 17 | 
 18 | #[derive(Debug)]
 19 | pub struct Theme {
 20 |     pub layout: String,
 21 |     pub keybind: String,
 22 |     pub preview: String,
 23 |     pub css: Option<gio::File>,
 24 |     pub items: HashMap<String, String>,
 25 | }
 26 | 
 27 | impl Theme {
 28 |     pub fn default() -> Self {
 29 |         let mut s = Self {
 30 |             layout: include_str!("../../resources/themes/default/layout.xml").to_string(),
 31 |             keybind: include_str!("../../resources/themes/default/keybind.xml").to_string(),
 32 |             preview: include_str!("../../resources/themes/default/preview.xml").to_string(),
 33 |             css: None,
 34 |             items: HashMap::new(),
 35 |         };
 36 | 
 37 |         for (k, v) in PROVIDERS.get().unwrap() {
 38 |             s.items.insert(k.clone(), v.get_item_layout());
 39 |         }
 40 | 
 41 |         s
 42 |     }
 43 | }
 44 | 
 45 | pub fn setup_themes(elephant: bool, theme: String, is_service: bool) {
 46 |     let mut themes: HashMap<String, Theme> = HashMap::new();
 47 | 
 48 |     let dirs = xdg::BaseDirectories::with_prefix("walker").find_config_files("themes");
 49 | 
 50 |     let mut config_paths: Vec<PathBuf> = dirs.collect();
 51 | 
 52 |     if let Some(a) = &get_config().additional_theme_location
 53 |         && let Ok(home) = env::var("HOME")
 54 |     {
 55 |         config_paths.push(PathBuf::from(a.replace("~", &home).to_string()));
 56 |     }
 57 | 
 58 |     let files = vec![
 59 |         "layout.xml".to_string(),
 60 |         "keybind.xml".to_string(),
 61 |         "style.css".to_string(),
 62 |         "preview.xml".to_string(),
 63 |     ];
 64 | 
 65 |     let combined = if elephant {
 66 |         let mut result = files;
 67 |         let additional = PROVIDERS
 68 |             .get()
 69 |             .unwrap()
 70 |             .iter()
 71 |             .map(|v| format!("item_{}.xml", v.0));
 72 |         result.extend(additional);
 73 |         result
 74 |     } else {
 75 |         files
 76 |     };
 77 | 
 78 |     for config_path in config_paths {
 79 |         if !is_service {
 80 |             let mut path = config_path;
 81 | 
 82 |             path.push(&theme);
 83 | 
 84 |             if let Some(t) = setup_theme_from_path(path.clone(), &combined) {
 85 |                 themes.insert(theme.clone(), t);
 86 |                 add_theme(theme.clone());
 87 |             }
 88 | 
 89 |             path.pop();
 90 | 
 91 |             continue;
 92 |         }
 93 | 
 94 |         let Ok(theme_dirs) = fs::read_dir(config_path) else {
 95 |             continue;
 96 |         };
 97 | 
 98 |         for theme_dir in theme_dirs {
 99 |             let entry = theme_dir.unwrap();
100 |             let path = entry.path();
101 | 
102 |             if !path.is_dir() {
103 |                 continue;
104 |             }
105 | 
106 |             let Some(name) = path.file_name() else {
107 |                 continue;
108 |             };
109 | 
110 |             let theme_name = name.to_string_lossy();
111 | 
112 |             if let Some(t) = setup_theme_from_path(path.clone(), &combined) {
113 |                 themes.insert(theme_name.to_string(), t);
114 |                 add_theme(theme_name.to_string());
115 |             }
116 |         }
117 |     }
118 | 
119 |     if !themes.contains_key("default") {
120 |         themes.insert("default".to_string(), Theme::default());
121 |         add_theme("default".to_string());
122 |     }
123 | 
124 |     THEMES.with(|s| s.set(themes).expect("failed initializing themes"));
125 | }
126 | 
127 | fn setup_theme_from_path(path: PathBuf, files: &Vec<String>) -> Option<Theme> {
128 |     let mut path = path;
129 | 
130 |     if !path.exists() {
131 |         return None;
132 |     }
133 | 
134 |     let mut theme = Theme::default();
135 | 
136 |     let mut pc = path.clone();
137 | 
138 |     let mut read_file = |filename: &str| -> Option<String> {
139 |         path.push(filename);
140 |         let result = fs::read_to_string(&path).ok();
141 |         path.pop();
142 |         result
143 |     };
144 | 
145 |     for file in files {
146 |         match file.as_str() {
147 |             "item.xml" => {
148 |                 if let Some(s) = read_file(file) {
149 |                     theme.items.insert("default".to_string(), s);
150 |                 }
151 |             }
152 |             "style.css" => {
153 |                 pc.push("style.css");
154 |                 theme.css = Some(gio::File::for_path(&pc));
155 |                 pc.pop();
156 |             }
157 |             "layout.xml" => {
158 |                 if let Some(s) = read_file(file) {
159 |                     theme.layout = s;
160 |                 }
161 |             }
162 |             "keybind.xml" => {
163 |                 if let Some(s) = read_file(file) {
164 |                     theme.keybind = s;
165 |                 }
166 |             }
167 |             "preview.xml" => {
168 |                 if let Some(s) = read_file(file) {
169 |                     theme.preview = s;
170 |                 }
171 |             }
172 |             name if name.ends_with(".xml") && name.starts_with("item_") => {
173 |                 if let Some(s) = read_file(file) {
174 |                     let key = name
175 |                         .strip_prefix("item_")
176 |                         .unwrap()
177 |                         .strip_suffix(".xml")
178 |                         .unwrap();
179 |                     theme.items.insert(key.to_string(), s);
180 |                 }
181 |             }
182 |             _ => (),
183 |         }
184 |     }
185 | 
186 |     Some(theme)
187 | }
188 | 
189 | pub fn setup_css(theme: String) {
190 |     with_themes(|t| {
191 |         if let Some(t) = t.get(&theme) {
192 |             with_css_provider(|p| {
193 |                 if let Some(f) = &t.css {
194 |                     p.load_from_file(f);
195 |                 } else {
196 |                     p.load_from_string(include_str!("../../resources/themes/default/style.css"));
197 |                 }
198 |             });
199 |         }
200 |     });
201 | }
202 | 
203 | pub fn setup_css_provider() {
204 |     let display = Display::default().unwrap();
205 |     let p = CssProvider::new();
206 | 
207 |     gtk4::style_context_add_provider_for_display(&display, &p, gtk4::STYLE_PROVIDER_PRIORITY_USER);
208 |     set_css_provider(p);
209 | }
210 | 
211 | pub fn setup_layer_shell(win: &Window) {
212 |     if !gtk4_layer_shell::is_supported() {
213 |         let titlebar = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
214 |         win.set_titlebar(Some(&titlebar));
215 |         return;
216 |     }
217 | 
218 |     let cfg = get_config();
219 | 
220 |     win.init_layer_shell();
221 |     win.set_namespace(Some("walker"));
222 |     win.set_exclusive_zone(-1);
223 |     win.set_layer(Layer::Overlay);
224 |     win.set_keyboard_mode(if cfg.force_keyboard_focus {
225 |         KeyboardMode::Exclusive
226 |     } else {
227 |         KeyboardMode::OnDemand
228 |     });
229 |     win.set_anchor(Edge::Left, cfg.shell.anchor_left);
230 |     win.set_anchor(Edge::Right, cfg.shell.anchor_right);
231 |     win.set_anchor(Edge::Top, cfg.shell.anchor_top);
232 |     win.set_anchor(Edge::Bottom, cfg.shell.anchor_top);
233 | }
234 | 
235 | pub fn with_themes<F, R>(f: F) -> R
236 | where
237 |     F: FnOnce(&HashMap<String, Theme>) -> R,
238 | {
239 |     THEMES.with(|state| {
240 |         let data = state.get().expect("Themes not initialized");
241 |         f(data)
242 |     })
243 | }
244 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Walker - A Modern Application Launcher
  2 | 
  3 | A fast, customizable application launcher built with GTK4 and Rust, designed for Linux desktop environments. Walker provides a clean, modern interface for launching applications, running commands, performing calculations, and more.
  4 | 
  5 | [GitBook Documentation/Wiki](https://benz.gitbook.io/walker/)
  6 | 
  7 | [![Discord](https://img.shields.io/discord/1402235361463242964?logo=discord)](https://discord.gg/mGQWBQHASt)
  8 | [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  9 | 
 10 | ![screenshot](https://raw.githubusercontent.com/abenz1267/walker/refs/heads/master/resources/screenshot.png)
 11 | 
 12 | ## Features
 13 | 
 14 | The following Elephant providers are implemented by default:
 15 | 
 16 | - **Desktop Applications**: Launch installed GUI applications
 17 | - **Calculator**: Perform mathematical calculations with `=` prefix
 18 | - **File Browser**: Navigate and open files with `/` prefix
 19 | - **Command Runner**: Execute shell commands
 20 | - **Websearch**: Search the web with custom-defined engines
 21 | - **Clipboard History**: Access clipboard history with `:` prefix
 22 | - **Symbol Picker**: Insert special symbols with `.` prefix
 23 | - **Provider List**: Switch between providers with `;` prefix
 24 | - **Menu Integration**: Create custom menus with elephant and let walker display them
 25 | - **Dmenu**: Your good old dmenu ... with seamless menus!
 26 | - **Arch Linux Packages**: Search through available packages (official and aur), install or delete a target! List all exlusively installed packages.
 27 | - **Todo List**: create simple todo items with basic time tracking, scheduling and notifications
 28 | - **Bluetooth**: basic bluetooth management
 29 | 
 30 | ## Installation
 31 | 
 32 | ### Build from Source
 33 | 
 34 | ```bash
 35 | # Clone the repository
 36 | git clone https://github.com/abenz1267/walker.git
 37 | cd walker
 38 | 
 39 | # Build with Cargo
 40 | cargo build --release
 41 | 
 42 | # Run Walker
 43 | ./target/release/walker
 44 | ```
 45 | 
 46 | ### Dependencies
 47 | 
 48 | - GTK4 (version 4.6+)
 49 | - gtk4-layer-shell
 50 | - Protocol Buffers compiler
 51 | - cairo
 52 | - poppler-glib
 53 | - make sure [elephant](https://github.com/abenz1267/elephant) is running before starting Walker
 54 | 
 55 | <details>
 56 |     <summary> <h3> Install using Nix </h3> </summary>
 57 | 
 58 | #### 1. Add flake inputs
 59 | 
 60 | Add walker and elephant to the inputs of your configs `flake.nix` and set walker to follow elephant
 61 | 
 62 | ```nix
 63 | elephant.url = "github:abenz1267/elephant";
 64 | 
 65 | walker = {
 66 |   url = "github:abenz1267/walker";
 67 |   inputs.elephant.follows = "elephant";
 68 | };
 69 | ```
 70 | 
 71 | #### 2. Install walker
 72 | 
 73 | You have 3 options for installing walker.
 74 | 
 75 | **Option A** (Home Manager Module): Import the home-manager module to your home-manager config and enable walker.
 76 | 
 77 | ```nix
 78 | imports = [inputs.walker.homeManagerModules.default];
 79 | 
 80 | programs.walker.enable = true;
 81 | ```
 82 | 
 83 | **Option B** (NixOS Module): Import the nixos module in your NixOS config and enable walker
 84 | 
 85 | ```nix
 86 | imports = [inputs.walker.nixosModules.default];
 87 | 
 88 | programs.walker.enable = true;
 89 | ```
 90 | 
 91 | > Note: this option doesn't support the `runAsService` option; It is recommended that you launch the elephant and walker services using your desktop instead.
 92 | 
 93 | **Option C** (Package): Add `inputs.walker.packages.<system>.default` to your system packages or home-manager packages. replace `<system>` with your system architecture. Note: This option doesn't support configuration using nix.
 94 | 
 95 | ```nix
 96 | home.packages = [inputs.walker.packages.<system>.default];
 97 | ```
 98 | 
 99 | ```nix
100 | environment.systemPackages = [inputs.walker.packages.<system>.default];
101 | ```
102 | 
103 | #### 3. Configure walker
104 | 
105 | ```nix
106 | programs.walker = {
107 |   enable = true;
108 |   runAsService = true; # Note: this option isn't supported in the NixOS module only in the home-manager module
109 | 
110 |   # All options from the config.toml can be used here https://github.com/abenz1267/walker/blob/master/resources/config.toml
111 |   config = {
112 |     theme = "your theme name";
113 |     placeholders."default" = { input = "Search"; list = "Example"; };
114 |     providers.prefixes = [
115 |       {provider = "websearch"; prefix = "+";}
116 |       {provider = "providerlist"; prefix = "_";}
117 |     ];
118 |     keybinds.quick_activate = ["F1" "F2" "F3"];
119 |   };
120 |   
121 |   # Set `programs.walker.config.theme="your theme name"` to choose the default theme
122 |   themes = {
123 |     "your theme name" = {
124 |       # Check out the default css theme as an example https://github.com/abenz1267/walker/blob/master/resources/themes/default/style.css
125 |       style = " /* css */ ";
126 | 
127 |       # Check out the default layouts for examples https://github.com/abenz1267/walker/tree/master/resources/themes/default
128 |       layouts = {
129 |         "layout" = " <!-- xml --> ";
130 |         "item_calc" = " <!-- xml --> ";
131 |         # other provider layouts
132 |       };
133 |     };
134 |     "other theme name" = {
135 |         # ...
136 |     };
137 |     # more themes
138 |   };
139 | };
140 | ```
141 | 
142 | Optionally, there is 2 binary caches which can be used by adding the following to you config:
143 | 
144 | ```nix
145 | nix.settings = {
146 |   extra-substituters = ["https://walker.cachix.org" "https://walker-git.cachix.org"];
147 |   extra-trusted-public-keys = ["walker.cachix.org-1:fG8q+uAaMqhsMxWjwvk0IMb4mFPFLqHjuvfwQxE4oJM=" "walker-git.cachix.org-1:vmC0ocfPWh0S/vRAQGtChuiZBTAe4wiKDeyyXM0/7pM="];
148 | };
149 | ```
150 | 
151 | </details>
152 | 
153 | ## Usage
154 | 
155 | ### Basic Usage
156 | 
157 | **Make sure `elephant` is running and you have providers installed. `elephant-providerlist` and f.e. `elephant-desktopapplications`.**
158 | 
159 | Launch Walker with `walker`.
160 | 
161 | In order to improve startup performance, run a Walker service with:
162 | 
163 | ```bash
164 | walker --gapplication-service
165 | ```
166 | 
167 | If the service is running, you can either open Walker with:
168 | 
169 | ```bash
170 | walker
171 | ```
172 | 
173 | or for an even faster launch make a socket call, f.e. with `openbsd-netcat`:
174 | 
175 | ```bash
176 | nc -U /run/user/1000/walker/walker.sock
177 | ```
178 | 
179 | The downside of the socket call is that it does not handle any commandline options, so it's just a faster alternative to a simple `walker` call.
180 | 
181 | ## Keybinds
182 | 
183 | The following modifier keys are valid: `ctrl`, `alt`, `shift`, `super`.
184 | 
185 | To get a full list of possible key values, look here: [GDK key-values](https://github.com/gtk-rs/gtk4-rs/blob/0.9/gdk4/sys/src/lib.rs#L302).
186 | 
187 | F.e. `pub const GDK_KEY_semicolon: c_int = 59;` means that `ctrl semicolon` would be a valid keybind.
188 | 
189 | ## Config
190 | 
191 | Configuration should be done in `~/.config/walker`.
192 | 
193 | Check out the [default config](https://raw.githubusercontent.com/abenz1267/walker/refs/heads/master/resources/config.toml).
194 | 
195 | ## Theming
196 | 
197 | You can customize Walker's appearance by creating a custom theme. Checkout `resources/themes/default` for the default theme. Themes inherit the default theme by default, so if you just want to change the CSS, you can just create `themes/yours/style.css`.
198 | 
199 | You can customize rendering of list items for each provider individually, f.e. "item_files.xml" will define the layout for items sourced from the `files` provider.
200 | 
201 | Please refer to [the GTK4 docs](https://docs.gtk.org/gtk4/) to checkout how to write `*.xml` files for GTK4.
202 | 
203 | You can set the default theme in your `config.toml` f.e. `theme = "yours"`.
204 | 
205 | ## Contributing
206 | 
207 | Please do not make PRs to fix single typos. Fix all or nothing.
208 | 
209 | ## License
210 | 
211 | This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
212 | 


--------------------------------------------------------------------------------
/src/preview/clipboard_preview.rs:
--------------------------------------------------------------------------------
  1 | use super::PreviewHandler;
  2 | use crate::protos::generated_proto::query::query_response::Item;
  3 | use crate::ui::window::get_selected_item;
  4 | use gtk4::gio;
  5 | use gtk4::glib;
  6 | use gtk4::{
  7 |     Box as GtkBox, Builder, ContentFit, Image, Orientation, Picture, PolicyType, ScrolledWindow,
  8 |     Stack, TextView, WrapMode, gdk_pixbuf, prelude::*,
  9 | };
 10 | use std::path::Path;
 11 | 
 12 | #[derive(Debug)]
 13 | pub struct ClipboardPreviewHandler;
 14 | 
 15 | #[derive(Debug)]
 16 | pub struct ClipboardPreview {
 17 |     pub box_widget: GtkBox,
 18 |     preview_area: Stack,
 19 |     current_item_id: String,
 20 | }
 21 | 
 22 | impl ClipboardPreviewHandler {
 23 |     pub fn new() -> Self {
 24 |         Self
 25 |     }
 26 | }
 27 | 
 28 | impl PreviewHandler for ClipboardPreviewHandler {
 29 |     fn clear_cache(&self) {}
 30 | 
 31 |     fn handle(&self, item: &Item, preview: &GtkBox, builder: &Builder) {
 32 |         let Some(current) = get_selected_item() else {
 33 |             return;
 34 |         };
 35 | 
 36 |         if current != *item {
 37 |             return;
 38 |         }
 39 | 
 40 |         let clipboard_preview =
 41 |             ClipboardPreview::new_with_builder(builder).or_else(|_| ClipboardPreview::new());
 42 | 
 43 |         let Ok(mut clipboard_preview) = clipboard_preview else {
 44 |             return;
 45 |         };
 46 | 
 47 |         if clipboard_preview.preview_item(item).is_err() {
 48 |             return;
 49 |         }
 50 | 
 51 |         while let Some(child) = preview.first_child() {
 52 |             child.unparent();
 53 |         }
 54 |         preview.append(&clipboard_preview.box_widget);
 55 |         preview.set_visible(get_selected_item().is_some_and(|current| current == *item));
 56 |     }
 57 | }
 58 | 
 59 | impl ClipboardPreview {
 60 |     pub fn new_with_builder(builder: &Builder) -> Result<Self, Box<dyn std::error::Error>> {
 61 |         let box_widget = builder
 62 |             .object::<GtkBox>("PreviewBox")
 63 |             .ok_or("PreviewBox not found in builder")?;
 64 | 
 65 |         let preview_area = builder
 66 |             .object::<Stack>("PreviewStack")
 67 |             .ok_or("PreviewStack not found in builder")?;
 68 | 
 69 |         Ok(Self {
 70 |             box_widget,
 71 |             preview_area,
 72 |             current_item_id: String::new(),
 73 |         })
 74 |     }
 75 | 
 76 |     pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
 77 |         let box_widget = GtkBox::new(Orientation::Vertical, 0);
 78 |         let preview_area = Stack::new();
 79 |         box_widget.append(&preview_area);
 80 | 
 81 |         Ok(Self {
 82 |             box_widget,
 83 |             preview_area,
 84 |             current_item_id: String::new(),
 85 |         })
 86 |     }
 87 | 
 88 |     pub fn preview_item(&mut self, item: &Item) -> Result<(), Box<dyn std::error::Error>> {
 89 |         self.current_item_id = item.identifier.clone();
 90 |         self.clear_preview();
 91 | 
 92 |         if !item.icon.is_empty() && Path::new(&item.icon).exists() {
 93 |             return self.preview_image(&item.icon);
 94 |         }
 95 | 
 96 |         self.preview_text(&item.text)
 97 |     }
 98 | 
 99 |     fn clear_preview(&self) {
100 |         while let Some(child) = self.preview_area.first_child() {
101 |             if let Some(picture) = child.downcast_ref::<Picture>() {
102 |                 picture.set_filename(Option::<&str>::None);
103 |                 picture.set_paintable(gtk4::gdk::Paintable::NONE);
104 |             }
105 | 
106 |             if let Some(image) = child.downcast_ref::<Image>() {
107 |                 image.clear();
108 |                 image.set_icon_name(Option::<&str>::None);
109 |             }
110 | 
111 |             if let Some(scrolled) = child.downcast_ref::<ScrolledWindow>()
112 |                 && let Some(scrolled_child) = scrolled.child()
113 |             {
114 |                 if let Some(text_view) = scrolled_child.downcast_ref::<TextView>() {
115 |                     text_view.buffer().set_text("");
116 |                 }
117 |                 if let Some(picture) = scrolled_child.downcast_ref::<Picture>() {
118 |                     picture.set_filename(Option::<&str>::None);
119 |                     picture.set_paintable(gtk4::gdk::Paintable::NONE);
120 |                 }
121 |                 if let Some(image) = scrolled_child.downcast_ref::<Image>() {
122 |                     image.clear();
123 |                     image.set_icon_name(Option::<&str>::None);
124 |                 }
125 |             }
126 | 
127 |             self.preview_area.remove(&child);
128 |         }
129 |     }
130 | 
131 |     fn preview_image(&self, image_path: &str) -> Result<(), Box<dyn std::error::Error>> {
132 |         let picture = Picture::new();
133 |         picture.set_content_fit(ContentFit::Contain);
134 | 
135 |         let scrolled = ScrolledWindow::new();
136 |         scrolled.set_child(Some(&picture));
137 |         scrolled.set_policy(PolicyType::Automatic, PolicyType::Automatic);
138 |         scrolled.set_size_request(400, 300);
139 | 
140 |         self.preview_area.add_child(&scrolled);
141 |         self.preview_area.set_visible_child(&scrolled);
142 | 
143 |         let file = gio::File::for_path(image_path);
144 |         picture.set_file(Some(&file));
145 | 
146 |         let image_path_clone = image_path.to_string();
147 | 
148 |         glib::MainContext::ref_thread_default().spawn_local(async move {
149 |             let cancellable = gio::Cancellable::new();
150 |             match Self::load_image_async(&image_path_clone, &cancellable).await {
151 |                 Ok(_) => {}
152 |                 Err(e) => {
153 |                     eprintln!("Failed to cache image {}: {}", image_path_clone, e);
154 |                 }
155 |             }
156 |         });
157 | 
158 |         Ok(())
159 |     }
160 | 
161 |     async fn load_image_async(
162 |         image_path: &str,
163 |         cancellable: &gio::Cancellable,
164 |     ) -> Result<gtk4::gdk::Texture, Box<dyn std::error::Error>> {
165 |         let file = gio::File::for_path(image_path);
166 | 
167 |         let (bytes, _) = file.load_bytes_future().await?;
168 |         let stream = gio::MemoryInputStream::from_bytes(&bytes);
169 | 
170 |         let pixbuf = gdk_pixbuf::Pixbuf::from_stream(&stream, Some(cancellable))?;
171 | 
172 |         let max_width = 800;
173 |         let max_height = 600;
174 |         let (width, height) = (pixbuf.width(), pixbuf.height());
175 |         let (new_width, new_height) = if width > max_width || height > max_height {
176 |             let width_ratio = max_width as f64 / width as f64;
177 |             let height_ratio = max_height as f64 / height as f64;
178 |             let ratio = width_ratio.min(height_ratio);
179 |             (
180 |                 (width as f64 * ratio) as i32,
181 |                 (height as f64 * ratio) as i32,
182 |             )
183 |         } else {
184 |             (width, height)
185 |         };
186 | 
187 |         let scaled_pixbuf = if new_width != width || new_height != height {
188 |             pixbuf
189 |                 .scale_simple(new_width, new_height, gdk_pixbuf::InterpType::Bilinear)
190 |                 .ok_or("Failed to scale image")?
191 |         } else {
192 |             pixbuf
193 |         };
194 | 
195 |         let texture = gtk4::gdk::Texture::for_pixbuf(&scaled_pixbuf);
196 | 
197 |         Ok(texture)
198 |     }
199 | 
200 |     fn preview_text(&self, text: &str) -> Result<(), Box<dyn std::error::Error>> {
201 |         let text_view = TextView::new();
202 |         text_view.set_editable(false);
203 |         text_view.set_monospace(true);
204 |         text_view.set_wrap_mode(WrapMode::Word);
205 |         text_view.set_size_request(400, 300);
206 | 
207 |         let buffer = text_view.buffer();
208 | 
209 |         let display_text = if text.len() > 10000 {
210 |             format!("{}\n\n[Text truncated...]", &text[..10000])
211 |         } else {
212 |             text.to_string()
213 |         };
214 | 
215 |         buffer.set_text(&display_text);
216 | 
217 |         let scrolled = ScrolledWindow::new();
218 |         scrolled.set_child(Some(&text_view));
219 |         scrolled.set_policy(PolicyType::Automatic, PolicyType::Automatic);
220 |         scrolled.set_size_request(400, 300);
221 | 
222 |         self.preview_area.add_child(&scrolled);
223 |         self.preview_area.set_visible_child(&scrolled);
224 | 
225 |         Ok(())
226 |     }
227 | }
228 | 


--------------------------------------------------------------------------------
/src/providers/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::{
  2 |     collections::{HashMap, HashSet},
  3 |     fmt::Debug,
  4 |     path::Path,
  5 |     process::Command,
  6 |     sync::OnceLock,
  7 | };
  8 | 
  9 | use gtk4::{
 10 |     Builder, Image, Label, ListItem, Picture, gdk,
 11 |     gio::{self, prelude::FileExtManual},
 12 |     glib,
 13 |     prelude::WidgetExt,
 14 | };
 15 | 
 16 | use crate::{
 17 |     config::get_config,
 18 |     keybinds::Action,
 19 |     protos::generated_proto::query::query_response::Item,
 20 |     providers::{
 21 |         archlinuxpkgs::ArchLinuxPkgs, calc::Calc, clipboard::Clipboard,
 22 |         default_provider::DefaultProvider, dmenu::Dmenu, files::Files, providerlist::Providerlist,
 23 |         symbols::Symbols, todo::Todo, unicode::Unicode,
 24 |     },
 25 | };
 26 | 
 27 | pub mod archlinuxpkgs;
 28 | pub mod calc;
 29 | pub mod clipboard;
 30 | pub mod default_provider;
 31 | pub mod dmenu;
 32 | pub mod files;
 33 | pub mod providerlist;
 34 | pub mod symbols;
 35 | pub mod todo;
 36 | pub mod unicode;
 37 | 
 38 | pub trait Provider: Sync + Send + Debug {
 39 |     fn get_name(&self) -> &str;
 40 | 
 41 |     fn get_actions(&self) -> Vec<Action> {
 42 |         get_config()
 43 |             .providers
 44 |             .actions
 45 |             .get(self.get_name())
 46 |             .cloned()
 47 |             .unwrap_or_else(|| {
 48 |                 vec![Action {
 49 |                     action: "activate".to_string(),
 50 |                     default: Some(true),
 51 |                     bind: Some("Return".to_string()),
 52 |                     global: None,
 53 |                     after: None,
 54 |                     label: None,
 55 |                 }]
 56 |             })
 57 |     }
 58 | 
 59 |     fn get_keybind_hint(&self, actions: &[String]) -> Vec<Action> {
 60 |         let mut present = HashSet::new();
 61 | 
 62 |         let mut result: Vec<Action> = self
 63 |             .get_actions()
 64 |             .iter()
 65 |             .map(|a| {
 66 |                 if a.action.ends_with(":keep") {
 67 |                     return match a.action.split_once(":") {
 68 |                         Some((first, _)) => {
 69 |                             let mut a = a.clone();
 70 |                             a.action = first.to_string();
 71 |                             a
 72 |                         }
 73 |                         None => a.clone(),
 74 |                     };
 75 |                 }
 76 | 
 77 |                 a.clone()
 78 |             })
 79 |             .filter(|v| {
 80 |                 if actions.contains(&v.action) || v.global.unwrap_or(false) {
 81 |                     present.insert(v.action.clone());
 82 |                 }
 83 | 
 84 |                 actions.contains(&v.action) || v.global.unwrap_or(false)
 85 |             })
 86 |             .collect();
 87 | 
 88 |         if let Some(r) = get_config().providers.actions.get("fallback") {
 89 |             r.iter()
 90 |                 .map(|a| {
 91 |                     if a.action.ends_with(":keep") {
 92 |                         return match a.action.split_once(":") {
 93 |                             Some((first, _)) => {
 94 |                                 let mut a = a.clone();
 95 |                                 a.action = first.to_string();
 96 |                                 a
 97 |                             }
 98 |                             None => a.clone(),
 99 |                         };
100 |                     }
101 | 
102 |                     a.clone()
103 |                 })
104 |                 .filter(|v| {
105 |                     (actions.contains(&v.action) || v.global.unwrap_or(false))
106 |                         && !present.contains(&v.action)
107 |                 })
108 |                 .for_each(|v| {
109 |                     result.push(v);
110 |                 });
111 |         }
112 | 
113 |         if !actions.is_empty()
114 |             && (result.is_empty()
115 |                 || (result.len() == 1 && result.first().unwrap().global.unwrap_or(false)))
116 |         {
117 |             if result.len() == 1 {
118 |                 result.push(Action {
119 |                     action: actions
120 |                         .iter()
121 |                         .find(|a| result.first().unwrap().action != **a)
122 |                         .unwrap()
123 |                         .to_string(),
124 |                     global: None,
125 |                     default: Some(true),
126 |                     bind: Some("Return".to_string()),
127 |                     after: None,
128 |                     label: None,
129 |                 });
130 |             } else {
131 |                 result.push(Action {
132 |                     action: actions.first().unwrap().to_string(),
133 |                     global: None,
134 |                     default: Some(true),
135 |                     bind: Some("Return".to_string()),
136 |                     after: None,
137 |                     label: None,
138 |                 });
139 |             }
140 |         }
141 | 
142 |         result.sort_by_key(|v| v.default.unwrap_or(false));
143 |         result
144 |     }
145 | 
146 |     fn get_item_layout(&self) -> String {
147 |         include_str!("../../resources/themes/default/item.xml").to_string()
148 |     }
149 | 
150 |     fn text_transformer(&self, item: &Item, label: &Label) {
151 |         if item.text.is_empty() {
152 |             label.set_visible(false);
153 |             return;
154 |         }
155 | 
156 |         label.set_text(&item.text);
157 |     }
158 | 
159 |     fn subtext_transformer(&self, item: &Item, label: &Label) {
160 |         if item.subtext.is_empty() {
161 |             label.set_visible(false);
162 |             return;
163 |         }
164 | 
165 |         label.set_text(&item.subtext);
166 |     }
167 | 
168 |     fn image_transformer(&self, b: &Builder, _: &ListItem, item: &Item) {
169 |         let mut is_text = false;
170 | 
171 |         if let Some(image) = b.object::<Label>("ItemImageFont") {
172 |             image.set_visible(false);
173 | 
174 |             if !item.icon.is_ascii() {
175 |                 image.set_text(&item.icon);
176 |                 image.set_visible(true);
177 |                 is_text = true;
178 |             }
179 |         }
180 | 
181 |         if let Some(image) = b.object::<Image>("ItemImage") {
182 |             image.set_visible(true);
183 |             if is_text {
184 |                 image.set_visible(false);
185 |                 return;
186 |             }
187 | 
188 |             if item.icon.is_empty() {
189 |                 image.set_visible(false);
190 |                 return;
191 |             }
192 | 
193 |             if !Path::new(&item.icon).is_absolute() {
194 |                 image.set_icon_name(Some(&item.icon));
195 |                 return;
196 |             };
197 | 
198 |             let icon = item.icon.clone();
199 |             glib::spawn_future_local(async move {
200 |                 let Ok((bytes, _)) = gio::File::for_path(&icon).load_contents_future().await else {
201 |                     return;
202 |                 };
203 | 
204 |                 let texture = gdk::Texture::from_bytes(&glib::Bytes::from(&bytes)).unwrap();
205 |                 image.set_paintable(Some(&texture));
206 |             });
207 |         } else if let Some(image) = b.object::<Picture>("ItemImage") {
208 |             image.set_visible(true);
209 |             if is_text {
210 |                 image.set_visible(false);
211 |                 return;
212 |             }
213 | 
214 |             if item.icon.is_empty() {
215 |                 image.set_visible(false);
216 |                 return;
217 |             }
218 | 
219 |             let icon = item.icon.clone();
220 | 
221 |             glib::spawn_future_local(async move {
222 |                 let Ok((bytes, _)) = gio::File::for_path(&icon).load_contents_future().await else {
223 |                     return;
224 |                 };
225 | 
226 |                 let texture = gdk::Texture::from_bytes(&glib::Bytes::from(&bytes)).unwrap();
227 |                 image.set_paintable(Some(&texture));
228 |             });
229 |         }
230 |     }
231 | }
232 | 
233 | pub static PROVIDERS: OnceLock<HashMap<String, Box<dyn Provider>>> = OnceLock::new();
234 | 
235 | pub fn setup_providers(elephant: bool) {
236 |     let mut providers: HashMap<String, Box<dyn Provider>> = HashMap::new();
237 |     providers.insert("dmenu".to_string(), Box::new(Dmenu::new()));
238 | 
239 |     let provider_list: Vec<String> = {
240 |         let config = get_config();
241 | 
242 |         if let Some(val) = &config.installed_providers {
243 |             val.clone()
244 |         } else if elephant {
245 |             match Command::new("elephant").arg("listproviders").output() {
246 |                 Ok(output) => match String::from_utf8(output.stdout) {
247 |                     Ok(stdout) => stdout
248 |                         .lines()
249 |                         .filter_map(|line| line.split_once(';').map(|(_, value)| value.to_string()))
250 |                         .collect(),
251 |                     Err(e) => {
252 |                         eprintln!("Error parsing elephant output as UTF-8: {}", e);
253 |                         Vec::new()
254 |                     }
255 |                 },
256 |                 Err(e) => {
257 |                     eprintln!(
258 |                         "Error running 'elephant' command: {}. Make sure it is installed.",
259 |                         e
260 |                     );
261 |                     Vec::new()
262 |                 }
263 |             }
264 |         } else {
265 |             Vec::new()
266 |         }
267 |     };
268 | 
269 |     provider_list.into_iter().for_each(|p| {
270 |         match p.as_str() {
271 |             "calc" => providers.insert("calc".to_string(), Box::new(Calc::new())),
272 |             "clipboard" => providers.insert("clipboard".to_string(), Box::new(Clipboard::new())),
273 |             "files" => providers.insert("files".to_string(), Box::new(Files::new())),
274 |             "symbols" => providers.insert("symbols".to_string(), Box::new(Symbols::new())),
275 |             "unicode" => providers.insert("unicode".to_string(), Box::new(Unicode::new())),
276 |             "providerlist" => {
277 |                 providers.insert("providerlist".to_string(), Box::new(Providerlist::new()))
278 |             }
279 |             // provider if provider.starts_with("menus:") => providers.insert(
280 |             //     provider.to_string(),
281 |             //     Box::new(DefaultProvider::new(provider.to_string())),
282 |             // ),
283 |             "archlinuxpkgs" => {
284 |                 providers.insert("archlinuxpkgs".to_string(), Box::new(ArchLinuxPkgs::new()))
285 |             }
286 |             "todo" => providers.insert("todo".to_string(), Box::new(Todo::new())),
287 |             provider => providers.insert(
288 |                 provider.to_string(),
289 |                 Box::new(DefaultProvider::new(provider.to_string())),
290 |             ),
291 |         };
292 |     });
293 | 
294 |     PROVIDERS
295 |         .set(providers)
296 |         .expect("couldn't initialize providers.")
297 | }
298 | 


--------------------------------------------------------------------------------
/src/state/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::HashSet;
  2 | use std::sync::{OnceLock, RwLock};
  3 | 
  4 | use crate::keybinds::AfterAction;
  5 | 
  6 | static STATE: OnceLock<RwLock<AppState>> = OnceLock::new();
  7 | 
  8 | #[derive(Debug, Clone, Default)]
  9 | pub struct AppState {
 10 |     current_selection: u32,
 11 |     error: String,
 12 |     async_after: Option<AfterAction>,
 13 |     hide_qa: bool,
 14 |     has_elephant: bool,
 15 |     block_scroll: bool,
 16 |     stay_open_explicit_provider: bool,
 17 |     is_connected: bool,
 18 |     is_connecting: bool,
 19 |     dmenu_keep_open: bool,
 20 |     dmenu_exit_after: bool,
 21 |     dmenu_current: i64,
 22 |     initial_height: Option<i32>,
 23 |     initial_width: Option<i32>,
 24 |     initial_max_height: Option<i32>,
 25 |     initial_max_width: Option<i32>,
 26 |     initial_min_height: Option<i32>,
 27 |     initial_min_width: Option<i32>,
 28 |     parameter_width: Option<i32>,
 29 |     parameter_height: Option<i32>,
 30 |     parameter_min_height: Option<i32>,
 31 |     parameter_min_width: Option<i32>,
 32 |     parameter_max_height: Option<i32>,
 33 |     parameter_max_width: Option<i32>,
 34 |     last_query: String,
 35 |     placeholder: String,
 36 |     initial_placeholder: String,
 37 |     available_themes: HashSet<String>,
 38 |     provider: String,
 39 |     prefix_provider: String,
 40 |     theme: String,
 41 |     is_service: bool,
 42 |     no_search: bool,
 43 |     no_hints: bool,
 44 |     input_only: bool,
 45 |     index: bool,
 46 |     is_dmenu: bool,
 47 |     is_param_close: bool,
 48 |     current_prefix: String,
 49 |     current_set: String,
 50 |     is_visible: bool,
 51 |     query: String,
 52 | }
 53 | 
 54 | pub fn init_app_state() {
 55 |     STATE
 56 |         .set(RwLock::new(AppState::default()))
 57 |         .expect("can't init appstate");
 58 | }
 59 | 
 60 | pub fn get_theme() -> String {
 61 |     STATE.get().unwrap().read().unwrap().theme.clone()
 62 | }
 63 | 
 64 | pub fn set_theme(val: String) {
 65 |     STATE.get().unwrap().write().unwrap().theme = val
 66 | }
 67 | 
 68 | pub fn get_current_selection() -> u32 {
 69 |     STATE.get().unwrap().read().unwrap().current_selection
 70 | }
 71 | 
 72 | pub fn set_current_selection(val: u32) {
 73 |     STATE.get().unwrap().write().unwrap().current_selection = val
 74 | }
 75 | 
 76 | pub fn get_async_after() -> Option<AfterAction> {
 77 |     STATE.get().unwrap().read().unwrap().async_after.clone()
 78 | }
 79 | 
 80 | pub fn set_async_after(val: Option<AfterAction>) {
 81 |     STATE.get().unwrap().write().unwrap().async_after = val
 82 | }
 83 | 
 84 | pub fn get_current_prefix() -> String {
 85 |     STATE.get().unwrap().read().unwrap().current_prefix.clone()
 86 | }
 87 | 
 88 | pub fn set_current_prefix(val: String) {
 89 |     STATE.get().unwrap().write().unwrap().current_prefix = val
 90 | }
 91 | 
 92 | pub fn get_current_set() -> String {
 93 |     STATE.get().unwrap().read().unwrap().current_set.clone()
 94 | }
 95 | 
 96 | pub fn set_current_set(val: String) {
 97 |     STATE.get().unwrap().write().unwrap().current_set = val
 98 | }
 99 | 
100 | pub fn get_provider() -> String {
101 |     STATE.get().unwrap().read().unwrap().provider.clone()
102 | }
103 | 
104 | pub fn set_provider(val: String) {
105 |     STATE.get().unwrap().write().unwrap().provider = val
106 | }
107 | 
108 | pub fn get_prefix_provider() -> String {
109 |     STATE.get().unwrap().read().unwrap().prefix_provider.clone()
110 | }
111 | 
112 | pub fn set_prefix_provider(val: String) {
113 |     STATE.get().unwrap().write().unwrap().prefix_provider = val
114 | }
115 | 
116 | pub fn get_initial_placeholder() -> String {
117 |     STATE
118 |         .get()
119 |         .unwrap()
120 |         .read()
121 |         .unwrap()
122 |         .initial_placeholder
123 |         .clone()
124 | }
125 | 
126 | pub fn set_initial_placeholder(val: String) {
127 |     STATE.get().unwrap().write().unwrap().initial_placeholder = val
128 | }
129 | 
130 | pub fn get_placeholder() -> String {
131 |     STATE.get().unwrap().read().unwrap().placeholder.clone()
132 | }
133 | 
134 | pub fn set_placeholder(val: String) {
135 |     STATE.get().unwrap().write().unwrap().placeholder = val
136 | }
137 | 
138 | pub fn get_error() -> String {
139 |     STATE.get().unwrap().read().unwrap().error.clone()
140 | }
141 | 
142 | pub fn set_error(val: String) {
143 |     STATE.get().unwrap().write().unwrap().error = val
144 | }
145 | 
146 | pub fn get_last_query() -> String {
147 |     STATE.get().unwrap().read().unwrap().last_query.clone()
148 | }
149 | 
150 | pub fn set_last_query(val: String) {
151 |     STATE.get().unwrap().write().unwrap().last_query = val
152 | }
153 | 
154 | pub fn set_is_service(val: bool) {
155 |     STATE.get().unwrap().write().unwrap().is_service = val
156 | }
157 | 
158 | pub fn is_visible() -> bool {
159 |     STATE.get().unwrap().read().unwrap().is_visible
160 | }
161 | 
162 | pub fn set_is_visible(val: bool) {
163 |     STATE.get().unwrap().write().unwrap().is_visible = val;
164 | }
165 | 
166 | pub fn is_block_scroll() -> bool {
167 |     STATE.get().unwrap().read().unwrap().block_scroll
168 | }
169 | 
170 | pub fn set_block_scroll(val: bool) {
171 |     STATE.get().unwrap().write().unwrap().block_scroll = val;
172 | }
173 | 
174 | pub fn has_elephant() -> bool {
175 |     STATE.get().unwrap().read().unwrap().has_elephant
176 | }
177 | 
178 | pub fn set_has_elephant(val: bool) {
179 |     STATE.get().unwrap().write().unwrap().has_elephant = val
180 | }
181 | 
182 | pub fn is_connected() -> bool {
183 |     STATE.get().unwrap().read().unwrap().is_connected
184 | }
185 | 
186 | pub fn set_is_connected(val: bool) {
187 |     STATE.get().unwrap().write().unwrap().is_connected = val
188 | }
189 | 
190 | pub fn is_stay_open_explicit_provider() -> bool {
191 |     STATE
192 |         .get()
193 |         .unwrap()
194 |         .read()
195 |         .unwrap()
196 |         .stay_open_explicit_provider
197 | }
198 | 
199 | pub fn set_is_stay_open_explicit_provider(val: bool) {
200 |     STATE
201 |         .get()
202 |         .unwrap()
203 |         .write()
204 |         .unwrap()
205 |         .stay_open_explicit_provider = val
206 | }
207 | 
208 | pub fn is_connecting() -> bool {
209 |     STATE.get().unwrap().read().unwrap().is_connecting
210 | }
211 | 
212 | pub fn set_is_connecting(val: bool) {
213 |     STATE.get().unwrap().write().unwrap().is_connecting = val
214 | }
215 | 
216 | pub fn is_input_only() -> bool {
217 |     STATE.get().unwrap().read().unwrap().input_only
218 | }
219 | 
220 | pub fn set_input_only(val: bool) {
221 |     STATE.get().unwrap().write().unwrap().input_only = val
222 | }
223 | 
224 | pub fn is_index() -> bool {
225 |     STATE.get().unwrap().read().unwrap().index
226 | }
227 | 
228 | pub fn set_index(val: bool) {
229 |     STATE.get().unwrap().write().unwrap().index = val
230 | }
231 | 
232 | pub fn is_param_close() -> bool {
233 |     STATE.get().unwrap().read().unwrap().is_param_close
234 | }
235 | 
236 | pub fn set_param_close(val: bool) {
237 |     STATE.get().unwrap().write().unwrap().is_param_close = val
238 | }
239 | 
240 | pub fn is_dmenu_keep_open() -> bool {
241 |     STATE.get().unwrap().read().unwrap().dmenu_keep_open
242 | }
243 | 
244 | pub fn set_dmenu_keep_open(val: bool) {
245 |     STATE.get().unwrap().write().unwrap().dmenu_keep_open = val
246 | }
247 | 
248 | pub fn is_dmenu_exit_after() -> bool {
249 |     STATE.get().unwrap().read().unwrap().dmenu_exit_after
250 | }
251 | 
252 | pub fn set_dmenu_exit_after(val: bool) {
253 |     STATE.get().unwrap().write().unwrap().dmenu_exit_after = val
254 | }
255 | 
256 | pub fn is_dmenu() -> bool {
257 |     STATE.get().unwrap().read().unwrap().is_dmenu
258 | }
259 | 
260 | pub fn set_is_dmenu(val: bool) {
261 |     STATE.get().unwrap().write().unwrap().is_dmenu = val
262 | }
263 | 
264 | pub fn is_hide_qa() -> bool {
265 |     STATE.get().unwrap().read().unwrap().hide_qa
266 | }
267 | 
268 | pub fn set_hide_qa(val: bool) {
269 |     STATE.get().unwrap().write().unwrap().hide_qa = val
270 | }
271 | 
272 | pub fn query() -> String {
273 |     STATE.get().unwrap().read().unwrap().query.clone()
274 | }
275 | 
276 | pub fn set_query(val: &str) {
277 |     STATE.get().unwrap().write().unwrap().query = val.to_string()
278 | }
279 | 
280 | pub fn is_no_search() -> bool {
281 |     STATE.get().unwrap().read().unwrap().no_search
282 | }
283 | 
284 | pub fn set_no_search(val: bool) {
285 |     STATE.get().unwrap().write().unwrap().no_search = val
286 | }
287 | 
288 | pub fn is_no_hints() -> bool {
289 |     STATE.get().unwrap().read().unwrap().no_hints
290 | }
291 | 
292 | pub fn set_no_hints(val: bool) {
293 |     STATE.get().unwrap().write().unwrap().no_hints = val
294 | }
295 | 
296 | pub fn is_service() -> bool {
297 |     STATE.get().unwrap().read().unwrap().is_service
298 | }
299 | 
300 | pub fn set_initial_height(val: Option<i32>) {
301 |     STATE.get().unwrap().write().unwrap().initial_height = val
302 | }
303 | 
304 | pub fn set_initial_width(val: Option<i32>) {
305 |     STATE.get().unwrap().write().unwrap().initial_width = val
306 | }
307 | 
308 | pub fn set_initial_max_height(val: Option<i32>) {
309 |     STATE.get().unwrap().write().unwrap().initial_max_height = val
310 | }
311 | 
312 | pub fn set_initial_max_width(val: Option<i32>) {
313 |     STATE.get().unwrap().write().unwrap().initial_max_width = val
314 | }
315 | 
316 | pub fn set_initial_min_height(val: Option<i32>) {
317 |     STATE.get().unwrap().write().unwrap().initial_min_height = val
318 | }
319 | 
320 | pub fn set_initial_min_width(val: Option<i32>) {
321 |     STATE.get().unwrap().write().unwrap().initial_min_width = val
322 | }
323 | 
324 | pub fn get_initial_height() -> Option<i32> {
325 |     STATE.get().unwrap().read().unwrap().initial_height
326 | }
327 | 
328 | pub fn get_initial_width() -> Option<i32> {
329 |     STATE.get().unwrap().read().unwrap().initial_width
330 | }
331 | 
332 | pub fn get_initial_min_height() -> Option<i32> {
333 |     STATE.get().unwrap().read().unwrap().initial_min_height
334 | }
335 | 
336 | pub fn get_initial_min_width() -> Option<i32> {
337 |     STATE.get().unwrap().read().unwrap().initial_min_width
338 | }
339 | 
340 | pub fn get_initial_max_height() -> Option<i32> {
341 |     STATE.get().unwrap().read().unwrap().initial_max_height
342 | }
343 | 
344 | pub fn get_initial_max_width() -> Option<i32> {
345 |     STATE.get().unwrap().read().unwrap().initial_max_width
346 | }
347 | 
348 | pub fn set_parameter_height(val: Option<i32>) {
349 |     STATE.get().unwrap().write().unwrap().parameter_height = val
350 | }
351 | 
352 | pub fn set_parameter_width(val: Option<i32>) {
353 |     STATE.get().unwrap().write().unwrap().parameter_width = val
354 | }
355 | 
356 | pub fn set_parameter_min_height(val: Option<i32>) {
357 |     STATE.get().unwrap().write().unwrap().parameter_min_height = val
358 | }
359 | 
360 | pub fn set_parameter_min_width(val: Option<i32>) {
361 |     STATE.get().unwrap().write().unwrap().parameter_min_width = val
362 | }
363 | 
364 | pub fn set_parameter_max_height(val: Option<i32>) {
365 |     STATE.get().unwrap().write().unwrap().parameter_max_height = val
366 | }
367 | 
368 | pub fn set_parameter_max_width(val: Option<i32>) {
369 |     STATE.get().unwrap().write().unwrap().parameter_max_width = val
370 | }
371 | 
372 | pub fn get_parameter_height() -> Option<i32> {
373 |     STATE.get().unwrap().read().unwrap().parameter_height
374 | }
375 | 
376 | pub fn get_parameter_width() -> Option<i32> {
377 |     STATE.get().unwrap().read().unwrap().parameter_width
378 | }
379 | 
380 | pub fn get_parameter_min_height() -> Option<i32> {
381 |     STATE.get().unwrap().read().unwrap().parameter_min_height
382 | }
383 | 
384 | pub fn get_parameter_min_width() -> Option<i32> {
385 |     STATE.get().unwrap().read().unwrap().parameter_min_width
386 | }
387 | 
388 | pub fn get_parameter_max_height() -> Option<i32> {
389 |     STATE.get().unwrap().read().unwrap().parameter_max_height
390 | }
391 | 
392 | pub fn get_parameter_max_width() -> Option<i32> {
393 |     STATE.get().unwrap().read().unwrap().parameter_max_width
394 | }
395 | 
396 | pub fn get_dmenu_current() -> i64 {
397 |     STATE.get().unwrap().read().unwrap().dmenu_current
398 | }
399 | 
400 | pub fn set_dmenu_current(val: i64) {
401 |     STATE.get().unwrap().write().unwrap().dmenu_current = val
402 | }
403 | 
404 | pub fn add_theme(val: String) {
405 |     STATE
406 |         .get()
407 |         .unwrap()
408 |         .write()
409 |         .unwrap()
410 |         .available_themes
411 |         .insert(val);
412 | }
413 | 
414 | pub fn has_theme(val: &str) -> bool {
415 |     STATE
416 |         .get()
417 |         .unwrap()
418 |         .read()
419 |         .unwrap()
420 |         .available_themes
421 |         .contains(val)
422 | }
423 | 


--------------------------------------------------------------------------------
/src/keybinds.rs:
--------------------------------------------------------------------------------
  1 | use crate::config::get_config;
  2 | use crate::providers::PROVIDERS;
  3 | use gtk4::gdk::{self, Key};
  4 | use serde::{Deserialize, Serialize};
  5 | use std::collections::HashMap;
  6 | use std::sync::{LazyLock, RwLock};
  7 | 
  8 | pub const ACTION_CLOSE: &str = "%CLOSE%";
  9 | pub const ACTION_SELECT_NEXT: &str = "%NEXT%";
 10 | pub const ACTION_SELECT_PREVIOUS: &str = "%PREVIOUS%";
 11 | pub const ACTION_TOGGLE_EXACT: &str = "%TOGGLE_EXACT%";
 12 | pub const ACTION_RESUME_LAST_QUERY: &str = "%RESUME_LAST_QUERY%";
 13 | pub const ACTION_QUICK_ACTIVATE: &str = "%QUICK_ACTIVATE%";
 14 | pub const ACTION_SELECT_PAGE_DOWN: &str = "%PAGE_DOWN%";
 15 | pub const ACTION_SELECT_PAGE_UP: &str = "%PAGE_UP%";
 16 | 
 17 | #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 18 | pub enum AfterAction {
 19 |     KeepOpen,
 20 |     #[default]
 21 |     Close,
 22 |     Nothing,
 23 |     Reload,
 24 |     ClearReload,
 25 |     AsyncClearReload,
 26 |     AsyncReload,
 27 |     AsyncReloadKeepSelection,
 28 | }
 29 | 
 30 | #[derive(Debug, Clone, Serialize, Deserialize)]
 31 | pub struct Action {
 32 |     pub action: String,
 33 |     pub global: Option<bool>,
 34 |     pub default: Option<bool>,
 35 | 
 36 |     #[serde(default = "default_bind")]
 37 |     pub bind: Option<String>,
 38 | 
 39 |     #[serde(default = "default_after")]
 40 |     pub after: Option<AfterAction>,
 41 | 
 42 |     pub label: Option<String>,
 43 | }
 44 | 
 45 | fn default_bind() -> Option<String> {
 46 |     Some("Return".to_string())
 47 | }
 48 | 
 49 | fn default_after() -> Option<AfterAction> {
 50 |     Some(AfterAction::Close)
 51 | }
 52 | 
 53 | static BINDS: LazyLock<RwLock<HashMap<Key, HashMap<gdk::ModifierType, Action>>>> =
 54 |     LazyLock::new(RwLock::default);
 55 | static PROVIDER_BINDS: LazyLock<
 56 |     RwLock<HashMap<String, HashMap<Key, HashMap<gdk::ModifierType, Vec<Action>>>>>,
 57 | > = LazyLock::new(RwLock::default);
 58 | static PROVIDER_GLOBAL_BINDS: LazyLock<
 59 |     RwLock<HashMap<String, HashMap<Key, HashMap<gdk::ModifierType, Vec<Action>>>>>,
 60 | > = LazyLock::new(RwLock::default);
 61 | 
 62 | pub static MODIFIERS: LazyLock<HashMap<&'static str, gdk::ModifierType>> = LazyLock::new(|| {
 63 |     let mut map = HashMap::new();
 64 |     map.insert("ctrl", gdk::ModifierType::CONTROL_MASK);
 65 |     map.insert("alt", gdk::ModifierType::ALT_MASK);
 66 |     map.insert("shift", gdk::ModifierType::SHIFT_MASK);
 67 |     map.insert("super", gdk::ModifierType::SUPER_MASK);
 68 |     map
 69 | });
 70 | 
 71 | pub fn setup_binds() {
 72 |     PROVIDERS.get().unwrap().iter().for_each(|(k, v)| {
 73 |         v.get_actions().iter().for_each(|v| {
 74 |             parse_bind(v, k).unwrap();
 75 |         });
 76 |     });
 77 | 
 78 |     let config = get_config();
 79 | 
 80 |     config
 81 |         .providers
 82 |         .actions
 83 |         .get("fallback")
 84 |         .unwrap_or(&Vec::new())
 85 |         .iter()
 86 |         .for_each(|v| {
 87 |             parse_bind(v, "fallback").unwrap();
 88 |         });
 89 | 
 90 |     config.keybinds.close.iter().for_each(|b| {
 91 |         parse_bind(
 92 |             &Action {
 93 |                 action: ACTION_CLOSE.to_string(),
 94 |                 global: None,
 95 |                 default: Some(true),
 96 |                 bind: Some(b.clone()),
 97 |                 label: Some("close".to_string()),
 98 |                 after: None,
 99 |             },
100 |             "",
101 |         )
102 |         .unwrap();
103 |     });
104 | 
105 |     config.keybinds.next.iter().for_each(|b| {
106 |         parse_bind(
107 |             &Action {
108 |                 action: ACTION_SELECT_NEXT.to_string(),
109 |                 default: None,
110 |                 global: Some(true),
111 |                 bind: Some(b.clone()),
112 |                 label: Some("select next".to_string()),
113 |                 after: Some(AfterAction::Nothing),
114 |             },
115 |             "",
116 |         )
117 |         .unwrap();
118 |     });
119 | 
120 |     config.keybinds.previous.iter().for_each(|b| {
121 |         parse_bind(
122 |             &Action {
123 |                 action: ACTION_SELECT_PREVIOUS.to_string(),
124 |                 default: None,
125 |                 global: Some(true),
126 |                 bind: Some(b.clone()),
127 |                 label: Some("select previous".to_string()),
128 |                 after: Some(AfterAction::Nothing),
129 |             },
130 |             "",
131 |         )
132 |         .unwrap();
133 |     });
134 | 
135 |     config.keybinds.toggle_exact.iter().for_each(|b| {
136 |         parse_bind(
137 |             &Action {
138 |                 action: ACTION_TOGGLE_EXACT.to_string(),
139 |                 default: None,
140 |                 global: Some(true),
141 |                 bind: Some(b.clone()),
142 |                 label: Some("toggle exact search".to_string()),
143 |                 after: Some(AfterAction::Nothing),
144 |             },
145 |             "",
146 |         )
147 |         .unwrap();
148 |     });
149 | 
150 |     config.keybinds.resume_last_query.iter().for_each(|b| {
151 |         parse_bind(
152 |             &Action {
153 |                 action: ACTION_RESUME_LAST_QUERY.to_string(),
154 |                 bind: Some(b.clone()),
155 |                 default: None,
156 |                 global: Some(true),
157 |                 label: Some("resume last query".to_string()),
158 |                 after: Some(AfterAction::Nothing),
159 |             },
160 |             "",
161 |         )
162 |         .unwrap();
163 |     });
164 | 
165 |     config.keybinds.page_down.iter().for_each(|b| {
166 |         parse_bind(
167 |             &Action {
168 |                 action: ACTION_SELECT_PAGE_DOWN.to_string(),
169 |                 default: None,
170 |                 global: Some(true),
171 |                 bind: Some(b.clone()),
172 |                 label: Some("select page down".to_string()),
173 |                 after: Some(AfterAction::Nothing),
174 |             },
175 |             "",
176 |         )
177 |         .unwrap();
178 |     });
179 | 
180 |     config.keybinds.page_up.iter().for_each(|b| {
181 |         parse_bind(
182 |             &Action {
183 |                 action: ACTION_SELECT_PAGE_UP.to_string(),
184 |                 default: None,
185 |                 global: Some(true),
186 |                 bind: Some(b.clone()),
187 |                 label: Some("select page up".to_string()),
188 |                 after: Some(AfterAction::Nothing),
189 |             },
190 |             "",
191 |         )
192 |         .unwrap();
193 |     });
194 | 
195 |     if let Some(qa) = &config.keybinds.quick_activate {
196 |         qa.iter().enumerate().for_each(|(k, s)| {
197 |             let action_str = format!("{ACTION_QUICK_ACTIVATE}:{k}");
198 | 
199 |             parse_bind(
200 |                 &Action {
201 |                     default: None,
202 |                     action: action_str,
203 |                     global: Some(true),
204 |                     bind: Some(s.clone()),
205 |                     label: Some("quick activate".to_string()),
206 |                     after: None,
207 |                 },
208 |                 "",
209 |             )
210 |             .unwrap();
211 |         });
212 |     }
213 | }
214 | 
215 | fn parse_bind(b: &Action, provider: &str) -> Result<(), Box<dyn std::error::Error>> {
216 |     let mut b = b.clone();
217 | 
218 |     if let Some((first, _)) = b.action.split_once(":")
219 |         && b.action.ends_with(":keep")
220 |     {
221 |         b.action = first.to_string();
222 |     }
223 | 
224 |     let mut fields = b.bind.as_ref().unwrap().split_whitespace().peekable();
225 | 
226 |     if fields.peek().is_none() {
227 |         return Err("incorrect bind".into());
228 |     }
229 | 
230 |     let mut modifiers_list = Vec::new();
231 |     let mut key: Option<Key> = None;
232 | 
233 |     for field in fields {
234 |         if let Some(&modifier) = MODIFIERS.get(field) {
235 |             modifiers_list.push(modifier);
236 |             continue;
237 |         }
238 | 
239 |         key = match Key::from_name(field.to_string()) {
240 |             Some(k) => Some(k),
241 |             None => {
242 |                 eprintln!(
243 |                     "Keybind Error: unable to create key from name: '{}' in '{}'.",
244 |                     field,
245 |                     b.bind.as_ref().unwrap()
246 |                 );
247 |                 std::process::exit(1);
248 |             }
249 |         };
250 |     }
251 | 
252 |     let modifier = modifiers_list
253 |         .iter()
254 |         .fold(gdk::ModifierType::empty(), |acc, &m| acc | m);
255 | 
256 |     let key = key.ok_or("incorrect bind")?;
257 |     if provider.is_empty() {
258 |         let mut binds = BINDS.write().unwrap();
259 |         binds.entry(key).or_default().insert(modifier, b.clone());
260 |         return Ok(());
261 |     }
262 | 
263 |     if !b.global.unwrap_or(false) {
264 |         let mut provider_binds = PROVIDER_BINDS.write().unwrap();
265 | 
266 |         provider_binds
267 |             .entry(provider.to_string())
268 |             .or_default()
269 |             .entry(key)
270 |             .or_default()
271 |             .entry(modifier)
272 |             .or_default()
273 |             .push(b.clone());
274 |     } else {
275 |         let mut global_binds = PROVIDER_GLOBAL_BINDS.write().unwrap();
276 |         global_binds
277 |             .entry(provider.to_string())
278 |             .or_default()
279 |             .entry(key)
280 |             .or_default()
281 |             .entry(modifier)
282 |             .or_default()
283 |             .push(b.clone());
284 |     }
285 | 
286 |     Ok(())
287 | }
288 | 
289 | pub fn get_bind(key: Key, modifier: gdk::ModifierType) -> Option<Action> {
290 |     if get_config().debug {
291 |         if modifier != gdk::ModifierType::empty() {
292 |             let mut modifiers = Vec::new();
293 | 
294 |             modifier.iter().for_each(|mt| {
295 |                 let m = if let Some((key, _)) = MODIFIERS.iter().find(|&(_, &v)| v == mt) {
296 |                     key
297 |                 } else {
298 |                     "modifier not supported"
299 |                 };
300 | 
301 |                 modifiers.push(m);
302 |             });
303 | 
304 |             println!("bind: {} {}", modifiers.join(" "), key.name().unwrap());
305 |         } else {
306 |             println!("bind: {}", key.name().unwrap());
307 |         }
308 |     }
309 | 
310 |     BINDS
311 |         .read()
312 |         .ok()?
313 |         .get(&key.to_lower())?
314 |         .get(&modifier)
315 |         .cloned()
316 | }
317 | 
318 | pub fn get_provider_bind(
319 |     provider: &str,
320 |     key: Key,
321 |     modifier: gdk::ModifierType,
322 |     actions: &[String],
323 | ) -> Option<Action> {
324 |     let mut action = None;
325 | 
326 |     // remove hardcoded global binds for elephant
327 |     let actions: Vec<_> = actions.iter().filter(|a| **a != "menus:parent").collect();
328 | 
329 |     if let Ok(binds) = PROVIDER_BINDS.read() {
330 |         action = binds
331 |             .get(provider)
332 |             .and_then(|keys| keys.get(&key.to_lower()))
333 |             .and_then(|modifiers| modifiers.get(&modifier))
334 |             .and_then(|actions_list| {
335 |                 actions_list
336 |                     .iter()
337 |                     .find(|action| actions.contains(&&action.action))
338 |                     .cloned()
339 |             });
340 | 
341 |         if action.is_none() {
342 |             action = binds
343 |                 .get("fallback")
344 |                 .and_then(|keys| keys.get(&key.to_lower()))
345 |                 .and_then(|modifiers| modifiers.get(&modifier))
346 |                 .and_then(|actions_list| {
347 |                     actions_list
348 |                         .iter()
349 |                         .find(|action| actions.contains(&&action.action))
350 |                         .cloned()
351 |                 });
352 |         }
353 |     }
354 | 
355 |     if actions.len() == 1 && action.is_none() && key == gdk::Key::Return {
356 |         return Some(Action {
357 |             action: actions.first().unwrap().to_string(),
358 |             global: None,
359 |             default: Some(true),
360 |             bind: Some("Return".to_string()),
361 |             after: None,
362 |             label: None,
363 |         });
364 |     }
365 | 
366 |     action
367 | }
368 | 
369 | pub fn get_provider_global_bind(
370 |     provider: &str,
371 |     key: Key,
372 |     modifier: gdk::ModifierType,
373 | ) -> Option<Action> {
374 |     PROVIDER_GLOBAL_BINDS
375 |         .read()
376 |         .ok()?
377 |         .get(provider)?
378 |         .get(&key.to_lower())?
379 |         .get(&modifier)?
380 |         .first()
381 |         .cloned()
382 | }
383 | 


--------------------------------------------------------------------------------
/src/config.rs:
--------------------------------------------------------------------------------
  1 | use config::{Config, ConfigError, File, FileFormat};
  2 | use serde::{Deserialize, Serialize};
  3 | use std::{collections::HashMap, sync::OnceLock};
  4 | 
  5 | use crate::{keybinds::Action, state::set_error};
  6 | 
  7 | static LOADED_CONFIG: OnceLock<Walker> = OnceLock::new();
  8 | const DEFAULT_CONFIG: &str = include_str!("../resources/config.toml");
  9 | 
 10 | #[derive(Debug, Clone, Serialize, Deserialize)]
 11 | pub struct Walker {
 12 |     pub debug: bool,
 13 |     pub force_keyboard_focus: bool,
 14 |     pub disable_mouse: bool,
 15 |     pub click_to_close: bool,
 16 |     pub close_when_open: bool,
 17 |     pub selection_wrap: bool,
 18 |     pub global_argument_delimiter: String,
 19 |     pub theme: String,
 20 |     pub exact_search_prefix: String,
 21 |     pub providers: Providers,
 22 |     pub installed_providers: Option<Vec<String>>,
 23 |     pub keybinds: Keybinds,
 24 |     pub shell: Shell,
 25 |     pub additional_theme_location: Option<String>,
 26 |     pub placeholders: Option<HashMap<String, Placeholder>>,
 27 |     pub page_jump_items: u32
 28 | }
 29 | 
 30 | // Partial config for user overrides
 31 | #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 32 | #[serde(default)]
 33 | struct PartialWalker {
 34 |     #[serde(skip_serializing_if = "Option::is_none")]
 35 |     pub debug: Option<bool>,
 36 |     #[serde(skip_serializing_if = "Option::is_none")]
 37 |     pub force_keyboard_focus: Option<bool>,
 38 |     #[serde(skip_serializing_if = "Option::is_none")]
 39 |     pub disable_mouse: Option<bool>,
 40 |     #[serde(skip_serializing_if = "Option::is_none")]
 41 |     pub click_to_close: Option<bool>,
 42 |     #[serde(skip_serializing_if = "Option::is_none")]
 43 |     pub close_when_open: Option<bool>,
 44 |     #[serde(skip_serializing_if = "Option::is_none")]
 45 |     pub selection_wrap: Option<bool>,
 46 |     #[serde(skip_serializing_if = "Option::is_none")]
 47 |     pub global_argument_delimiter: Option<String>,
 48 |     #[serde(skip_serializing_if = "Option::is_none")]
 49 |     pub theme: Option<String>,
 50 |     #[serde(skip_serializing_if = "Option::is_none")]
 51 |     pub exact_search_prefix: Option<String>,
 52 |     #[serde(skip_serializing_if = "Option::is_none")]
 53 |     pub providers: Option<PartialProviders>,
 54 |     #[serde(skip_serializing_if = "Option::is_none")]
 55 |     pub installed_providers: Option<Vec<String>>,
 56 |     #[serde(skip_serializing_if = "Option::is_none")]
 57 |     pub keybinds: Option<PartialKeybinds>,
 58 |     #[serde(skip_serializing_if = "Option::is_none")]
 59 |     pub shell: Option<PartialShell>,
 60 |     #[serde(skip_serializing_if = "Option::is_none")]
 61 |     pub additional_theme_location: Option<String>,
 62 |     #[serde(skip_serializing_if = "Option::is_none")]
 63 |     pub placeholders: Option<HashMap<String, Placeholder>>,
 64 |     #[serde(skip_serializing_if = "Option::is_none")]
 65 |     pub page_jump_items: Option<u32>,
 66 | }
 67 | 
 68 | #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 69 | #[serde(default)]
 70 | struct PartialProviders {
 71 |     #[serde(skip_serializing_if = "Option::is_none")]
 72 |     pub default: Option<Vec<String>>,
 73 |     #[serde(skip_serializing_if = "Option::is_none")]
 74 |     pub max_results: Option<i32>,
 75 |     #[serde(skip_serializing_if = "Option::is_none")]
 76 |     pub empty: Option<Vec<String>>,
 77 |     #[serde(skip_serializing_if = "Option::is_none")]
 78 |     pub prefixes: Option<Vec<Prefix>>,
 79 |     #[serde(skip_serializing_if = "Option::is_none")]
 80 |     pub clipboard: Option<PartialClipboard>,
 81 |     #[serde(skip_serializing_if = "Option::is_none")]
 82 |     pub sets: Option<HashMap<String, ProviderSet>>,
 83 |     #[serde(skip_serializing_if = "Option::is_none")]
 84 |     pub actions: Option<HashMap<String, Vec<Action>>>,
 85 |     #[serde(skip_serializing_if = "Option::is_none")]
 86 |     pub max_results_provider: Option<HashMap<String, i32>>,
 87 | }
 88 | 
 89 | #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 90 | #[serde(default)]
 91 | struct PartialKeybinds {
 92 |     #[serde(skip_serializing_if = "Option::is_none")]
 93 |     pub close: Option<Vec<String>>,
 94 |     #[serde(skip_serializing_if = "Option::is_none")]
 95 |     pub next: Option<Vec<String>>,
 96 |     #[serde(skip_serializing_if = "Option::is_none")]
 97 |     pub previous: Option<Vec<String>>,
 98 |     #[serde(skip_serializing_if = "Option::is_none")]
 99 |     pub toggle_exact: Option<Vec<String>>,
100 |     #[serde(skip_serializing_if = "Option::is_none")]
101 |     pub resume_last_query: Option<Vec<String>>,
102 |     #[serde(skip_serializing_if = "Option::is_none")]
103 |     pub quick_activate: Option<Vec<String>>,
104 |     #[serde(skip_serializing_if = "Option::is_none")]
105 |     pub page_down: Option<Vec<String>>,
106 |     #[serde(skip_serializing_if = "Option::is_none")]
107 |     pub page_up: Option<Vec<String>>,
108 | }
109 | 
110 | #[derive(Debug, Clone, Serialize, Deserialize, Default)]
111 | #[serde(default)]
112 | struct PartialShell {
113 |     #[serde(skip_serializing_if = "Option::is_none")]
114 |     pub anchor_top: Option<bool>,
115 |     #[serde(skip_serializing_if = "Option::is_none")]
116 |     pub anchor_bottom: Option<bool>,
117 |     #[serde(skip_serializing_if = "Option::is_none")]
118 |     pub anchor_left: Option<bool>,
119 |     #[serde(skip_serializing_if = "Option::is_none")]
120 |     pub anchor_right: Option<bool>,
121 | }
122 | 
123 | #[derive(Debug, Clone, Serialize, Deserialize, Default)]
124 | #[serde(default)]
125 | struct PartialClipboard {
126 |     #[serde(skip_serializing_if = "Option::is_none")]
127 |     pub time_format: Option<String>,
128 | }
129 | 
130 | impl Walker {
131 |     pub fn new() -> Result<Self, ConfigError> {
132 |         let default_config = Config::builder()
133 |             .add_source(File::from_str(DEFAULT_CONFIG, FileFormat::Toml))
134 |             .build()?;
135 | 
136 |         let mut config: Walker = default_config.try_deserialize()?;
137 | 
138 |         if let Some(user_config_path) =
139 |             xdg::BaseDirectories::with_prefix("walker").find_config_file("config.toml")
140 |         {
141 |             let user_config = Config::builder()
142 |                 .add_source(File::from(user_config_path))
143 |                 .build()?;
144 | 
145 |             match user_config.try_deserialize() {
146 |                 Ok(res) => config.merge(res),
147 |                 Err(error) => {
148 |                     set_error(format!("Config: {error}"));
149 |                     println!("{error}");
150 |                 }
151 |             }
152 |         }
153 | 
154 |         let env_config = Config::builder()
155 |             .add_source(config::Environment::with_prefix("WALKER").separator("_"))
156 |             .build()?;
157 | 
158 |         if let Ok(partial) = env_config.try_deserialize::<PartialWalker>() {
159 |             config.merge(partial);
160 |         }
161 | 
162 |         Ok(config)
163 |     }
164 | 
165 |     fn merge(&mut self, partial: PartialWalker) {
166 |         if let Some(v) = partial.debug {
167 |             self.debug = v;
168 |         }
169 |         if let Some(v) = partial.force_keyboard_focus {
170 |             self.force_keyboard_focus = v;
171 |         }
172 |         if let Some(v) = partial.disable_mouse {
173 |             self.disable_mouse = v;
174 |         }
175 |         if let Some(v) = partial.click_to_close {
176 |             self.click_to_close = v;
177 |         }
178 |         if let Some(v) = partial.close_when_open {
179 |             self.close_when_open = v;
180 |         }
181 |         if let Some(v) = partial.selection_wrap {
182 |             self.selection_wrap = v;
183 |         }
184 |         if let Some(v) = partial.global_argument_delimiter {
185 |             self.global_argument_delimiter = v;
186 |         }
187 |         if let Some(v) = partial.theme {
188 |             self.theme = v;
189 |         }
190 |         if let Some(v) = partial.exact_search_prefix {
191 |             self.exact_search_prefix = v;
192 |         }
193 |         if let Some(v) = partial.installed_providers {
194 |             self.installed_providers = Some(v);
195 |         }
196 |         if let Some(v) = partial.additional_theme_location {
197 |             self.additional_theme_location = Some(v);
198 |         }
199 |         if let Some(v) = partial.placeholders {
200 |             self.placeholders = Some(v);
201 |         }
202 |         if let Some(v) = partial.page_jump_items {
203 |             self.page_jump_items = v;
204 |         }
205 | 
206 |         if let Some(p) = partial.providers {
207 |             self.providers.merge(p);
208 |         }
209 |         if let Some(k) = partial.keybinds {
210 |             self.keybinds.merge(k);
211 |         }
212 |         if let Some(s) = partial.shell {
213 |             self.shell.merge(s);
214 |         }
215 |     }
216 | }
217 | 
218 | impl Providers {
219 |     fn merge(&mut self, partial: PartialProviders) {
220 |         if let Some(v) = partial.default {
221 |             self.default = v;
222 |         }
223 |         if let Some(v) = partial.empty {
224 |             self.empty = v;
225 |         }
226 |         if let Some(v) = partial.prefixes {
227 |             self.prefixes = v;
228 |         }
229 |         if let Some(v) = partial.sets {
230 |             self.sets = v;
231 |         }
232 |         if let Some(v) = partial.max_results {
233 |             self.max_results = v;
234 |         }
235 | 
236 |         if let Some(v) = partial.max_results_provider {
237 |             v.iter().for_each(|(key, value)| {
238 |                 self.max_results_provider.insert(key.clone(), *value);
239 |             });
240 |         }
241 | 
242 |         if let Some(v) = partial.actions {
243 |             v.iter().for_each(|(key, value)| {
244 |                 if !self.actions.contains_key(key) {
245 |                     self.actions.insert(key.clone(), value.clone());
246 |                 } else {
247 |                     let mut defaults: HashMap<String, Action> = self
248 |                         .actions
249 |                         .get(key)
250 |                         .unwrap()
251 |                         .iter()
252 |                         .map(|action| (action.action.clone(), action.clone()))
253 |                         .collect();
254 | 
255 |                     let user: HashMap<String, Action> = value
256 |                         .iter()
257 |                         .map(|action| (action.action.clone(), action.clone()))
258 |                         .collect();
259 | 
260 |                     defaults.extend(user);
261 | 
262 |                     self.actions
263 |                         .insert(key.clone(), defaults.into_values().collect());
264 |                 }
265 |             });
266 |         }
267 |         if let Some(c) = partial.clipboard {
268 |             self.clipboard.merge(c);
269 |         }
270 |     }
271 | }
272 | 
273 | impl Keybinds {
274 |     fn merge(&mut self, partial: PartialKeybinds) {
275 |         if let Some(v) = partial.close {
276 |             self.close = v;
277 |         }
278 |         if let Some(v) = partial.next {
279 |             self.next = v;
280 |         }
281 |         if let Some(v) = partial.previous {
282 |             self.previous = v;
283 |         }
284 |         if let Some(v) = partial.toggle_exact {
285 |             self.toggle_exact = v;
286 |         }
287 |         if let Some(v) = partial.resume_last_query {
288 |             self.resume_last_query = v;
289 |         }
290 |         if let Some(v) = partial.quick_activate {
291 |             self.quick_activate = Some(v);
292 |         }
293 |         if let Some(v) = partial.page_down {
294 |             self.page_down = v;
295 |         }
296 |         if let Some(v) = partial.page_up {
297 |             self.page_up = v;
298 |         }
299 |     }
300 | }
301 | 
302 | impl Shell {
303 |     fn merge(&mut self, partial: PartialShell) {
304 |         if let Some(v) = partial.anchor_top {
305 |             self.anchor_top = v;
306 |         }
307 |         if let Some(v) = partial.anchor_bottom {
308 |             self.anchor_bottom = v;
309 |         }
310 |         if let Some(v) = partial.anchor_left {
311 |             self.anchor_left = v;
312 |         }
313 |         if let Some(v) = partial.anchor_right {
314 |             self.anchor_right = v;
315 |         }
316 |     }
317 | }
318 | 
319 | impl Clipboard {
320 |     fn merge(&mut self, partial: PartialClipboard) {
321 |         if let Some(v) = partial.time_format {
322 |             self.time_format = v;
323 |         }
324 |     }
325 | }
326 | 
327 | #[derive(Debug, Clone, Serialize, Deserialize)]
328 | pub struct CustomKeybind {}
329 | 
330 | #[derive(Debug, Clone, Serialize, Deserialize)]
331 | pub struct Shell {
332 |     pub anchor_top: bool,
333 |     pub anchor_bottom: bool,
334 |     pub anchor_left: bool,
335 |     pub anchor_right: bool,
336 | }
337 | 
338 | #[derive(Debug, Clone, Serialize, Deserialize)]
339 | pub struct Placeholder {
340 |     pub input: String,
341 |     pub list: String,
342 | }
343 | 
344 | #[derive(Debug, Clone, Serialize, Deserialize)]
345 | pub struct Keybinds {
346 |     pub close: Vec<String>,
347 |     pub next: Vec<String>,
348 |     pub previous: Vec<String>,
349 |     pub toggle_exact: Vec<String>,
350 |     pub resume_last_query: Vec<String>,
351 |     pub quick_activate: Option<Vec<String>>,
352 |     pub page_down: Vec<String>,
353 |     pub page_up: Vec<String>,
354 | }
355 | 
356 | #[derive(Debug, Clone, Serialize, Deserialize)]
357 | pub struct Providers {
358 |     pub default: Vec<String>,
359 |     pub empty: Vec<String>,
360 |     pub previews: Vec<String>,
361 |     pub max_results: i32,
362 |     pub max_results_provider: HashMap<String, i32>,
363 |     pub prefixes: Vec<Prefix>,
364 |     pub clipboard: Clipboard,
365 |     pub actions: HashMap<String, Vec<Action>>,
366 |     pub sets: HashMap<String, ProviderSet>,
367 | }
368 | 
369 | #[derive(Debug, Clone, Serialize, Deserialize)]
370 | pub struct ProviderSet {
371 |     pub default: Vec<String>,
372 |     pub empty: Vec<String>,
373 | }
374 | 
375 | #[derive(Debug, Clone, Serialize, Deserialize)]
376 | pub struct Prefix {
377 |     pub prefix: String,
378 |     pub provider: String,
379 | }
380 | 
381 | #[derive(Debug, Clone, Serialize, Deserialize)]
382 | pub struct Clipboard {
383 |     pub time_format: String,
384 | }
385 | 
386 | pub fn load() -> Result<(), Box<dyn std::error::Error>> {
387 |     LOADED_CONFIG
388 |         .set(Walker::new()?)
389 |         .map_err(|_| "Failed to set loaded config".into())
390 | }
391 | 
392 | pub fn get_config() -> &'static Walker {
393 |     LOADED_CONFIG.get().expect("config not initialized")
394 | }
395 | 


--------------------------------------------------------------------------------
/src/preview/files_preview.rs:
--------------------------------------------------------------------------------
  1 | use super::PreviewHandler;
  2 | use crate::protos::generated_proto::query::query_response::Item;
  3 | use crate::ui::window::get_selected_item;
  4 | use crate::{quit, with_window};
  5 | use gtk4::gdk::ContentProvider;
  6 | use gtk4::gio::{self, Cancellable, File};
  7 | use gtk4::glib::{self, Bytes};
  8 | use gtk4::{
  9 |     Box as GtkBox, Builder, ContentFit, DragSource, Image, Orientation, Picture, PolicyType,
 10 |     ScrolledWindow, Stack, TextView, Video, WrapMode, gdk_pixbuf, prelude::*,
 11 | };
 12 | use poppler::{Document, Page};
 13 | use std::cell::RefCell;
 14 | use std::collections::HashMap;
 15 | use std::fs;
 16 | use std::path::Path;
 17 | use std::rc::Rc;
 18 | 
 19 | #[derive(Debug)]
 20 | pub struct FilesPreviewHandler {
 21 |     cached_preview: RefCell<Option<FilePreview>>,
 22 | }
 23 | 
 24 | #[derive(Debug)]
 25 | pub struct FilePreview {
 26 |     pub box_widget: GtkBox,
 27 |     preview_area: Stack,
 28 |     current_file: String,
 29 |     image_cache: Rc<RefCell<HashMap<String, gtk4::gdk::Texture>>>,
 30 |     pub current_video_cancellable: Rc<RefCell<Option<Cancellable>>>,
 31 | }
 32 | 
 33 | impl FilesPreviewHandler {
 34 |     pub fn new() -> Self {
 35 |         Self {
 36 |             cached_preview: RefCell::new(None),
 37 |         }
 38 |     }
 39 | }
 40 | 
 41 | impl PreviewHandler for FilesPreviewHandler {
 42 |     fn clear_cache(&self) {
 43 |         let mut cached_preview = self.cached_preview.borrow_mut();
 44 |         if let Some(preview) = cached_preview.as_mut() {
 45 |             preview.clear_preview();
 46 |             preview.image_cache.borrow_mut().clear();
 47 |         }
 48 |         *cached_preview = None;
 49 |     }
 50 | 
 51 |     fn handle(&self, item: &Item, preview: &GtkBox, builder: &Builder) {
 52 |         let file_path = if item.preview.is_empty() {
 53 |             item.text.as_str()
 54 |         } else {
 55 |             item.preview.as_str()
 56 |         };
 57 | 
 58 |         if !Path::new(file_path).exists() {
 59 |             return;
 60 |         }
 61 | 
 62 |         let Some(current) = get_selected_item() else {
 63 |             return;
 64 |         };
 65 | 
 66 |         if current != *item {
 67 |             return;
 68 |         }
 69 | 
 70 |         let mut cached_preview = self.cached_preview.borrow_mut();
 71 |         if let Some(existing) = cached_preview.as_ref()
 72 |             && existing.current_file != item.text
 73 |         {
 74 |             *cached_preview = None;
 75 |         }
 76 | 
 77 |         if cached_preview.is_none()
 78 |             && let Ok(preview) =
 79 |                 FilePreview::new_with_builder(&builder).or_else(|_| FilePreview::new())
 80 |         {
 81 |             *cached_preview = Some(preview);
 82 |         } else if cached_preview.is_none() {
 83 |             return;
 84 |         }
 85 | 
 86 |         let file_preview = cached_preview.as_mut().unwrap();
 87 |         if file_preview.preview_file(file_path).is_err() {
 88 |             return;
 89 |         }
 90 | 
 91 |         while let Some(child) = preview.first_child() {
 92 |             child.unparent();
 93 |         }
 94 | 
 95 |         let existing_controllers: Vec<_> = preview
 96 |             .observe_controllers()
 97 |             .into_iter()
 98 |             .filter_map(Result::ok)
 99 |             .collect();
100 |         for controller in existing_controllers {
101 |             if let Ok(drag_source) = controller.downcast::<DragSource>() {
102 |                 preview.remove_controller(&drag_source);
103 |             }
104 |         }
105 | 
106 |         let drag_source = DragSource::new();
107 | 
108 |         let path_copy = file_path.to_string();
109 |         drag_source.connect_prepare(move |_, _, _| {
110 |             let file = File::for_path(&path_copy);
111 |             let uri_string = format!("{}\n", file.uri());
112 |             let b = glib::Bytes::from(uri_string.as_bytes());
113 |             let cp = ContentProvider::for_bytes("text/uri-list", &b);
114 |             Some(cp)
115 |         });
116 | 
117 |         drag_source.connect_drag_begin(|_, _| with_window(|w| w.window.set_visible(false)));
118 |         drag_source.connect_drag_end(|_, _, _| with_window(|w| quit(&w.app, false)));
119 | 
120 |         file_preview.box_widget.set_can_target(false);
121 |         preview.add_controller(drag_source);
122 |         preview.append(&file_preview.box_widget);
123 |         preview.set_visible(get_selected_item().is_some_and(|current| current == *item));
124 |     }
125 | }
126 | 
127 | impl FilePreview {
128 |     pub fn new_with_builder(builder: &Builder) -> Result<Self, Box<dyn std::error::Error>> {
129 |         let box_widget = builder
130 |             .object::<GtkBox>("PreviewBox")
131 |             .ok_or("PreviewBox not found in builder")?;
132 | 
133 |         let preview_area = builder
134 |             .object::<Stack>("PreviewStack")
135 |             .ok_or("PreviewStack not found in builder")?;
136 | 
137 |         Ok(Self {
138 |             box_widget,
139 |             preview_area,
140 |             current_file: String::new(),
141 |             image_cache: Rc::new(RefCell::new(HashMap::new())),
142 |             current_video_cancellable: Rc::new(RefCell::new(None)),
143 |         })
144 |     }
145 | 
146 |     pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
147 |         let box_widget = GtkBox::new(Orientation::Vertical, 0);
148 |         let preview_area = Stack::new();
149 |         box_widget.append(&preview_area);
150 | 
151 |         Ok(Self {
152 |             box_widget,
153 |             preview_area,
154 |             current_file: String::new(),
155 |             image_cache: Rc::new(RefCell::new(HashMap::new())),
156 |             current_video_cancellable: Rc::new(RefCell::new(None)),
157 |         })
158 |     }
159 | 
160 |     pub fn preview_file(&mut self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
161 |         self.current_file = file_path.to_string();
162 |         self.clear_preview();
163 | 
164 |         let Some(guess) = new_mime_guess::from_path(file_path).first() else {
165 |             return self.preview_generic(file_path);
166 |         };
167 | 
168 |         let function = match (guess.type_(), guess.subtype()) {
169 |             (mime::IMAGE, _) => Self::preview_image,
170 |             (mime::APPLICATION, mime::PDF) => Self::preview_pdf,
171 |             (mime::TEXT, _) => Self::preview_text,
172 |             (mime::VIDEO, _) => Self::preview_video,
173 |             _ => Self::preview_generic,
174 |         };
175 | 
176 |         function(self, file_path)
177 |     }
178 | 
179 |     fn clear_preview(&self) {
180 |         while let Some(child) = self.preview_area.first_child() {
181 |             if let Some(picture) = child.downcast_ref::<Picture>() {
182 |                 picture.set_filename(Option::<&str>::None);
183 |                 picture.set_paintable(gtk4::gdk::Paintable::NONE);
184 |             }
185 | 
186 |             if let Some(image) = child.downcast_ref::<Image>() {
187 |                 image.clear();
188 |                 image.set_icon_name(Option::<&str>::None);
189 |             }
190 | 
191 |             while let Some(container) = child.downcast_ref::<gtk4::Box>()
192 |                 && let Some(nested_child) = container.first_child()
193 |             {
194 |                 if let Some(nested_picture) = nested_child.downcast_ref::<Picture>() {
195 |                     nested_picture.set_paintable(gtk4::gdk::Paintable::NONE);
196 |                 }
197 |                 if let Some(nested_image) = nested_child.downcast_ref::<Image>() {
198 |                     nested_image.clear();
199 |                     nested_image.set_icon_name(Option::<&str>::None);
200 |                 }
201 | 
202 |                 container.remove(&nested_child);
203 |             }
204 | 
205 |             if let Some(scrolled) = child.downcast_ref::<ScrolledWindow>()
206 |                 && let Some(scrolled_child) = scrolled.child()
207 |             {
208 |                 if let Some(text_view) = scrolled_child.downcast_ref::<TextView>() {
209 |                     text_view.buffer().set_text("");
210 |                 }
211 |                 if let Some(picture) = scrolled_child.downcast_ref::<Picture>() {
212 |                     picture.set_filename(Option::<&str>::None);
213 |                     picture.set_paintable(gtk4::gdk::Paintable::NONE);
214 |                 }
215 |                 if let Some(image) = scrolled_child.downcast_ref::<Image>() {
216 |                     image.clear();
217 |                     image.set_icon_name(Option::<&str>::None);
218 |                 }
219 |             }
220 | 
221 |             self.preview_area.remove(&child);
222 |         }
223 |     }
224 | 
225 |     fn preview_pdf(&self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
226 |         let uri = format!("file://{file_path}");
227 |         let document =
228 |             Document::from_file(&uri, None).map_err(|e| format!("Failed to load PDF: {e}"))?;
229 | 
230 |         let pdf = GtkBox::new(Orientation::Vertical, 0);
231 | 
232 |         if let Some(page) = document.page(0) {
233 |             match self.render_pdf_page(&page) {
234 |                 Ok(page_widget) => pdf.append(&page_widget),
235 |                 Err(e) => eprintln!("Failed to render PDF page: {e}"),
236 |             }
237 |         }
238 | 
239 |         std::mem::drop(document);
240 | 
241 |         let scrolled = ScrolledWindow::new();
242 |         scrolled.set_child(Some(&pdf));
243 |         scrolled.set_policy(PolicyType::Never, PolicyType::Automatic);
244 |         scrolled.set_width_request(800);
245 | 
246 |         self.preview_area.add_child(&scrolled);
247 |         self.preview_area.set_visible_child(&scrolled);
248 | 
249 |         Ok(())
250 |     }
251 | 
252 |     fn render_pdf_page(&self, page: &Page) -> Result<GtkBox, Box<dyn std::error::Error>> {
253 |         let page_container = GtkBox::new(Orientation::Vertical, 5);
254 |         page_container.set_halign(gtk4::Align::Fill);
255 |         page_container.set_hexpand(true);
256 | 
257 |         let (width, height) = page.size();
258 | 
259 |         let target_width = 800.0;
260 |         let display_scale = target_width / width;
261 | 
262 |         let render_scale = (display_scale * 1.5).min(2.0);
263 |         let render_width = ((width * render_scale) as i32).min(1600);
264 |         let render_height = ((height * render_scale) as i32).min(2400);
265 | 
266 |         let estimated_size = (render_width * render_height * 4) as usize;
267 |         if estimated_size > 15 * 1024 * 1024 {
268 |             return Err("PDF page too large for preview".into());
269 |         }
270 | 
271 |         let mut surface =
272 |             cairo::ImageSurface::create(cairo::Format::ARgb32, render_width, render_height)?;
273 | 
274 |         {
275 |             let ctx = cairo::Context::new(&surface)?;
276 | 
277 |             ctx.set_antialias(cairo::Antialias::Best);
278 |             ctx.scale(render_scale, render_scale);
279 | 
280 |             ctx.set_source_rgb(1.0, 1.0, 1.0);
281 |             ctx.paint()?;
282 | 
283 |             page.render(&ctx);
284 | 
285 |             ctx.target().flush();
286 |             std::mem::drop(ctx);
287 |         }
288 | 
289 |         surface.flush();
290 | 
291 |         let bytes = {
292 |             let mut rgba_data = surface.data()?.to_vec();
293 | 
294 |             for chunk in rgba_data.chunks_exact_mut(4) {
295 |                 chunk.swap(0, 2);
296 |             }
297 | 
298 |             Bytes::from_owned(rgba_data)
299 |         };
300 | 
301 |         std::mem::drop(surface);
302 | 
303 |         let texture = gtk4::gdk::MemoryTexture::new(
304 |             render_width,
305 |             render_height,
306 |             gtk4::gdk::MemoryFormat::R8g8b8a8,
307 |             &bytes,
308 |             (render_width * 4) as usize,
309 |         );
310 | 
311 |         let picture = Picture::for_paintable(&texture);
312 |         picture.set_content_fit(ContentFit::Cover);
313 |         picture.set_halign(gtk4::Align::Start);
314 |         picture.set_valign(gtk4::Align::Start);
315 |         picture.set_width_request(800);
316 | 
317 |         let display_height = (height * display_scale) as i32;
318 |         picture.set_height_request(display_height);
319 | 
320 |         page_container.append(&picture);
321 |         Ok(page_container)
322 |     }
323 | 
324 |     fn preview_image(&self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
325 |         let picture = Picture::new();
326 |         picture.set_content_fit(ContentFit::Contain);
327 | 
328 |         let scrolled = ScrolledWindow::new();
329 |         scrolled.set_child(Some(&picture));
330 |         scrolled.set_policy(PolicyType::Automatic, PolicyType::Automatic);
331 | 
332 |         self.preview_area.add_child(&scrolled);
333 |         self.preview_area.set_visible_child(&scrolled);
334 | 
335 |         if let Some(cached_texture) = self.image_cache.borrow().get(file_path) {
336 |             picture.set_paintable(Some(cached_texture));
337 |             return Ok(());
338 |         }
339 | 
340 |         let file = gio::File::for_path(file_path);
341 |         picture.set_file(Some(&file));
342 | 
343 |         // load and cache in background for future use
344 |         let file_path_clone = file_path.to_string();
345 |         let cache_clone = self.image_cache.clone();
346 | 
347 |         glib::MainContext::ref_thread_default().spawn_local(async move {
348 |             let cancellable = gio::Cancellable::new();
349 |             match Self::load_image_async(&file_path_clone, &cancellable, cache_clone).await {
350 |                 Ok(_) => {}
351 |                 Err(e) => {
352 |                     eprintln!("Failed to cache image {}: {}", file_path_clone, e);
353 |                 }
354 |             }
355 |         });
356 | 
357 |         Ok(())
358 |     }
359 | 
360 |     async fn load_image_async(
361 |         file_path: &str,
362 |         cancellable: &gio::Cancellable,
363 |         cache: Rc<RefCell<HashMap<String, gtk4::gdk::Texture>>>,
364 |     ) -> Result<gtk4::gdk::Texture, Box<dyn std::error::Error>> {
365 |         if let Some(cached_texture) = cache.borrow().get(file_path) {
366 |             return Ok(cached_texture.clone());
367 |         }
368 | 
369 |         let file = gio::File::for_path(file_path);
370 | 
371 |         let (bytes, _) = file.load_bytes_future().await?;
372 |         let stream = gio::MemoryInputStream::from_bytes(&bytes);
373 | 
374 |         let pixbuf = gdk_pixbuf::Pixbuf::from_stream(&stream, Some(cancellable))?;
375 | 
376 |         // Downscale to small size for fast preview (max 360x360)
377 |         let max_size = 360;
378 |         let (width, height) = (pixbuf.width(), pixbuf.height());
379 |         let (new_width, new_height) = if width > max_size || height > max_size {
380 |             let ratio = (max_size as f64) / (width.max(height) as f64);
381 |             (
382 |                 (width as f64 * ratio) as i32,
383 |                 (height as f64 * ratio) as i32,
384 |             )
385 |         } else {
386 |             (width, height)
387 |         };
388 | 
389 |         let scaled_pixbuf = if new_width != width || new_height != height {
390 |             pixbuf
391 |                 .scale_simple(new_width, new_height, gdk_pixbuf::InterpType::Bilinear)
392 |                 .ok_or("Failed to scale image")?
393 |         } else {
394 |             pixbuf
395 |         };
396 | 
397 |         let texture = gtk4::gdk::Texture::for_pixbuf(&scaled_pixbuf);
398 | 
399 |         let mut cache_mut = cache.borrow_mut();
400 |         if cache_mut.len() >= 50 {
401 |             if let Some(key) = cache_mut.keys().next().cloned() {
402 |                 cache_mut.remove(&key);
403 |             }
404 |         }
405 |         cache_mut.insert(file_path.to_string(), texture.clone());
406 | 
407 |         Ok(texture)
408 |     }
409 | 
410 |     fn preview_text(&self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
411 |         let content = fs::read(file_path)?;
412 | 
413 |         let max_size = 1024 * 1024; // 1MB
414 |         let display_content = if content.len() > max_size {
415 |             let mut truncated = content[..max_size].to_vec();
416 |             truncated.extend_from_slice(b"\n\n[File truncated...]");
417 |             truncated
418 |         } else {
419 |             content
420 |         };
421 | 
422 |         let text_view = TextView::new();
423 |         text_view.set_editable(false);
424 |         text_view.set_monospace(true);
425 |         text_view.set_wrap_mode(WrapMode::Word);
426 |         text_view.set_size_request(300, 200);
427 |         let buffer = text_view.buffer();
428 |         buffer.set_text(
429 |             String::from_utf8(display_content)
430 |                 .as_ref()
431 |                 .map(String::as_str)
432 |                 .unwrap_or("[Binary file - cannot display as text]"),
433 |         );
434 | 
435 |         let scrolled = ScrolledWindow::new();
436 |         scrolled.set_child(Some(&text_view));
437 |         scrolled.set_policy(PolicyType::Automatic, PolicyType::Automatic);
438 |         scrolled.set_size_request(300, 250);
439 | 
440 |         self.preview_area.add_child(&scrolled);
441 |         self.preview_area.set_visible_child(&scrolled);
442 |         Ok(())
443 |     }
444 | 
445 |     fn preview_video(&self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
446 |         // Cancel previous load
447 |         if let Some(c) = self.current_video_cancellable.borrow_mut().take() {
448 |             c.cancel();
449 |         }
450 | 
451 |         let cancellable = Cancellable::new();
452 |         *self.current_video_cancellable.borrow_mut() = Some(cancellable.clone());
453 | 
454 |         let scrolled = self.get_or_create_scrolled();
455 |         scrolled.set_size_request(128, 72);
456 |         scrolled.set_child(None::<gtk4::Widget>.as_ref());
457 | 
458 |         let placeholder = GtkBox::new(Orientation::Vertical, 10);
459 |         placeholder.set_halign(gtk4::Align::Center);
460 |         placeholder.set_valign(gtk4::Align::Center);
461 |         let icon = Image::from_icon_name("video-x-generic");
462 |         icon.set_pixel_size(64);
463 |         placeholder.append(&icon);
464 |         scrolled.set_child(Some(&placeholder));
465 | 
466 |         self.preview_area.set_visible_child(&scrolled);
467 | 
468 |         //added a 200ms debounce to make fast scrolling smoother
469 |         let file_path_clone = file_path.to_string();
470 |         let scrolled_clone = scrolled.clone();
471 |         let placeholder_clone = placeholder.clone();
472 |         let cancellable_clone = cancellable.clone();
473 | 
474 |         glib::timeout_add_local(std::time::Duration::from_millis(200), move || {
475 |             if cancellable_clone.is_cancelled() {
476 |                 return glib::ControlFlow::Break;
477 |             }
478 |             if !scrolled_clone.is_visible() {
479 |                 return glib::ControlFlow::Break;
480 |             }
481 | 
482 |             let file = gio::File::for_path(&file_path_clone);
483 |             let video = Video::for_file(Some(&file));
484 |             video.set_autoplay(true);
485 | 
486 |             // Replace placeholder with video
487 |             placeholder_clone.set_visible(false);
488 |             scrolled_clone.set_child(Some(&video));
489 | 
490 |             glib::ControlFlow::Break
491 |         });
492 | 
493 |         Ok(())
494 |     }
495 | 
496 |     fn get_or_create_scrolled(&self) -> ScrolledWindow {
497 |         if let Some(child) = self.preview_area.first_child() {
498 |             if let Ok(scrolled) = child.downcast::<ScrolledWindow>() {
499 |                 return scrolled;
500 |             }
501 |         }
502 |         let scrolled = ScrolledWindow::new();
503 |         scrolled.set_policy(PolicyType::Automatic, PolicyType::Automatic);
504 |         scrolled.set_size_request(300, 250);
505 |         scrolled.set_halign(gtk4::Align::Fill);
506 |         scrolled.set_valign(gtk4::Align::Fill);
507 |         scrolled.set_hexpand(true);
508 |         scrolled.set_vexpand(true);
509 |         self.preview_area.add_child(&scrolled);
510 |         scrolled
511 |     }
512 | 
513 |     fn preview_generic(&self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
514 |         let container = GtkBox::new(Orientation::Vertical, 10);
515 |         container.set_halign(gtk4::Align::Center);
516 |         container.set_valign(gtk4::Align::Center);
517 |         container.set_margin_top(20);
518 |         container.set_margin_bottom(20);
519 |         container.set_margin_start(20);
520 |         container.set_margin_end(20);
521 |         container.set_size_request(250, 200);
522 | 
523 |         let icon = Image::from_icon_name("text-x-generic");
524 |         icon.set_icon_size(gtk4::IconSize::Large);
525 |         icon.add_css_class("preview-generic-icon");
526 | 
527 |         // Try to get file-specific icon, but fallback gracefully to avoid memory issues
528 |         let file = gio::File::for_path(file_path);
529 |         if let Ok(info) = file.query_info(
530 |             "standard::icon",
531 |             gio::FileQueryInfoFlags::NONE,
532 |             gio::Cancellable::NONE,
533 |         ) && let Some(file_icon) = info.icon()
534 |         {
535 |             icon.set_from_gicon(&file_icon);
536 |         }
537 | 
538 |         container.append(&icon);
539 | 
540 |         self.preview_area.add_child(&container);
541 |         self.preview_area.set_visible_child(&container);
542 |         Ok(())
543 |     }
544 | }
545 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | mod config;
  2 | mod data;
  3 | mod keybinds;
  4 | mod preview;
  5 | mod protos;
  6 | mod providers;
  7 | mod renderers;
  8 | mod state;
  9 | mod theme;
 10 | mod ui;
 11 | use gtk4::gio::prelude::{ApplicationCommandLineExt, DataInputStreamExtManual, SettingsExt};
 12 | use gtk4::gio::{self, ApplicationCommandLine, ApplicationHoldGuard};
 13 | use gtk4::glib::Priority;
 14 | use gtk4::prelude::EntryExt;
 15 | 
 16 | use config::get_config;
 17 | use state::init_app_state;
 18 | use which::which;
 19 | 
 20 | use std::cell::OnceCell;
 21 | use std::os::fd::AsRawFd;
 22 | use std::os::unix::net::UnixListener;
 23 | use std::path::PathBuf;
 24 | use std::process;
 25 | use std::rc::Rc;
 26 | use std::sync::RwLock;
 27 | use std::thread;
 28 | use std::{env, fs};
 29 | use tokio::sync::oneshot::{self, Sender};
 30 | 
 31 | use gtk4::{
 32 |     Application,
 33 |     gio::{
 34 |         ApplicationFlags,
 35 |         prelude::{ApplicationExt, ApplicationExtManual},
 36 |     },
 37 |     glib::{self, OptionFlags, VariantTy},
 38 |     prelude::WidgetExt,
 39 | };
 40 | 
 41 | use crate::data::init_socket;
 42 | use crate::keybinds::setup_binds;
 43 | use crate::protos::QueryResponseObject;
 44 | use crate::protos::generated_proto::query::{QueryResponse, query_response};
 45 | use crate::providers::setup_providers;
 46 | use crate::state::{
 47 |     get_parameter_height, get_parameter_max_height, get_parameter_max_width,
 48 |     get_parameter_min_height, get_parameter_min_width, get_parameter_width, get_placeholder,
 49 |     get_provider, get_theme, has_elephant, has_theme, is_connected, is_dmenu, is_dmenu_keep_open,
 50 |     is_input_only, is_no_hints, is_no_search, is_param_close, is_service,
 51 |     is_stay_open_explicit_provider, is_visible, set_current_set, set_dmenu_current,
 52 |     set_dmenu_exit_after, set_dmenu_keep_open, set_has_elephant, set_hide_qa, set_index,
 53 |     set_initial_height, set_initial_max_height, set_initial_max_width, set_initial_min_height,
 54 |     set_initial_min_width, set_initial_placeholder, set_initial_width, set_input_only,
 55 |     set_is_dmenu, set_is_service, set_is_stay_open_explicit_provider, set_is_visible, set_no_hints,
 56 |     set_no_search, set_param_close, set_parameter_height, set_parameter_max_height,
 57 |     set_parameter_max_width, set_parameter_min_height, set_parameter_min_width,
 58 |     set_parameter_width, set_placeholder, set_provider, set_theme,
 59 | };
 60 | use crate::theme::{setup_css, setup_css_provider, setup_themes};
 61 | use crate::ui::window::{
 62 |     handle_preview, quit, set_input_text, set_keybind_hint, setup_window, with_window,
 63 | };
 64 | 
 65 | static GLOBAL_DMENU_SENDER: RwLock<Option<Sender<String>>> = RwLock::new(None);
 66 | 
 67 | thread_local! {
 68 |     static HOLD_GUARD: OnceCell<ApplicationHoldGuard> = const { OnceCell::new() };
 69 | }
 70 | 
 71 | fn main() -> glib::ExitCode {
 72 |     let app = Application::builder()
 73 |         .application_id("dev.benz.walker")
 74 |         .flags(ApplicationFlags::HANDLES_COMMAND_LINE)
 75 |         .build();
 76 | 
 77 |     app.connect_handle_local_options(|_, _| -1);
 78 | 
 79 |     add_flags(&app);
 80 | 
 81 |     app.connect_command_line(handle_command_line);
 82 |     app.connect_activate(activate);
 83 |     app.connect_startup(startup);
 84 | 
 85 |     app.run()
 86 | }
 87 | 
 88 | fn init_ui(app: &Application, dmenu: bool) {
 89 |     if app.flags().contains(ApplicationFlags::IS_SERVICE) {
 90 |         set_is_service(true);
 91 |     }
 92 | 
 93 |     config::load().unwrap();
 94 | 
 95 |     let mut theme = get_config().theme.as_str();
 96 | 
 97 |     if theme.is_empty() {
 98 |         theme = "default";
 99 |     }
100 | 
101 |     set_theme(theme.to_string());
102 | 
103 |     let mut elephant = false;
104 | 
105 |     if !dmenu || is_service() {
106 |         elephant = which("elephant").is_ok();
107 |         set_has_elephant(elephant);
108 |     }
109 | 
110 |     setup_providers(elephant);
111 | 
112 |     setup_css_provider();
113 | 
114 |     setup_binds();
115 | 
116 |     setup_themes(elephant && !dmenu, get_theme(), is_service());
117 | 
118 |     setup_window(app);
119 | 
120 |     let settings = gio::Settings::new("org.gnome.desktop.interface");
121 |     let settings_clone = settings.clone();
122 |     adjust_accent_color(settings_clone);
123 | 
124 |     let settings_clone = settings.clone();
125 |     adjust_color_scheme(settings_clone);
126 | 
127 |     let settings_clone = settings.clone();
128 |     settings.connect_changed(Some("accent-color"), move |_, _| {
129 |         adjust_accent_color(settings_clone.clone());
130 |     });
131 | 
132 |     let settings_clone = settings.clone();
133 |     settings.connect_changed(Some("color-scheme"), move |_, _| {
134 |         adjust_color_scheme(settings_clone.clone());
135 |     });
136 | }
137 | 
138 | fn adjust_accent_color(settings: gio::Settings) {
139 |     with_window(|w| {
140 |         w.window
141 |             .css_classes()
142 |             .iter()
143 |             .filter(|c| c.starts_with("accent-"))
144 |             .for_each(|c| w.window.remove_css_class(c));
145 | 
146 |         let new_accent_color = format!("accent-{}", settings.string("accent-color").as_str());
147 |         w.window.add_css_class(new_accent_color.as_str());
148 |     });
149 | }
150 | 
151 | fn adjust_color_scheme(settings: gio::Settings) {
152 |     with_window(|w| {
153 |         w.window.remove_css_class("dark");
154 |         w.window.remove_css_class("light");
155 |         match settings.string("color-scheme").as_str() {
156 |             "prefer-dark" => w.window.add_css_class("dark"),
157 |             "prefer-light" => w.window.add_css_class("light"),
158 |             _ => (),
159 |         }
160 |     });
161 | }
162 | 
163 | fn send_message(message: String) {
164 |     let mut sender_guard = GLOBAL_DMENU_SENDER.write().unwrap();
165 | 
166 |     if let Some(sender) = sender_guard.take() {
167 |         if sender.send(message).is_err() {
168 |             println!("the receiver dropped");
169 |         }
170 | 
171 |         *sender_guard = None;
172 |     } else {
173 |         println!("No sender available");
174 |     }
175 | }
176 | 
177 | fn add_flags(app: &Application) {
178 |     app.add_main_option(
179 |         "version",
180 |         b'v'.into(),
181 |         OptionFlags::NONE,
182 |         glib::OptionArg::None,
183 |         "show version",
184 |         None,
185 |     );
186 | 
187 |     app.add_main_option(
188 |         "nosearch",
189 |         b'n'.into(),
190 |         OptionFlags::NONE,
191 |         glib::OptionArg::None,
192 |         "hide search input",
193 |         None,
194 |     );
195 | 
196 |     app.add_main_option(
197 |         "nohints",
198 |         b'N'.into(),
199 |         OptionFlags::NONE,
200 |         glib::OptionArg::None,
201 |         "hide keybind hints",
202 |         None,
203 |     );
204 | 
205 |     app.add_main_option(
206 |         "inputonly",
207 |         b'I'.into(),
208 |         OptionFlags::NONE,
209 |         glib::OptionArg::None,
210 |         "only show input. dmenu only.",
211 |         None,
212 |     );
213 | 
214 |     app.add_main_option(
215 |         "index",
216 |         b'i'.into(),
217 |         OptionFlags::NONE,
218 |         glib::OptionArg::None,
219 |         "prints the selected index instead of its value. dmenu only.",
220 |         None,
221 |     );
222 | 
223 |     app.add_main_option(
224 |         "provider",
225 |         b'm'.into(),
226 |         OptionFlags::NONE,
227 |         glib::OptionArg::String,
228 |         "exclusive provider to query",
229 |         None,
230 |     );
231 | 
232 |     app.add_main_option(
233 |         "set",
234 |         b's'.into(),
235 |         OptionFlags::NONE,
236 |         glib::OptionArg::String,
237 |         "provider set to use",
238 |         None,
239 |     );
240 | 
241 |     app.add_main_option(
242 |         "placeholder",
243 |         b'p'.into(),
244 |         OptionFlags::NONE,
245 |         glib::OptionArg::String,
246 |         "input placeholder.",
247 |         None,
248 |     );
249 | 
250 |     app.add_main_option(
251 |         "height",
252 |         b'h'.into(),
253 |         OptionFlags::NONE,
254 |         glib::OptionArg::Int64,
255 |         "forced height. concerned with overall box. min 1. DONT USE SHORTHAND.",
256 |         None,
257 |     );
258 | 
259 |     app.add_main_option(
260 |         "minheight",
261 |         b'h'.into(),
262 |         OptionFlags::NONE,
263 |         glib::OptionArg::Int64,
264 |         "min height. concerned with scrolled content. min 1.",
265 |         None,
266 |     );
267 | 
268 |     app.add_main_option(
269 |         "maxheight",
270 |         b'h'.into(),
271 |         OptionFlags::NONE,
272 |         glib::OptionArg::Int64,
273 |         "max height. concerned with scrolled content. min 1.",
274 |         None,
275 |     );
276 | 
277 |     app.add_main_option(
278 |         "current",
279 |         b'c'.into(),
280 |         OptionFlags::NONE,
281 |         glib::OptionArg::Int64,
282 |         "mark current value. dmenu only.",
283 |         None,
284 |     );
285 | 
286 |     app.add_main_option(
287 |         "width",
288 |         b'w'.into(),
289 |         OptionFlags::NONE,
290 |         glib::OptionArg::Int64,
291 |         "forced width. concerned with overall box. min 1. DONT USE SHORTHAND.",
292 |         None,
293 |     );
294 | 
295 |     app.add_main_option(
296 |         "minwidth",
297 |         b'w'.into(),
298 |         OptionFlags::NONE,
299 |         glib::OptionArg::Int64,
300 |         "min width. concerned with scrolled content. min 1.",
301 |         None,
302 |     );
303 | 
304 |     app.add_main_option(
305 |         "maxwidth",
306 |         b'w'.into(),
307 |         OptionFlags::NONE,
308 |         glib::OptionArg::Int64,
309 |         "max width. concerned with scrolled content. min 1.",
310 |         None,
311 |     );
312 | 
313 |     app.add_main_option(
314 |         "theme",
315 |         b't'.into(),
316 |         OptionFlags::NONE,
317 |         glib::OptionArg::String,
318 |         "theme to use",
319 |         None,
320 |     );
321 | 
322 |     app.add_main_option(
323 |         "dmenu",
324 |         b'd'.into(),
325 |         OptionFlags::NONE,
326 |         glib::OptionArg::None,
327 |         "dmenu",
328 |         None,
329 |     );
330 | 
331 |     app.add_main_option(
332 |         "close",
333 |         b'q'.into(),
334 |         OptionFlags::NONE,
335 |         glib::OptionArg::None,
336 |         "closes walker when open",
337 |         None,
338 |     );
339 | 
340 |     app.add_main_option(
341 |         "hideqa",
342 |         b'H'.into(),
343 |         OptionFlags::NONE,
344 |         glib::OptionArg::None,
345 |         "hides quick activation buttons",
346 |         None,
347 |     );
348 | 
349 |     app.add_main_option(
350 |         "keepopen",
351 |         b'k'.into(),
352 |         OptionFlags::NONE,
353 |         glib::OptionArg::None,
354 |         "keep walker open after selection. only when using service. dmenu only.",
355 |         None,
356 |     );
357 | 
358 |     app.add_main_option(
359 |         "exit",
360 |         b'e'.into(),
361 |         OptionFlags::NONE,
362 |         glib::OptionArg::None,
363 |         "exit after this dmenu call. only when using service. dmenu only",
364 |         None,
365 |     );
366 | }
367 | 
368 | fn handle_command_line(app: &Application, cmd: &ApplicationCommandLine) -> i32 {
369 |     let options = cmd.options_dict();
370 | 
371 |     if options.contains("version") {
372 |         cmd.print_literal(&format!("{}\n", env!("CARGO_PKG_VERSION")));
373 |         return 0;
374 |     }
375 | 
376 |     set_is_stay_open_explicit_provider(false);
377 | 
378 |     if let Some(val) = options.lookup_value("provider", Some(VariantTy::STRING)) {
379 |         let p = val.str().unwrap().to_string();
380 | 
381 |         set_is_stay_open_explicit_provider(get_provider() != p);
382 | 
383 |         set_provider(val.str().unwrap().to_string());
384 |     } else {
385 |         set_is_stay_open_explicit_provider(!get_provider().is_empty());
386 |         set_provider("".to_string());
387 |     }
388 | 
389 |     set_param_close(options.contains("close"));
390 |     set_hide_qa(options.contains("hideqa"));
391 | 
392 |     if let Some(val) = options.lookup_value("theme", Some(VariantTy::STRING)) {
393 |         let theme = val.str().unwrap();
394 | 
395 |         if has_theme(theme) {
396 |             set_theme(theme.to_string());
397 |         } else {
398 |             cmd.print_literal("theme not found. using default theme.\n");
399 |             set_theme("default".to_string());
400 |         }
401 |     }
402 | 
403 |     if let Some(val) = options.lookup_value("set", Some(VariantTy::STRING)) {
404 |         let set = val.str().unwrap();
405 |         set_current_set(set.to_string());
406 |     }
407 | 
408 |     set_parameter_height(None);
409 |     if let Some(val) = options.lookup_value("height", Some(VariantTy::INT64)) {
410 |         set_parameter_height(Some(val.get::<i64>().unwrap() as i32));
411 |     }
412 | 
413 |     set_parameter_width(None);
414 |     if let Some(val) = options.lookup_value("width", Some(VariantTy::INT64)) {
415 |         set_parameter_width(Some(val.get::<i64>().unwrap() as i32));
416 |     }
417 | 
418 |     set_parameter_min_width(None);
419 |     if let Some(val) = options.lookup_value("minwidth", Some(VariantTy::INT64)) {
420 |         set_parameter_min_width(Some(val.get::<i64>().unwrap() as i32));
421 |     }
422 | 
423 |     set_parameter_min_height(None);
424 |     if let Some(val) = options.lookup_value("minheight", Some(VariantTy::INT64)) {
425 |         set_parameter_min_height(Some(val.get::<i64>().unwrap() as i32));
426 |     }
427 | 
428 |     set_parameter_max_width(None);
429 |     if let Some(val) = options.lookup_value("maxwidth", Some(VariantTy::INT64)) {
430 |         set_parameter_max_width(Some(val.get::<i64>().unwrap() as i32));
431 |     }
432 | 
433 |     set_parameter_max_height(None);
434 |     if let Some(val) = options.lookup_value("maxheight", Some(VariantTy::INT64)) {
435 |         set_parameter_max_height(Some(val.get::<i64>().unwrap() as i32));
436 |     }
437 | 
438 |     set_no_search(options.contains("nosearch"));
439 |     set_no_hints(options.contains("nohints"));
440 | 
441 |     if let Some(val) = options.lookup_value("placeholder", Some(VariantTy::STRING)) {
442 |         set_placeholder(val.str().unwrap().to_string());
443 |     }
444 | 
445 |     'dmenu: {
446 |         if !options.contains("dmenu") {
447 |             set_dmenu_keep_open(false);
448 |             set_is_dmenu(false);
449 |             break 'dmenu;
450 |         } else {
451 |             set_is_dmenu(true);
452 |         }
453 | 
454 |         set_index(options.contains("index"));
455 | 
456 |         set_input_only(options.contains("inputonly"));
457 | 
458 |         if options.contains("keepopen") && app.flags().contains(ApplicationFlags::IS_SERVICE) {
459 |             set_dmenu_keep_open(true);
460 |         }
461 | 
462 |         if let Some(val) = options.lookup_value("current", Some(VariantTy::INT64)) {
463 |             set_dmenu_current(val.get::<i64>().unwrap());
464 |         }
465 | 
466 |         set_dmenu_exit_after(options.contains("exit"));
467 | 
468 |         if GLOBAL_DMENU_SENDER.read().unwrap().is_some() {
469 |             send_message("CNCLD".to_string());
470 |             break 'dmenu;
471 |         }
472 | 
473 |         with_window(|w| {
474 |             set_input_text("");
475 | 
476 |             let items = w.items.clone();
477 |             items.remove_all();
478 | 
479 |             if is_input_only() {
480 |                 return;
481 |             }
482 | 
483 |             let stdin = cmd.stdin();
484 |             let data_stream = gio::DataInputStream::new(&stdin.unwrap());
485 | 
486 |             async fn read_lines_async(stream: Rc<gio::DataInputStream>, items: gio::ListStore) {
487 |                 let mut i = 0;
488 | 
489 |                 loop {
490 |                     match stream.read_line_utf8_future(Priority::DEFAULT).await {
491 |                         Ok(Some(line)) => {
492 |                             if line.is_empty() {
493 |                                 break;
494 |                             }
495 | 
496 |                             let line = line.trim();
497 | 
498 |                             if !line.is_empty() {
499 |                                 let mut item = query_response::Item::new();
500 |                                 item.text = line.to_string();
501 |                                 item.provider = "dmenu".to_string();
502 |                                 item.score = 1000000 - i;
503 |                                 item.actions = vec!["select".to_string()];
504 | 
505 |                                 let mut response = QueryResponse::new();
506 |                                 response.item = protobuf::MessageField::some(item);
507 | 
508 |                                 items.append(&QueryResponseObject::new(response));
509 |                             }
510 | 
511 |                             i += 1;
512 |                         }
513 |                         Ok(None) => {
514 |                             set_keybind_hint();
515 |                             break;
516 |                         }
517 |                         Err(e) => {
518 |                             eprintln!("Error reading: {e}");
519 |                             break;
520 |                         }
521 |                     }
522 |                 }
523 |             }
524 | 
525 |             glib::spawn_future_local(async move {
526 |                 read_lines_async(Rc::new(data_stream), items).await;
527 |             });
528 |         });
529 | 
530 |         if !is_service() {
531 |             break 'dmenu;
532 |         }
533 | 
534 |         let (sender, receiver) = oneshot::channel();
535 | 
536 |         *GLOBAL_DMENU_SENDER.write().unwrap() = Some(sender);
537 | 
538 |         let cmd = cmd.clone();
539 | 
540 |         glib::spawn_future_local(async move {
541 |             match receiver.await {
542 |                 Ok(message) => match message.as_str() {
543 |                     "CNCLD" => {
544 |                         cmd.set_exit_status(130);
545 |                     }
546 |                     msg => cmd.print_literal(&format!("{msg}\n")),
547 |                 },
548 |                 Err(_) => {
549 |                     println!("the sender dropped");
550 |                     cmd.set_exit_status(130);
551 |                 }
552 |             }
553 | 
554 |             *GLOBAL_DMENU_SENDER.write().unwrap() = None;
555 |         });
556 |     }
557 | 
558 |     app.activate();
559 |     0
560 | }
561 | 
562 | fn activate(app: &Application) {
563 |     let cfg = get_config();
564 | 
565 |     apply_flag_logic();
566 | 
567 |     if is_dmenu() && is_visible() {
568 |         return;
569 |     }
570 | 
571 |     if (!is_stay_open_explicit_provider()
572 |         && cfg.close_when_open
573 |         && is_visible()
574 |         && !is_dmenu_keep_open())
575 |         || is_param_close()
576 |     {
577 |         if is_visible() {
578 |             quit(app, false);
579 |         }
580 | 
581 |         return;
582 |     }
583 | 
584 |     if is_dmenu_keep_open() && is_visible() {
585 |         return;
586 |     }
587 | 
588 |     with_window(|w| {
589 |         setup_css(get_theme());
590 | 
591 |         if let Some(input) = &w.input {
592 |             set_input_text("");
593 |             input.grab_focus();
594 |         }
595 | 
596 |         if !is_connected() && !is_dmenu() {
597 |             w.elephant_hint.set_visible(true);
598 |             w.scroll.set_visible(false);
599 |         } else {
600 |             w.elephant_hint.set_visible(false);
601 |         }
602 | 
603 |         w.window.set_visible(true);
604 | 
605 |         if !is_dmenu() && !is_connected() && has_elephant() {
606 |             thread::spawn(|| init_socket().unwrap());
607 |         } else if !has_elephant() && !is_dmenu() {
608 |             println!("Please install elephant.");
609 |             process::exit(1);
610 |         }
611 |     });
612 | 
613 |     set_is_visible(true);
614 | }
615 | 
616 | fn apply_flag_logic() {
617 |     let cfg = get_config();
618 |     let provider = get_provider();
619 |     let provider = if provider.is_empty() {
620 |         "default"
621 |     } else {
622 |         provider.as_str()
623 |     };
624 | 
625 |     with_window(|w| {
626 |         if is_input_only() {
627 |             w.content_container.set_visible(false);
628 |             if let Some(keybinds) = &w.keybinds {
629 |                 keybinds.set_visible(false);
630 |             }
631 |         }
632 | 
633 |         if let Some(placeholders) = &cfg.placeholders
634 |             && let Some(placeholder) = placeholders.get(provider)
635 |         {
636 |             if let Some(input) = &w.input {
637 |                 input.set_placeholder_text(Some(&placeholder.input));
638 |             }
639 | 
640 |             if let Some(p) = w.placeholder.as_ref() {
641 |                 p.set_text(&placeholder.list)
642 |             }
643 |         }
644 | 
645 |         if !get_placeholder().is_empty()
646 |             && let Some(input) = &w.input
647 |         {
648 |             if let Some(placeholder) = input.placeholder_text() {
649 |                 set_initial_placeholder(placeholder.to_string());
650 |             }
651 | 
652 |             input.set_placeholder_text(Some(&get_placeholder()));
653 |         }
654 | 
655 |         if let Some(val) = get_parameter_height() {
656 |             set_initial_height(Some(w.box_wrapper.height_request()));
657 |             w.box_wrapper.set_height_request(val);
658 |         }
659 | 
660 |         if let Some(val) = get_parameter_width() {
661 |             set_initial_width(Some(w.box_wrapper.width_request()));
662 |             w.box_wrapper.set_width_request(val);
663 |         }
664 | 
665 |         if let Some(val) = get_parameter_min_width() {
666 |             set_initial_min_width(Some(w.scroll.min_content_width()));
667 |             w.scroll.set_min_content_width(val);
668 |         }
669 | 
670 |         if let Some(val) = get_parameter_min_height() {
671 |             set_initial_min_height(Some(w.scroll.min_content_height()));
672 |             w.scroll.set_min_content_height(val);
673 |         }
674 | 
675 |         if let Some(val) = get_parameter_max_width() {
676 |             set_initial_max_width(Some(w.scroll.max_content_width()));
677 |             w.scroll.set_max_content_width(val);
678 |         }
679 | 
680 |         if let Some(val) = get_parameter_max_height() {
681 |             set_initial_max_height(Some(w.scroll.max_content_height()));
682 |             w.scroll.set_max_content_height(val);
683 |         }
684 | 
685 |         if get_parameter_min_width().is_some() || get_parameter_max_width().is_some() {
686 |             set_initial_width(Some(w.box_wrapper.width_request()));
687 |             w.box_wrapper.set_width_request(-1);
688 |         }
689 | 
690 |         if get_parameter_min_height().is_some() || get_parameter_max_height().is_some() {
691 |             set_initial_height(Some(w.box_wrapper.height_request()));
692 |             w.box_wrapper.set_height_request(-1);
693 |         }
694 | 
695 |         if is_no_search()
696 |             && let Some(search_container) = &w.search_container
697 |         {
698 |             search_container.set_visible(false);
699 |         }
700 | 
701 |         if is_no_hints()
702 |             && let Some(hints) = &w.keybinds
703 |         {
704 |             hints.set_visible(false);
705 |         }
706 |     });
707 | }
708 | 
709 | fn startup(app: &Application) {
710 |     let args: Vec<String> = env::args().collect();
711 |     let dmenu = args.contains(&"--dmenu".to_string()) || args.contains(&"-d".to_string());
712 |     let version = args.contains(&"--version".to_string()) || args.contains(&"-v".to_string());
713 |     let is_service = app.flags().contains(ApplicationFlags::IS_SERVICE);
714 | 
715 |     if !is_service && (args.contains(&"--close".to_string()) || args.contains(&"-q".to_string())) {
716 |         process::exit(0);
717 |     }
718 | 
719 |     if version {
720 |         return;
721 |     }
722 | 
723 |     if !app.flags().contains(ApplicationFlags::IS_SERVICE) && !dmenu {
724 |         println!("make sure 'walker --gapplication-service' is running!");
725 |     }
726 | 
727 |     HOLD_GUARD.with(|h| h.set(app.hold()).expect("couldn't set hold-guard"));
728 | 
729 |     init_app_state();
730 |     init_ui(app, dmenu);
731 | 
732 |     listen_activation_socket(app.clone());
733 | }
734 | 
735 | fn listen_activation_socket(app_clone: Application) {
736 |     let mut socket_path = env::var("XDG_RUNTIME_DIR")
737 |         .map(PathBuf::from)
738 |         .unwrap_or_else(|_| env::temp_dir());
739 | 
740 |     socket_path.push("walker");
741 |     if !socket_path.exists() {
742 |         fs::create_dir(&socket_path).unwrap();
743 |     }
744 | 
745 |     socket_path.push("walker.sock");
746 | 
747 |     let _ = fs::remove_file(&socket_path);
748 | 
749 |     let listener = UnixListener::bind(&socket_path).unwrap();
750 |     listener.set_nonblocking(true).unwrap();
751 | 
752 |     let fd = listener.as_raw_fd();
753 | 
754 |     glib::unix_fd_add_local(fd, glib::IOCondition::IN, move |_fd, condition| {
755 |         if condition.contains(glib::IOCondition::IN) {
756 |             match listener.accept() {
757 |                 Ok((stream, _)) => {
758 |                     drop(stream);
759 |                     set_parameter_width(None);
760 |                     set_parameter_height(None);
761 |                     set_parameter_min_width(None);
762 |                     set_parameter_max_width(None);
763 |                     set_parameter_min_height(None);
764 |                     set_parameter_max_height(None);
765 |                     set_is_dmenu(false);
766 |                     set_dmenu_keep_open(false);
767 |                     set_param_close(false);
768 |                     set_hide_qa(false);
769 |                     set_provider("".to_string());
770 |                     set_is_stay_open_explicit_provider(false);
771 | 
772 |                     activate(&app_clone);
773 |                 }
774 |                 Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {}
775 |                 Err(e) => {
776 |                     eprintln!("Error accepting connection: {}", e);
777 |                     return glib::ControlFlow::Break;
778 |                 }
779 |             }
780 |         }
781 |         glib::ControlFlow::Continue
782 |     });
783 | }
784 | 


--------------------------------------------------------------------------------