├── .github
    ├── pull_request_template.md
    └── workflows
    │   ├── build-platforms.yml
    │   ├── pull-request.yml
    │   └── semver-checks.yml
├── .gitignore
├── .gitmodules
├── .vscode
    └── settings.json
├── CHANGELOG.md
├── Cargo.toml
├── History.md
├── LICENSE-Apache
├── LICENSE-MIT
├── README.md
├── bumpversion.sh
├── capabilities.md
├── examples
    ├── actions.rs
    ├── at_bus.rs
    ├── close.rs
    ├── countdown.rs
    ├── formatting.rs
    ├── hints.rs
    ├── images.rs
    ├── info.rs
    ├── mac.rs
    ├── mac_app_id.rs
    ├── minimal.rs
    ├── octodex.jpg
    ├── on_close.rs
    ├── on_close_reason.rs
    ├── persistent.rs
    ├── progress.rs
    ├── reuse.rs
    ├── schedule.rs
    ├── show_volume.rs
    ├── simple.rs
    ├── simple_async.rs
    ├── sound.rs
    ├── stack.rs
    ├── timeout.rs
    ├── update.rs
    ├── urgency.rs
    ├── wait_for_closing.rs
    ├── wait_for_closing_async.rs
    └── windows.rs
├── renovate.json
├── server_infos.yaml
├── src
    ├── error.rs
    ├── hints.rs
    ├── hints
    │   ├── constants.rs
    │   ├── message.rs
    │   └── tests.rs
    ├── image.rs
    ├── lib.rs
    ├── macos.rs
    ├── miniver.rs
    ├── notification.rs
    ├── server.rs
    ├── timeout.rs
    ├── urgency.rs
    ├── windows.rs
    └── xdg
    │   ├── bus.rs
    │   ├── dbus_rs.rs
    │   ├── mod.rs
    │   └── zbus_rs.rs
└── tests
    ├── conversion.rs
    ├── ownworld.rs
    └── realworld.rs


/.github/pull_request_template.md:
--------------------------------------------------------------------------------
 1 | <!--
 2 | First and foremost, thank you for taking the time to contribute to this project! Your efforts are greatly appreciated.
 3 | 
 4 | ## Semantic Commit Messages
 5 | Please ensure your commit messages follows the [Conventional Commits Specification](https://www.conventionalcommits.org/en/v1.0.0/),
 6 | as these are being used to automatically generate the changelog and determine the version bump for releases.
 7 | 
 8 | Most importantly: [Mark breaking changes accordingly](https://www.conventionalcommits.org/en/v1.0.0/#commit-message-with-description-and-breaking-change-footer)!
 9 | 
10 | ### Example
11 | ```
12 | feat: add new user authentication module
13 | 
14 | fix: resolve issue with user not being able to login
15 | 
16 | feat!: remove deprecated user module
17 | ```
18 | ->>
19 | 
20 | 
21 | Again, thank you for your contribution!
22 | If you have any questions or need assistance, don't hesitate to ask. We're here to help!
23 | 


--------------------------------------------------------------------------------
/.github/workflows/build-platforms.yml:
--------------------------------------------------------------------------------
  1 | name: Build Platforms
  2 | on:
  3 |   push:
  4 |     branches:
  5 |       - main
  6 |   pull_request:
  7 | 
  8 | jobs:
  9 |   linux:
 10 |     name: linux
 11 |     runs-on: ubuntu-latest
 12 |     strategy:
 13 |       #fail-fast: true
 14 |       matrix:
 15 |         rust:
 16 |           - stable
 17 |           - beta
 18 |           - stable minus 5 releases
 19 |         feature:
 20 |           - d
 21 |           - d,images
 22 |           - z
 23 |           - z,images
 24 |           - z,d
 25 |     steps:
 26 |       - uses: actions/checkout@v4
 27 |       - uses: Swatinem/rust-cache@v2
 28 |       - uses: dtolnay/rust-toolchain@stable
 29 |         with:
 30 |           toolchain: ${{ matrix.rust }}
 31 |           components: clippy, rustfmt
 32 |       - run: sudo apt-get install -y libdbus-1-dev
 33 | 
 34 |       - name: check (default features)
 35 |         run: cargo check
 36 | 
 37 |       - name: check (${{matrix.feature}})
 38 |         run: cargo check --no-default-features --features ${{matrix.feature}}
 39 | 
 40 |       # - name: test (default features)
 41 |       #   run: cargo test
 42 | 
 43 |       - name: test lib (${{matrix.feature}})
 44 |         run: cargo test --lib --no-default-features --features ${{matrix.feature}}
 45 | 
 46 |       # - name: test tests (${{matrix.feature}})
 47 |       #   run: cargo test --tests --no-default-features --features ${{matrix.feature}}
 48 | 
 49 |       - name: test docs (${{matrix.feature}})
 50 |         run: cargo test --doc --no-default-features --features ${{matrix.feature}}
 51 | 
 52 |       - name: clippy (default features)
 53 |         run: cargo clippy
 54 | 
 55 |   windows:
 56 |     name: windows
 57 |     runs-on: windows-latest
 58 |     strategy:
 59 |       matrix:
 60 |         rust:
 61 |           - stable
 62 |           - beta
 63 |           - stable minus 5 releases
 64 |     steps:
 65 |       - uses: actions/checkout@v4
 66 |       - uses: Swatinem/rust-cache@v2
 67 |       - uses: dtolnay/rust-toolchain@stable
 68 |         with:
 69 |           toolchain: ${{ matrix.rust }}
 70 |           components: clippy, rustfmt
 71 | 
 72 |       - name: check (default features)
 73 |         run: cargo check
 74 | 
 75 |       - name: test (default features)
 76 |         run: cargo test --no-run
 77 | 
 78 |       - name: clippy (default features)
 79 |         run: cargo clippy -- -D warnings
 80 | 
 81 |   macos:
 82 |     name: macos
 83 |     runs-on: macos-latest
 84 |     strategy:
 85 |       matrix:
 86 |         rust:
 87 |           - stable
 88 |           - beta
 89 |           - stable minus 5 releases
 90 |     steps:
 91 |       - uses: actions/checkout@v4
 92 |       - uses: Swatinem/rust-cache@v2
 93 |       - uses: dtolnay/rust-toolchain@stable
 94 |         with:
 95 |           toolchain: ${{ matrix.rust }}
 96 |           components: clippy, rustfmt
 97 | 
 98 |       - name: check (default features)
 99 |         run: cargo check
100 | 
101 |       - name: test (default features)
102 |         run: cargo test --no-run
103 | 
104 |       - name: clippy (default features)
105 |         run: cargo clippy -- -D warnings
106 | 


--------------------------------------------------------------------------------
/.github/workflows/pull-request.yml:
--------------------------------------------------------------------------------
 1 | name: Pull request
 2 | # This workflow is triggered on pushes to the repository.
 3 | on: [ pull_request ]
 4 | 
 5 | jobs:
 6 |   check:
 7 |     name: Check Commit Message
 8 |     runs-on: ubuntu-latest
 9 |     steps:
10 |       - uses: actions/checkout@v4
11 |         with:
12 |           # A PR should not contain too many commits
13 |           fetch-depth: 10
14 |       - name: Validate commit messages
15 |         run: |
16 |           git show-ref
17 |           curl -sSfL https://github.com/convco/convco/releases/latest/download/convco-ubuntu.zip | zcat > convco
18 |           chmod +x convco
19 |           ./convco check ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }}
20 |           rm convco
21 | 
22 |   check_fmt:
23 |     name: Check Format
24 |     runs-on: ubuntu-latest
25 |     steps:
26 |       - uses: actions/checkout@v4
27 |       - uses: dtolnay/rust-toolchain@stable
28 |       - uses: Swatinem/rust-cache@v2
29 | 
30 |       - name: cargo-fmt
31 |         run: cargo fmt --all --check
32 | 
33 | 
34 | 


--------------------------------------------------------------------------------
/.github/workflows/semver-checks.yml:
--------------------------------------------------------------------------------
 1 | name: Semver Checks
 2 | on:
 3 |   push:
 4 |     branches:
 5 |       - main
 6 |   pull_request:
 7 | 
 8 | jobs:
 9 |   semver:
10 |     name: cargo-semver-checks
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |       - uses: actions/checkout@v4
14 |       - uses: dtolnay/rust-toolchain@stable
15 |       - uses: Swatinem/rust-cache@v2
16 | 
17 |       - name: check semver
18 |         uses: obi1kenobi/cargo-semver-checks-action@v2.6
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | Cargo.lock
3 | *.swp
4 | *.swo
5 | .directory
6 | *.rustfmt
7 | *.rsx
8 | main-doc
9 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "target/doc"]
2 | 	path = target/doc
3 | 	url = git@github.com:hoodie/notify-rust
4 | 	branch = gh-pages
5 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "cSpell.words": [
 3 |         "appname",
 4 |         "dbus",
 5 |         "DBUSRS",
 6 |         "ffidisp",
 7 |         "freedesktop",
 8 |         "Galago",
 9 |         "OBJECTPATH",
10 |         "rustfmt",
11 |         "winrt",
12 |         "Xfce",
13 |         "ZBUS",
14 |         "zvariant"
15 |     ]
16 | }


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | ### [v4.11.7](https://github.com/hoodie/notify-rust/compare/v4.11.6...v4.11.7) (2025-04-08)
  4 | 
  5 | #### Fixes
  6 | 
  7 | * **deps:** update rust crate winrt-notification to 0.7 (#220)
  8 | ([6411aec](https://github.com/hoodie/notify-rust/commit/6411aec798fab664f984ac60bd40ae6b41e19011)),
  9 | closes [#220](https://github.com/hoodie/notify-rust/issues/220)
 10 | 
 11 | ### [v4.11.6](https://github.com/hoodie/notify-rust/compare/v4.11.5...v4.11.6) (2025-03-28)
 12 | 
 13 | #### Fixes
 14 | 
 15 | * resolve type inference issue with u32::MAX conversion (#244)
 16 | ([0c6c3ff](https://github.com/hoodie/notify-rust/commit/0c6c3ff251dbb32df6d45446940820d2f5d8e375)),
 17 | closes [#244](https://github.com/hoodie/notify-rust/issues/244)
 18 | 
 19 | ### [v4.11.5](https://github.com/hoodie/notify-rust/compare/v4.11.4...v4.11.5) (2025-02-10)
 20 | 
 21 | #### Fixes
 22 | 
 23 | * **deps:** broken zbus export
 24 | ([354d5a8](https://github.com/hoodie/notify-rust/commit/354d5a8c7072e46aeba41a7e1991e2d780b6ad6a)),
 25 | closes [#236](https://github.com/hoodie/notify-rust/issues/236)
 26 | 
 27 | ### [v4.11.4](https://github.com/hoodie/notify-rust/compare/v4.11.3...v4.11.4) (2025-01-12)
 28 | 
 29 | #### Fixes
 30 | 
 31 | * **deps:** update rust crate zbus to v5
 32 | ([0834adc](https://github.com/hoodie/notify-rust/commit/0834adc4635c72420ab52cb58ef573004693cab8))
 33 | 
 34 | ### [v4.11.3](https://github.com/hoodie/notify-rust/compare/v4.11.2...v4.11.3) (2024-09-10)
 35 | 
 36 | #### Fixes
 37 | 
 38 | * update build badge
 39 | ([c0ffeed](https://github.com/hoodie/notify-rust/commit/c0ffeed9455244f616ae738d2ac009e66fc2513a))
 40 | 
 41 | ### [v4.11.2](https://github.com/hoodie/notify-rust/compare/v4.11.1...v4.11.2) (2024-09-10)
 42 | 
 43 | #### Fixes
 44 | 
 45 | * **docs:** update links to Hints specification
 46 | ([6312e9c](https://github.com/hoodie/notify-rust/commit/6312e9c2273150d8c844c4725bf9ad29b3ac6021))
 47 | * **docs:** link warning
 48 | ([6edff02](https://github.com/hoodie/notify-rust/commit/6edff02d5450b9ae13f8271f32685fe9bca64404))
 49 | * more precise dependency on lazy_static
 50 | ([c24169e](https://github.com/hoodie/notify-rust/commit/c24169ef76b2b0be6d2acb4e6b4b445161a19d49))
 51 | 
 52 | ### [v4.11.1](https://github.com/hoodie/notify-rust/compare/v4.11.0...v4.11.1) (2024-08-01)
 53 | 
 54 | #### Fixes
 55 | 
 56 | * **docs:** make sure crates.io and readme are in sync
 57 | ([2bd2a2c](https://github.com/hoodie/notify-rust/commit/2bd2a2ce94aa9941040a939244ac3798f3a0110d))
 58 | * update maintenance badge
 59 | ([789fe44](https://github.com/hoodie/notify-rust/commit/789fe44140416837812889c5cdc0b64ac81f26b7))
 60 | 
 61 | ## [v4.11.0](https://github.com/hoodie/notify-rust/compare/v4.10.0...v4.11.0) (2024-04-04)
 62 | 
 63 | ### Features
 64 | 
 65 | * update to zbus v4
 66 | ([9683d01](https://github.com/hoodie/notify-rust/commit/9683d012568e4975f4e99068c7653b844146b536))
 67 | 
 68 | ### Fixes
 69 | 
 70 | * **deps:** update rust crate image to 0.25
 71 | ([c453121](https://github.com/hoodie/notify-rust/commit/c4531213af4d7319c5c3b23095d48d75c14f2181))
 72 | * **deps:** update rust crate env_logger to 0.11
 73 | ([656a915](https://github.com/hoodie/notify-rust/commit/656a915063484f1f96a5c3c5e0a566cf8dad71a7))
 74 | * **deps:** update rust crate winrt-notification to 0.2
 75 | ([730d563](https://github.com/hoodie/notify-rust/commit/730d5632f541ed3f452c62612c7b14992923d978))
 76 | 
 77 | ## [v4.10.0](https://github.com/hoodie/notify-rust/compare/v4.9.0...v4.10.0) (2023-11-16)
 78 | 
 79 | ### Features
 80 | 
 81 | * add feature `d_vendored` to enable dbus/vendored feature
 82 | ([a34239c](https://github.com/hoodie/notify-rust/commit/a34239c99e9caedf8f327226de82ad36dc6b3dcc))
 83 | 
 84 | ## [v4.9.0](https://github.com/hoodie/notify-rust/compare/v4.8.0...v4.9.0) (2023-08-22)
 85 | 
 86 | ### Features
 87 | 
 88 | * base `Urgency` on `u8` instead of `u64`
 89 | ([e9e3c30](https://github.com/hoodie/notify-rust/commit/e9e3c3068478bd2133a202fb4cc7f03af8160836))
 90 | * **xdg:** make dbus bus configurable
 91 | ([a514664](https://github.com/hoodie/notify-rust/commit/a514664cbe3277231106775482a87ac792f21635))
 92 | 
 93 | ### Fixes
 94 | 
 95 | * remove redundant action button on macOS
 96 | ([c0ffee9](https://github.com/hoodie/notify-rust/commit/c0ffee958afdf312d4c8eee5433345690686efb9))
 97 | * remove server feature
 98 | ([f8e89cf](https://github.com/hoodie/notify-rust/commit/f8e89cfd1a392d9b6cff43adcb167e9f64ebbdec))
 99 | * building with both dbus and zbus backend
100 | ([83d4489](https://github.com/hoodie/notify-rust/commit/83d44898a853944b9e62b77655c6384c5e75030c))
101 | 
102 | ## [v4.8.0](https://github.com/hoodie/notify-rust/compare/v4.7.1...v4.8.0) (2023-02-19)
103 | 
104 | ### Features
105 | 
106 | * add .show_async()
107 | ([ae3db62](https://github.com/hoodie/notify-rust/commit/ae3db621665ce4e2c741e2507f57d805d88c25ba))
108 | 
109 | ### [v4.7.1](https://github.com/hoodie/notify-rust/compare/v4.7.0...v4.7.1) (2023-02-15)
110 | 
111 | #### Fixes
112 | 
113 | * remove build issue when building with both z and d
114 | ([6f4238f](https://github.com/hoodie/notify-rust/commit/6f4238fe60c7790dd47ed4f31613eb9a1814b436))
115 | 
116 | ## [v4.7.0](https://github.com/hoodie/notify-rust/compare/v4.6.0...v4.7.0) (2023-01-08)
117 | 
118 | ### Features
119 | 
120 | * Accept durations as timeout arguments
121 | ([3ab191a](https://github.com/hoodie/notify-rust/commit/3ab191a9b74ad3120211719050f125de2e6f757d))
122 | * implement FromStr for Timeout
123 | ([b87b859](https://github.com/hoodie/notify-rust/commit/b87b859e6d18481e40d90ae7b4cd1b885589b897))
124 | 
125 | ### Fixes
126 | 
127 | * **deps:** update rust crate zbus to 3.6
128 | ([89779e8](https://github.com/hoodie/notify-rust/commit/89779e8f43978e3d4f72d9a66107a60bc3443d10))
129 | 
130 | ## [v4.6.0](https://github.com/hoodie/notify-rust/compare/v4.5.10...v4.6.0) (2022-12-04)
131 | 
132 | ### Features
133 | 
134 | * update zbus dependency to 3.x
135 | ([8425c05](https://github.com/hoodie/notify-rust/commit/8425c05b9ad945745cba9f16e288d6a8fc9887a6))
136 | 
137 | ### [v4.5.10](https://github.com/hoodie/notify-rust/compare/v4.5.9...v4.5.10) (2022-09-25)
138 | 
139 | #### Fixes
140 | 
141 | * lower minimum rustc version to 1.59.0 for linux (dbus)
142 | ([c0ffeed](https://github.com/hoodie/notify-rust/commit/c0ffeede93816f601a0a8701fb3510c052ce3a0e))
143 | 
144 | ### [v4.5.9](https://github.com/hoodie/notify-rust/compare/v4.5.8...v4.5.9) (2022-09-21)
145 | 
146 | #### Fixes
147 | 
148 | * raise minimum rustc version to 1.60.0 for zbus
149 | ([b3b9aba](https://github.com/hoodie/notify-rust/commit/b3b9aba88fbacfd2c2c406e58cbc020c46895879))
150 | * update winrt-notification to a maintained fork, closes #148
151 | ([7cc6824](https://github.com/hoodie/notify-rust/commit/7cc682428d2f5f0c2335c8ff141fb71af1e01a26)),
152 | closes [#148](https://github.com/hoodie/notify-rust/issues/148)
153 | 
154 | ### [v4.5.8](https://github.com/hoodie/notify-rust/compare/v4.5.7...v4.5.8) (2022-03-26)
155 | 
156 | #### Fixes
157 | 
158 | * re-exported types from mac-notification-sys
159 | ([80daef6](https://github.com/hoodie/notify-rust/commit/80daef6b0dfda0d61697d118c824930bb00a8a35))
160 | 
161 | ### [v4.5.7](https://github.com/hoodie/notify-rust/compare/v4.5.6...v4.5.7) (2022-03-20)
162 | 
163 | #### Fixes
164 | 
165 | * **deps:** update rust crate mac-notification-sys to 0.5.0
166 | ([1f3a9f5](https://github.com/hoodie/notify-rust/commit/1f3a9f5c36c17775885fd6adb80bbf0295219e45))
167 | 
168 | ### [v4.5.6](https://github.com/hoodie/notify-rust/compare/v4.5.5...v4.5.6) (2022-02-04)
169 | 
170 | #### Fixes
171 | 
172 | * update crates zbus to v2, zvariant to v3, zvariant_derive to v3
173 | ([14bca58](https://github.com/hoodie/notify-rust/commit/14bca588efbc88d6a1e00b5abcb5be7db44abfcf))
174 | * **deps:** update rust crate zbus to v2
175 | ([04901a8](https://github.com/hoodie/notify-rust/commit/04901a85fd587ed7482a0bf222d76d7c898369ef))
176 | * **deps:** update rust crate image to 0.24
177 | ([c7fa276](https://github.com/hoodie/notify-rust/commit/c7fa276cab7ffdd2b6e825334837a3515599a3a9))
178 | 
179 | ### [v4.5.5](https://github.com/hoodie/notify-rust/compare/v4.5.4...v4.5.5) (2021-11-04)
180 | 
181 | #### Fixes
182 | 
183 | * **deps:** update rust crate winrt-notification to 0.5
184 | ([6620110](https://github.com/hoodie/notify-rust/commit/6620110a5a8e37b4ac738ccd3df87cda88f57ce8))
185 | 
186 | ### [v4.5.4](https://github.com/hoodie/notify-rust/compare/v4.5.3...v4.5.4) (2021-10-08)
187 | 
188 | #### Fixes
189 | 
190 | * update winrt-notification to 0.4
191 | ([c94e111](https://github.com/hoodie/notify-rust/commit/c94e111f320c75015de9d2177d12f4dce218804b))
192 | 
193 | ### [v4.5.3](https://github.com/hoodie/notify-rust/compare/v4.5.2...v4.5.3) (2021-09-16)
194 | 
195 | #### Fixes
196 | 
197 | * clear up documentation and flip env switch for dual stack
198 | ([3a3b175](https://github.com/hoodie/notify-rust/commit/3a3b1750ce24d2ba54437cfe65a9c8d7dd251cf2))
199 | 
200 | ### [v4.5.2](https://github.com/hoodie/notify-rust/compare/v4.5.1...v4.5.2) (2021-05-14)
201 | 
202 | #### Fixes
203 | 
204 | * clear up documentation of action handling
205 | ([ad35d34](https://github.com/hoodie/notify-rust/commit/ad35d34f93bed6c4f926403d6495972f9dcba273))
206 | 
207 | ### [v4.5.1](https://github.com/hoodie/notify-rust/compare/v4.5.0...v4.5.1) (2021-05-13)
208 | 
209 | #### Fixes
210 | 
211 | * export of ActionResponse
212 | ([3bf2f37](https://github.com/hoodie/notify-rust/commit/3bf2f37836902334f556d66c609d5d52d732284a))
213 | 
214 | ## [v4.5.0](https://github.com/hoodie/notify-rust/compare/v4.4.1...v4.5.0) (2021-05-05)
215 | 
216 | ### Features
217 | 
218 | * **NotificationHandle:** add close reason handling
219 | ([01f9980](https://github.com/hoodie/notify-rust/commit/01f9980e20a687f37391b8c32675436167b4f435)),
220 | closes [#104](https://github.com/hoodie/notify-rust/issues/104)
221 | 
222 | ### [v4.4.1](https://github.com/hoodie/notify-rust/compare/v4.4.0...v4.4.1) (2021-05-01)
223 | 
224 | #### Fixes
225 | 
226 | * notify with __closed when notification is closed in zbus implementation
227 | ([3a9c206](https://github.com/hoodie/notify-rust/commit/3a9c2066929bace67bf88b5882f4296906a7a7dc))
228 | 
229 | ## [v4.4.0](https://github.com/hoodie/notify-rust/compare/v4.3.0...v4.4.0) (2021-04-25)
230 | 
231 | ### Features
232 | 
233 | * add schedule_raw() for f64 timestamps
234 | ([b8f811b](https://github.com/hoodie/notify-rust/commit/b8f811b030c94224a8b6c17cdd49f09a41a417a4))
235 | * add schedule method to Notification
236 | ([30f1741](https://github.com/hoodie/notify-rust/commit/30f1741ca8818fd4552de0b53bf7fc19511886bc))
237 | * create macos schedule_notification method
238 | ([72bda94](https://github.com/hoodie/notify-rust/commit/72bda94d3e0281d8c0dc88343f643099d1963520))
239 | 
240 | ## [v4.3.0](https://github.com/hoodie/notify-rust/compare/v4.2.2...v4.3.0) (2021-02-27)
241 | 
242 | ### Features
243 | 
244 | * Convert DynamicImage::ImageRgba8
245 | ([87e92b5](https://github.com/hoodie/notify-rust/commit/87e92b5d717edcd75f94f66b0f7aed1f04363459))
246 | * Implement TryFrom trait for RgbImage and RgbaImage
247 | ([69c2b1e](https://github.com/hoodie/notify-rust/commit/69c2b1e2417399ea08a13463218c1ef34f64ab25))
248 | * Implement converting image with alpha
249 | ([d25ab47](https://github.com/hoodie/notify-rust/commit/d25ab47b4bdc0d7cab2802787e3f086e32dad29d))
250 | * make zbus backend the default
251 | ([582b87e](https://github.com/hoodie/notify-rust/commit/582b87ec85647e66058f1857bc0a169411ebeb3b))
252 | 
253 | ### [v4.2.2](https://github.com/hoodie/notify-rust/compare/v4.2.1...v4.2.2) (2021-01-08)
254 | 
255 | #### Fixes
256 | 
257 | * remove another stray println
258 | ([bd6ab59](https://github.com/hoodie/notify-rust/commit/bd6ab59d04d23f25da1f333677fc89d90ff2aaf3))
259 | 
260 | ### [v4.2.1](https://github.com/hoodie/notify-rust/compare/v4.2.0...v4.2.1) (2021-01-08)
261 | 
262 | #### Fixes
263 | 
264 | * **deps:** update zbus
265 | ([684d031](https://github.com/hoodie/notify-rust/commit/684d03161470ad119095c86999f169a352d2e4d3))
266 | * **deps:** update rust crate dbus to 0.9
267 | ([96f84f4](https://github.com/hoodie/notify-rust/commit/96f84f4e1c2d025d0d42488f07c178fba012a030))
268 | 
269 | ## [v4.2.0](https://github.com/hoodie/notify-rust/compare/v4.1.1...v4.2.0) (2021-01-08)
270 | 
271 | ### Features
272 | 
273 | * make custom hints unique
274 | ([f6ec445](https://github.com/hoodie/notify-rust/commit/f6ec4453367db915fb1523c8ea223ed3e9cae800)),
275 | closes [#88](https://github.com/hoodie/notify-rust/issues/88)
276 | 
277 | ### Fixes
278 | 
279 | * remove stray dbug!()
280 | ([b67c1d5](https://github.com/hoodie/notify-rust/commit/b67c1d504df2c99f24a8ceef0079b4764ebc52d7))
281 | 
282 | ### [v4.1.1](https://github.com/hoodie/notify-rust/compare/v4.1.0...v4.1.1) (2021-01-07)
283 | 
284 | #### Fixes
285 | 
286 | * remove stray println
287 | ([15b3ecd](https://github.com/hoodie/notify-rust/commit/15b3ecd2be6ec09a1a490187a24ed40e03526d77))
288 | 
289 | ## [v4.1.0](https://github.com/hoodie/notify-rust/compare/v4.0.0...v4.1.0) (2021-01-06)
290 | 
291 | ### Features
292 | 
293 | * add zbus version
294 | ([58d38ba](https://github.com/hoodie/notify-rust/commit/58d38ba98e19b6f382f577416b039bd0dcb4491c))
295 | 
296 | ### Fixes
297 | 
298 | * **deps:** update rust crate image to 0.23
299 | ([1dd236d](https://github.com/hoodie/notify-rust/commit/1dd236d95b9bd47ea4cbfd75d648ba6e93d8a9a0))
300 | 
301 | ## [v4.0.0](https://github.com/hoodie/notify-rust/compare/v3.6.3...v4.0.0) (2020-06-06)
302 | 
303 | ### ⚠ BREAKING CHANGE
304 | 
305 | * remove `From<&str>`
306 | * restructure modules and exports
307 | 
308 | 
309 | ### Features
310 | 
311 | * **windows:** additions to the API (#69)
312 | ([1d9cb0e](https://github.com/hoodie/notify-rust/commit/1d9cb0eb73fdf7f442757a63f2131cb42c4c150f)),
313 | closes [#69](https://github.com/hoodie/notify-rust/issues/69)
314 | * make notification non-exhaustive
315 | ([0304274](https://github.com/hoodie/notify-rust/commit/03042744a05fdab5eff1eee5023c93b2930710d2))
316 | * make error non-exhaustive
317 | ([26f96e4](https://github.com/hoodie/notify-rust/commit/26f96e4a90916496b26a0c955a878b0fe83b9aab))
318 | * drop redundant name prefixes
319 | ([faf3123](https://github.com/hoodie/notify-rust/commit/faf3123bb375a58b57930727da9a09df49830c3e))
320 | * restructure modules and exports
321 | ([45be84c](https://github.com/hoodie/notify-rust/commit/45be84ce976ac3a18d674df7a412ec638861e6b0))
322 | * .image() no longer silently fails
323 | ([8b215bd](https://github.com/hoodie/notify-rust/commit/8b215bd8dfd31655711c522553bb130552930201))
324 | 
325 | ### Fixes
326 | 
327 | * reexport NotificationHandle
328 | ([00edbc9](https://github.com/hoodie/notify-rust/commit/00edbc9a2e44db642d02abfcb6931f0e3bb77563))
329 | 
330 | ### [v3.6.3](https://github.com/hoodie/notify-rust/compare/v3.6.2...v3.6.3) (2019-11-02)
331 | 
332 | #### Fixes
333 | 
334 | * **deps:** update rust crate lazy_static to 1.4
335 | ([687e34d](https://github.com/hoodie/notify-rust/commit/687e34d7a73db36eb2bdeb20e27c8ed18b08f4c1))
336 | * build again after merge conflict
337 | ([bcfc8c8](https://github.com/hoodie/notify-rust/commit/bcfc8c8d41d38bcc51a78ca5febcb4f1adb4d810))
338 | * test-build without `--features image` 🙄
339 | ([3eead0b](https://github.com/hoodie/notify-rust/commit/3eead0b30d189315828a7e4835526e551f0e81a0))
340 | * test-build with `--features image`
341 | ([60e963d](https://github.com/hoodie/notify-rust/commit/60e963de1ea40e29ab09599d26160b206b8acf31))
342 | * test-build with `--features image`
343 | ([92217a2](https://github.com/hoodie/notify-rust/commit/92217a2c83b4c083076978061059175ecb9048ee))
344 | 
345 | ### [v3.6.2](https://github.com/hoodie/notify-rust/compare/v3.6.1...v3.6.2) (2019-08-11)
346 | 
347 | #### Fixes
348 | 
349 | * test-build without `--features image` 🙄
350 | ([0524a5f](https://github.com/hoodie/notify-rust/commit/0524a5fba819a7470525cfdcbcf4dcb4db4b3623))
351 | 
352 | ### [v3.6.1](https://github.com/hoodie/notify-rust/compare/v3.6.0...v3.6.1) (2019-08-11)
353 | 
354 | #### Fixes
355 | 
356 | * test-build with `--features image`
357 | ([8ee6998](https://github.com/hoodie/notify-rust/commit/8ee69984cb5350287581de2b453f225d1fef3de2))
358 | 
359 | ## [v3.6.0](https://github.com/hoodie/notify-rust/compare/v3.5.0...v3.6.0) (2019-05-06)
360 | 
361 | ## [v3.5.0](https://github.com/hoodie/notify-rust/compare/v3.4.3...v3.5.0) (2018-10-21)
362 | 
363 | ### [v3.4.3](https://github.com/hoodie/notify-rust/compare/v3.4.0...v3.4.3) (2018-10-13)
364 | 
365 | ## [v3.4.0](https://github.com/hoodie/notify-rust/compare/v3.2.1...v3.4.0) (2017-05-21)
366 | 
367 | ### [v3.2.1](https://github.com/hoodie/notify-rust/compare/v3.1.1...v3.2.1) (2016-09-07)
368 | 
369 | ### [v3.1.1](https://github.com/hoodie/notify-rust/compare/v3.1.0...v3.1.1) (2016-03-03)
370 | 
371 | ## [v3.1.0](https://github.com/hoodie/notify-rust/compare/v3.0.4...v3.1.0) (2016-03-01)
372 | 
373 | ### [v3.0.4](https://github.com/hoodie/notify-rust/compare/v3.0.3...v3.0.4) (2016-02-15)
374 | 
375 | ### [v3.0.3](https://github.com/hoodie/notify-rust/compare/v3.0.2...v3.0.3) (2016-02-15)
376 | 
377 | ### [v3.0.2](https://github.com/hoodie/notify-rust/compare/v3.0.1...v3.0.2) (2016-02-15)
378 | 
379 | ### [v3.0.1](https://github.com/hoodie/notify-rust/compare/v3.0.0...v3.0.1) (2015-10-23)
380 | 
381 | ## [v3.0.0](https://github.com/hoodie/notify-rust/compare/v2.1.0...v3.0.0) (2015-10-01)
382 | 
383 | ## [v2.1.0](https://github.com/hoodie/notify-rust/compare/v2.0.0...v2.1.0) (2015-09-27)
384 | 
385 | ## [v2.0.0](https://github.com/hoodie/notify-rust/compare/v1.1.0...v2.0.0) (2015-08-04)
386 | 
387 | ## [v1.1.0](https://github.com/hoodie/notify-rust/compare/v1.0.1...v1.1.0) (2015-08-03)
388 | 
389 | ### [v1.0.1](https://github.com/hoodie/notify-rust/compare/v1.0.0...v1.0.1) (2015-07-19)
390 | 
391 | ## [v1.0.0](https://github.com/hoodie/notify-rust/compare/v0.9.0...v1.0.0) (2015-07-12)
392 | 
393 | ## [v0.9.0](https://github.com/hoodie/notify-rust/compare/v0.8.0...v0.9.0) (2015-06-30)
394 | 
395 | ## [v0.8.0](https://github.com/hoodie/notify-rust/compare/v0.0.8...v0.8.0) (2015-06-19)
396 | 
397 | ### [v0.0.8](https://github.com/hoodie/notify-rust/compare/v0.0.7...v0.0.8) (2015-06-19)
398 | 
399 | ### [v0.0.7](https://github.com/hoodie/notify-rust/compare/v0.0.6...v0.0.7) (2015-06-13)
400 | 
401 | ### [v0.0.6](https://github.com/hoodie/notify-rust/compare/v0.0.4...v0.0.6) (2015-06-08)
402 | 
403 | ### [v0.0.4](https://github.com/hoodie/notify-rust/compare/v0.0.3...v0.0.4) (2015-05-30)
404 | 
405 | ### [v0.0.3](https://github.com/hoodie/notify-rust/compare/v0.0.2...v0.0.3) (2015-05-24)
406 | 
407 | ### v0.0.2 (2015-05-22)
408 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "notify-rust"
 3 | version = "4.11.7"
 4 | authors = ["Hendrik Sollich <hendrik@hoodie.de>"]
 5 | description = "Show desktop notifications (linux, bsd, mac). Pure Rust dbus client and server."
 6 | repository = "https://github.com/hoodie/notify-rust"
 7 | documentation = "https://docs.rs/notify-rust/"
 8 | edition = "2021"
 9 | rust-version = "1.63.0"
10 | license = "MIT/Apache-2.0"
11 | keywords = ["desktop", "notification", "notify", "linux", "macos"]
12 | readme = "README.md"
13 | include = [
14 |   "README.md",
15 |   "History.md",
16 |   "CHANGELOG.md",
17 |   "LICENSE-*",
18 |   "Cargo.toml",
19 |   "src/**/*.rs",
20 |   "tests/*.rs"
21 | ]
22 | 
23 | [target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
24 | dbus = { version = "0.9", optional = true }
25 | lazy_static = { version = "1.5", optional = true }
26 | image = { version = "0.25", optional = true }
27 | zbus = { version = "5", optional = true, default-features = false }
28 | serde = { version = "1", optional = true }
29 | log = "0.4"
30 | env_logger ={ version ="0.11", optional = true }
31 | futures-lite = { version = "2.6.0"}
32 | 
33 | [target.'cfg(target_os="macos")'.dependencies]
34 | mac-notification-sys = "0.6"
35 | chrono = { version = "0.4", optional = true}
36 | 
37 | [target.'cfg(target_os="windows")'.dependencies]
38 | winrt-notification = { package = "tauri-winrt-notification", version = "0.7" }
39 | 
40 | [features]
41 | default = ["z"]
42 | # server = []
43 | d = ["dbus"]
44 | d_vendored = ["dbus/vendored"]
45 | z = ["zbus", "serde", "async"]
46 | z-with-tokio = ["zbus", "serde", "tokio"]
47 | async = ["zbus/async-io"]
48 | tokio = ["zbus/tokio"]
49 | debug_namespace = []
50 | images = ["image", "lazy_static"]
51 | 
52 | [dev-dependencies]
53 | color-backtrace = "0.7" # wait for MSVR 1.70 to update
54 | ctor = "0.4"
55 | maplit = "1.0"
56 | 
57 | [dev-dependencies.async-std]
58 | version = "1.12.0"
59 | features = ["attributes"]
60 | 
61 | [[example]]
62 | name = "images"
63 | path = "examples/images.rs"
64 | required-features = ["images"]
65 | 
66 | [[example]]
67 | name = "schedule"
68 | path = "examples/schedule.rs"
69 | required-features = ["chrono"]
70 | 
71 | [[example]]
72 | name = "wait_for_closing_async"
73 | path = "examples/wait_for_closing_async.rs"
74 | required-features = ["async"]
75 | 
76 | [[example]]
77 | name = "simple_async"
78 | path = "examples/simple_async.rs"
79 | required-features = ["async"]
80 | 
81 | [dependencies]
82 | futures-lite = "2.6.0"
83 | 


--------------------------------------------------------------------------------
/History.md:
--------------------------------------------------------------------------------
  1 | v4.0.0-alpha
  2 | ==================
  3 |   * dbus message types are now hidden
  4 |   * rename Notification{Hint, Image, Urgency}
  5 |   * make `hint_from_key_val` a method
  6 |   * reorganize modules
  7 |   * make server an optional feature (was never stable)
  8 |   * remove `handle_actions`
  9 | 
 10 | v3.6.0 / 2019-05-16
 11 | ==================
 12 | 
 13 |   * remove error-chain: use pure std::error implementation
 14 |   * update mac-notification-sys
 15 | 
 16 | v3.5.0 / 2018-10-21
 17 | ===================
 18 | 
 19 |   * update dbus-rs to 0.6
 20 | 
 21 | v3.4.3 / 2018-10-13
 22 | ===================
 23 | 
 24 |   * bump version to 3.4.3
 25 |   * update image and lazy-static
 26 |   * applied some more clippy
 27 |   * Complement requirements documentation and examples
 28 |   * applied some clippy
 29 |   * some manually assisted rustfmt
 30 |   * format examples
 31 |   * cleanups and modernizations
 32 |   * Depedency update
 33 |   * Updated error-chain
 34 |   * including readme in package
 35 |   * update docs link
 36 |   * Create LICENSE-MIT
 37 |   * Create LICENSE-Apache
 38 |   * added requirements to readme
 39 |   * formatting
 40 |   * made NotificationHandle::new() internally public
 41 |   * bumped version to 3.4.1
 42 |   * publicly using NotificationHandle again
 43 |   * Put mac-notificatio-sys errors as foreign links in error.rs
 44 |   * Fix new mac-notification-sys integration
 45 | 
 46 | v3.4.0 / 2017-05-21
 47 | ===================
 48 | 
 49 |   * changed version to 3.4.0
 50 |   * exposing Error again
 51 |   * fixed build issues
 52 |   * feature gate all the things
 53 |   * image!
 54 |   * static spec version and Error
 55 |   * image_data
 56 |   * first working version of image data
 57 |   * badges!
 58 | 
 59 | 3.3.1 / 2017-05-06
 60 | ==================
 61 | 
 62 |   * bumped to version 3.3.1
 63 |   * readme update
 64 |   * add sound example
 65 |   * fix target_os
 66 |   * documented platform compatibility
 67 |   * updating history
 68 |   * examples compile on macOS
 69 |   * Fix some style issues given by clippy (#27)
 70 |   * Minimize number of Timeout <-> i32 convertors (only single pair needed) * Make `dbus::FromMessageItem<'a> for Timeout` produce correct enum for Default and Never cases
 71 |   * removed placeholder `Error`
 72 |   * a little more macOS documentation
 73 |   * simplyfied error handling in show (macOS)
 74 |   * fix missing field in server.rs add missing documentation
 75 |   * updating to mac-notification-sys 0.1.1
 76 |   * split notification summary into title and subtitle
 77 |   * fixing mac-notification-sys usage
 78 |   * satisfied lints
 79 |   * more moving things around
 80 |   * documentation, tests and deduplication
 81 |   * testing platform specific documentation
 82 |   * moved xdg specifics into extra module
 83 |   * target specific deps
 84 |   * first minimal notification on macOS
 85 |   * deprecated .actions
 86 |   * added an extra type for timeout
 87 |   * 3... 2... 1... NEW RELEASE! \0/
 88 | 
 89 | v3.2.1 / 2016-09-07
 90 | ===================
 91 | 
 92 |   * 3... 2... 1... NEW RELEASE! \0/
 93 |   * updated to dbus ~0.4 and fixed warnings
 94 |   * ready to release v3.2.0
 95 |   * example to show notification in bg thread, good enough to fix #18
 96 |   * documentation: more examples
 97 |   * added fn auto_icon()
 98 |   * added on_close(F) method to NotificationHandle
 99 |   * `.show(&mut self)` -> `.show(&self)`
100 |   * chore: applied clippy
101 |   * added use of id when sending
102 |   * pubbed NotificaionHint const strings and added hint_from_key_val
103 |   * removing outdated commandline help from readme
104 |   * fix clippy version again
105 | 
106 | v3.1.1 / 2016-03-03
107 | ===================
108 | 
109 |   * changed version to v3.1.1
110 |   * exposed dbus Error because its returned in public methods
111 | 
112 | v3.1.0 / 2016-03-01
113 | ===================
114 | 
115 |   * changed version to v3.1.0
116 |   * made clippy happy
117 |   * removed redundant example
118 |   * info example print a valid yaml
119 |   * updated examples
120 |   * added examples for custom_int and reuse of notifications
121 |   * added custom int option
122 |   * updated examples to current api
123 | 
124 | v3.0.4 / 2016-02-15
125 | ===================
126 | 
127 |   * updated dbus-rs dependency
128 |   * use cfg unix instead of linux
129 |   * updated to dbus ~0.3
130 |   * minimal preparations for work on macos
131 |   * reduced the TCB
132 |   * fuzzier crate versions
133 | 
134 | v3.0.3 / 2015-11-03
135 | ===================
136 | 
137 |   * made a clippy a dev dependency only
138 | 
139 | v3.0.2 / 2015-11-03
140 | ===================
141 | 
142 |   * removed bin from crate
143 |   * applied "good practices" checks
144 |   * readme examples
145 |   * building against stable
146 |   * no longer testing with 1.0.0, those times are over
147 | 
148 | v3.0.1 / 2015-10-23
149 | ===================
150 | 
151 |   * bin moved in with lib
152 |   * added examples to README
153 |   * works with dbus 0.2.0
154 |   * Add missing docs for ServerInformation
155 |   * Add missing docs for NotificationUrgency
156 |   * Add missing docs to Hint
157 |   * Add missing documentation to NotificationServer
158 |   * Document NotificationHandle::wait_for_action
159 |   * why do I always forget the milk? no, the README :D
160 | 
161 | v3.0.0 / 2015-10-01
162 | ===================
163 | 
164 |   * changed version to 3.0.0
165 |   * test example file for Hints
166 |   * adjusted to new Urgencies
167 |   * Tidying up
168 |   * more documentation
169 |   * added: Urgency::from(&str) for convenience
170 |   * updated changelog and history
171 |   * fixed: hint types other than just strings
172 |   * added convenience from::<str>() for Urgency
173 |   * renamed urgencies: Low, Normal and Critical (as in both standards)
174 |   * resolved timeout TODO
175 |   * fixed doc examples
176 |   * tests and examples
177 |   * added internal `stop_server()`
178 |   * fixed urgency in example
179 |   * removed redundant Urgency field
180 |   * serializing and deserializing Notifications
181 |   * introducing actual error handling, lots of breaking changes
182 |   * renamed get_information example into info.rs
183 |   * more idiomatic implementation of Hints
184 |   * added clippy as dev-dependency
185 |   * Cli: defaulting to --help if not command is issued
186 |   * tracking nightly dbus-rs
187 |   * updated changelog
188 | 
189 | v2.1.0 / 2015-09-27
190 | ===================
191 | 
192 |   * fixed: Hint Types are not only strings
193 | 
194 | v2.0.0 / 2015-08-04
195 | ===================
196 | 
197 |   * changed version to 2.0.0
198 |   * fixed example code to match new api
199 |   * Handle unused_must_use case
200 |   * Update examples and tests
201 |   * Remove old API
202 |   * Impl update, close, etc. for NotificationHandle
203 |   * Set transient hint in wait_for_closing example
204 | 
205 | v1.1.0 / 2015-08-03
206 | ===================
207 | 
208 |   * changed version to 1.1.0
209 |   * small refactoring
210 |   * Add NotificationHandle to keep dbus conns alive
211 |   * added: notify-cli as child project
212 |   * added: GetCapabilities() and GetServerinformation() to server
213 |   * added a few possible panic messages
214 |   * updated readme
215 |   * using src/server for testing
216 | 
217 | v1.0.1 / 2015-07-19
218 | ===================
219 | 
220 |   * fixed: actions and hints were not passed along
221 | 
222 | v1.0.0 / 2015-07-13
223 | ===================
224 | 
225 |   * releasing 1.0.0
226 |   * added hints to `show_debug()`
227 |   * added urgency to `show_debug()`
228 |   * how could I have forgotten `urgency`?
229 |   * building agains dbus 0.1.1
230 |   * improved documentation
231 |   * shields
232 |   * took a note from clippy
233 |   * travis always test against 1.0.0, stable and nightly
234 | 
235 | v0.9.0 / 2015-07-01
236 | ===================
237 | 
238 |   * added: updateing notifications ( see example )
239 |   * replace `.to_string()` with `.to_owned()`
240 |   * updated readme
241 |   * `if let` is nicer than `match`
242 | 
243 | v0.8.0 / 2015-06-19
244 | ===================
245 | 
246 |   * corrected versioning scheme
247 | 
248 | v0.0.8 / 2015-06-19
249 | ===================
250 | 
251 |   * changed version to v0.0.8
252 |   * added: extra example for closing signal alone
253 |   * added `"__closed"` action that is 'invoked' when the Notification closes
254 |   * added doc about show_and_wait_for_action()
255 |   * sacrificed storing closure approach for simpler construct
256 |   * added interface for adding action alongside closure
257 |   * checking for a certain action invoked
258 |   * signal listener breaks on `NotificationClosed` too
259 |   * checking the notificatoin id when waiting for a signal
260 |   * can listen for ActionInvoked signals
261 |   * added waiting_for_action_signal stub
262 |   * removed examples from README, doc should be up to date
263 | 
264 | v0.0.7 / 2015-06-13
265 | ===================
266 | 
267 |   * ready for v0.0.7
268 |   * implemented `GetServerInformation()`
269 |   * Capitalize all the headlines!
270 |   * Urgency is now an enum
271 |   * pack methods return actual empty arrays now (builds with 1.0.0)
272 |   * moved to dbus-rs 0.1.0
273 |   * removed ruby script
274 |   * moved examples into tests
275 |   * added: close_notification
276 |   * is this worth commiting?
277 |   * made exe_name() private
278 |   * elaborated documentation
279 |   * displaying generic version in readme
280 |   * corrected build status image
281 |   * removed doc submodule
282 |   * doc up to date
283 | 
284 | v0.0.6 / 2015-06-08
285 | ===================
286 | 
287 |   * writing history
288 |   * added documentation link
289 |   * changed submodule url
290 |   * added my own gh-pages branch as submodule as branch as submodule
291 |   * added note about Notification::hint()
292 |   * added link to doc to README
293 |   * added: `Notification.action(identifer, label)` for your convenience
294 |   * previous commit only compiles on rust-nightly :(
295 |   * pack methods return actual empty arrays now
296 |   * pack methods return MessageItem directly
297 |   * fixed: index out of bounds when no hints here used
298 |   * added ruby script for testing
299 |   * integrated hints, removed `NotificationCategory`
300 |   * added backend to hints()
301 |   * added: Hints and Categories API frontend
302 |   * renaming crates is generally a bad idea
303 |   * removed travis batch
304 |   * pointed travis batch into right direction
305 |   * removed left over send()s
306 |   * changed dependency notice in readme
307 |   * removed send()
308 |   * updated readme
309 |   * renamed into notify-rust
310 |   * renamed send() into show()
311 |   * added paragraph example
312 |   * changed default timeout -1
313 |   * working on documentation
314 |   * added my ultimate goal
315 |   * added some bookmarks for myself to read
316 |   * wrote a little documentation
317 |   * moved tests out of ./src
318 |   * modified server output
319 |   * added NotificationServer (barely works)
320 |   * implemented Notification::actions()
321 |   * implemented GetCapabilities()
322 |   * send() and send_debug() now returns Notifcation ID
323 |   * travis: build only
324 |   * build dependencies for travis
325 |   * whitespace removal
326 |   * README.md: add travic-ci batch
327 |   * Add support for travis-ci
328 |   * added send_debug to readme
329 | 
330 | v0.0.4 / 2015-05-30
331 | ===================
332 | 
333 |   * changed version to v0.0.4
334 |   * added more examples
335 |   * added: formatting example
336 |   * added: loop_test()
337 |   * added: appname() and send_debug()
338 | 
339 | v0.0.3 / 2015-05-24
340 | ===================
341 | 
342 |   * changed API: using builder pattern now
343 |   * getting ready for 0.0.3
344 |   * removed duplication
345 |   * updated example in README
346 |   * added icon() and timeout() to builder pattern
347 |   * implemented builder pattern
348 |   * trying out a hole lot of design patterns
349 | 
350 | v0.0.2 / 2015-05-22
351 | ===================
352 | 
353 | 
354 | 


--------------------------------------------------------------------------------
/LICENSE-Apache:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Hendrik Sollich
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <div align="center">
 2 | 
 3 | # notify-rust
 4 | 
 5 | [![build](https://img.shields.io/github/actions/workflow/status/hoodie/notify-rust/build-platforms.yml?branch=main)](https://github.com/hoodie/notify-rust/actions?query=workflow%3A"Continuous+Integration")
 6 | [![Crates.io](https://img.shields.io/crates/d/notify-rust)](https://crates.io/crates/notify-rust)
 7 | [![contributors](https://img.shields.io/github/contributors/hoodie/notify-rust)](https://github.com/hoodie/notify-rust/graphs/contributors)
 8 | ![maintenance](https://img.shields.io/maintenance/yes/2025)
 9 | 
10 | [![version](https://img.shields.io/crates/v/notify-rust)](https://crates.io/crates/notify-rust/)
11 | [![documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://docs.rs/notify-rust/)
12 | [![license](https://img.shields.io/crates/l/notify-rust.svg?style=flat)](https://crates.io/crates/notify-rust/)
13 | 
14 | </div>
15 | 
16 | A not so well-named library for displaying desktop notifications.
17 | 
18 | 
19 | ```toml
20 | [dependencies]
21 | notify-rust = "4"
22 | ```
23 | 
24 | ## Usage & Documentation
25 | Please see the [documentation](https://docs.rs/crate/notify-rust/) for current examples.
26 | 
27 | 
28 | ### Simple Notification
29 | ```rust
30 | use notify_rust::Notification;
31 | Notification::new()
32 |     .summary("Firefox News")
33 |     .body("This will almost look like a real firefox notification.")
34 |     .icon("firefox")
35 |     .show()?;
36 | ```
37 | 
38 | ### Persistent Notification
39 | ```rust
40 | use notify_rust::{Notification, Hint};
41 | Notification::new()
42 |     .summary("Category:email")
43 |     .body("This has nothing to do with emails.\nIt should not go away until you acknowledge it.")
44 |     .icon("thunderbird")
45 |     .appname("thunderbird")
46 |     .hint(Hint::Category("email".to_owned()))
47 |     .hint(Hint::Resident(true)) // this is not supported by all implementations
48 |     .timeout(0) // this however is
49 |     .show()?;
50 | ```
51 | 
52 | ## Linux/BSD support
53 | The main audience of this library are Linux/BSD based desktop environments that follow the XDG specification (see [gnome dev docs](http://web.archive.org/web/20200606201408/https://developer.gnome.org/notification-spec/) or [libnotify docs](https://www.galago-project.org/specs/notification/0.9/index.html)). These include KDE, Gnome, XFCE, LXDC, Mate (and probably also most others that I haven't personally tested).
54 | 
55 | ### Features
56 | 
57 | #### `images`
58 | Enables sending of images with notifications. This is only supported on XDG. This will add the [**image** crate](https://lib.rs/image) as a dependency as well as [**lazy_static**](https://lib.rs/lazy_static) to determine the supported spec spec-version on startup.
59 | 
60 | #### `d`
61 | Enables the usage of [**dbus-rs**](https://lib.rs/dbus) instead of [**zbus**](https://lib.rs/zbus) (also XDG only).
62 | This is functionally identical to the default feature set.
63 | **As long as you still compile with default-features this will only enable dbus-rs usage, but not default to it!** In order to use the dbus-rs implementation set the environment variable **`DBUSRS `** or compile notify-rust with **`--no-default-features`**.
64 | 
65 | ## macOS support
66 | This library shines on linux and bsd, which is its original target platform.
67 | Lately it gained support for macOS thanks to [mac-notification-sys](https://crates.io/crates/mac-notification-sys).
68 | However this only includes a small subset of the current functionality, since [`NSNotification`](https://developer.apple.com/reference/foundation/nsnotification)s don't have as many features.
69 | 
70 | **call for participation:** You are a versed macOS UI developer with mad Objective-C skillz? <abbr title="pull request sil vous plait">PRSV</abbr>.
71 | 
72 | ## Windows support
73 | Similar to macOS we support windows via the help of [winrt-notification](https://crates.io/crates/winrt-notification).
74 | 
75 | 
76 | ## Commandline tool
77 | Checkout [toastify](https://github.com/hoodie/toastify), it exposes most of the functionality of the lib to the commandline.
78 | 
79 | ## Contribution
80 | Any help in form of descriptive and friendly [issues](https://github.com/hoodie/notify-rust/issues) or comprehensive pull requests are welcome! 
81 | 
82 | 
83 | Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in notify-rust by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
84 | 
85 | ### Conventions
86 | The Changelog of this library is generated from its commit log, there any commit message must conform with https://www.conventionalcommits.org/en/v1.0.0/. For simplicity you could make your commits with [convco](https://crates.io/crates/convco).
87 | 


--------------------------------------------------------------------------------
/bumpversion.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -xe
 4 | 
 5 | current_branch=`git rev-parse --abbrev-ref HEAD`
 6 | release_branch="main"
 7 | 
 8 | 
 9 | if [ "${current_branch}" != "${release_branch}" ]; then
10 | echo can only bump version on $release_branch
11 | exit 1
12 | fi
13 | 
14 | which convco
15 | which cargo-set-version
16 | 
17 | NEXT_VERSION=`convco version --bump HEAD`
18 | 
19 | cargo set-version $NEXT_VERSION
20 | git add Cargo.toml
21 | git commit -m "chore: bump version"
22 | git tag v$NEXT_VERSION
23 | 
24 | convco changelog > CHANGELOG.md
25 | git add CHANGELOG.md
26 | git commit -m "chore: changelog"
27 | 


--------------------------------------------------------------------------------
/capabilities.md:
--------------------------------------------------------------------------------
 1 | # Sampled Capabilities
 2 | 
 3 | ## unity
 4 | * body
 5 | * body-markup
 6 | * icon-static
 7 | * image/svg+xml
 8 | * x-canonical-private-synchronous
 9 | * x-canonical-append
10 | * x-canonical-private-icon-only
11 | * x-canonical-truncation
12 | * private-synchronous
13 | * append
14 | * private-icon-only
15 | * truncation
16 | 
17 | ## xfce Notifyd
18 | * actions
19 | * body
20 | * body-markup
21 | * body-hyperlinks
22 | * icon-static
23 | * x-canonical-private-icon-only
24 | 
25 | ## kde plasma5
26 | * body
27 | * body-hyperlinks
28 | * body-markup
29 | * icon-static
30 | * actions
31 | 
32 | ## gnome 3
33 | actions
34 | body
35 | body-markup
36 | icon-static
37 | persistence
38 | sound
39 | 
40 | 


--------------------------------------------------------------------------------
/examples/actions.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_imports)]
 2 | use notify_rust::{Hint, Notification};
 3 | 
 4 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 5 | fn main() {
 6 |     println!("this is a xdg only feature");
 7 | }
 8 | 
 9 | #[cfg(all(unix, not(target_os = "macos")))]
10 | fn main() {
11 |     Notification::new()
12 |         .summary("click me")
13 |         .action("default", "default") // IDENTIFIER, LABEL
14 |         .action("clicked_a", "button a") // IDENTIFIER, LABEL
15 |         .action("clicked_b", "button b") // IDENTIFIER, LABEL
16 |         .hint(Hint::Resident(true))
17 |         .show()
18 |         .unwrap()
19 |         .wait_for_action(|action| match action {
20 |             "default" => println!("default"),
21 |             "clicked_a" => println!("clicked a"),
22 |             "clicked_b" => println!("clicked b"),
23 |             // FIXME: here "__closed" is a hardcoded keyword, it will be deprecated!!
24 |             "__closed" => println!("the notification was closed"),
25 |             _ => (),
26 |         });
27 | }
28 | 


--------------------------------------------------------------------------------
/examples/at_bus.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is an xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos",)))]
 7 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 8 |     use notify_rust::Notification;
 9 |     std::env::set_var(
10 |         "RUST_LOG",
11 |         "simple=trace,zbus=trace,server=trace,notify_rust=trace",
12 |     );
13 |     color_backtrace::install();
14 |     #[cfg(feature = "env_logger")]
15 |     env_logger::init();
16 | 
17 |     #[allow(deprecated)]
18 |     Notification::at_bus("example")
19 |         .summary("Critical Error")
20 |         .body("Just <b>kidding</b>, this is just the notification (example).")
21 |         .icon("dialog-error")
22 |         .show()?;
23 |     Ok(())
24 | }
25 | 


--------------------------------------------------------------------------------
/examples/close.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is a xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | fn main() {
 8 |     use notify_rust::*;
 9 |     fn wait_for_keypress(msg: &str) {
10 |         println!("{}", msg);
11 |         std::io::stdin().read_line(&mut String::new()).unwrap();
12 |     }
13 | 
14 |     let handle: NotificationHandle = Notification::new()
15 |         .summary("oh no")
16 |         .hint(Hint::Transient(true))
17 |         .body("I'll be here till you close me!")
18 |         .hint(Hint::Resident(true)) // does not work on kde
19 |         .timeout(Timeout::Never) // works on kde and gnome
20 |         .show()
21 |         .unwrap();
22 | 
23 |     wait_for_keypress("press to close notification");
24 |     handle.close();
25 |     wait_for_keypress("press to exit");
26 | }
27 | 


--------------------------------------------------------------------------------
/examples/countdown.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_imports, dead_code)]
 2 | use notify_rust::Notification;
 3 | use std::time::Duration;
 4 | 
 5 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 6 | fn main() {
 7 |     println!("this is a xdg only feature")
 8 | }
 9 | 
10 | #[cfg(all(unix, not(target_os = "macos")))]
11 | fn main() {
12 |     let mut notification = Notification::new()
13 |         .summary("Rocket launch in ...")
14 |         .body("count down")
15 |         .icon("clock")
16 |         .timeout(0)
17 |         .show()
18 |         .unwrap();
19 | 
20 |     for i in 0..11 {
21 |         std::thread::sleep(Duration::from_millis(1_000));
22 |         notification
23 |             .body(&format!("T-minus {}", 10 - i))
24 |             .appname(&format!("countdown_{}", 10 - i));
25 |         notification.update();
26 |         println!("{}", 10 - i);
27 |     }
28 | 
29 |     notification
30 |         .body("TAKE OFF")
31 |         .appname("countdown_takeoff")
32 |         .show()
33 |         .unwrap();
34 | }
35 | 


--------------------------------------------------------------------------------
/examples/formatting.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_must_use)]
 2 | use notify_rust::Notification;
 3 | 
 4 | fn main() {
 5 |     Notification::new()
 6 |         .summary("Formatting")
 7 |         .appname("chromium")
 8 |         .body(&format!("This is not chrome, but <b>{}</b>!<br/>", "bold"))
 9 |         .icon("chromium")
10 |         .show();
11 | 
12 |     Notification::new()
13 |         .summary("Table Test - will probably not work")
14 |         .body(&format!(
15 |             "<table><tr><td>{}</td><td>cell 2</td></tr> <tr><td>cell 3</td><td>cell 4</td></tr></table>",
16 |             "cell 1"
17 |         ))
18 |         .icon("table")
19 |         .show();
20 | 
21 |     Notification::new()
22 |         .summary("linebreaks")
23 |         .body(
24 |             "This should be a paragraph, this is why I wrote more than one line worth of text, only to make it linebreak.
25 |              This should be another paragraph."
26 |         )
27 |         .icon("thunderbird")
28 |         .show();
29 |     Notification::new()
30 |         .summary("Paragraphs")
31 |         .body(
32 |             "<p>This should be a paragraph, this is why I wrote more than one line worth of text, only to make it linebreak.</p>
33 |              <p>This should be another paragraph.</p> <p>This should be another paragraph.</p>"
34 |         )
35 |         .icon("thunderbird")
36 |         .show();
37 | }
38 | 


--------------------------------------------------------------------------------
/examples/hints.rs:
--------------------------------------------------------------------------------
  1 | #![allow(unused_imports, dead_code)]
  2 | use std::{thread::sleep, time::Duration};
  3 | 
  4 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
  5 | use notify_rust::Image;
  6 | use notify_rust::{Hint, Notification, Urgency::*};
  7 | 
  8 | fn freeze(message: &str) {
  9 |     println!("{message}\n");
 10 |     let mut _devnull = String::new();
 11 |     let _ = std::io::stdin().read_line(&mut _devnull);
 12 | }
 13 | 
 14 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 15 | fn main() {
 16 |     println!("this is an xdg only feature")
 17 | }
 18 | 
 19 | #[cfg(all(unix, not(target_os = "macos")))]
 20 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 21 |     println!("Pay close attention to the output of:");
 22 |     println!("$ dbus-monitor \"interface=org.freedesktop.Notifications\"");
 23 | 
 24 |     freeze("actionicons");
 25 |     Notification::new().hint(Hint::ActionIcons(true)).show()?;
 26 | 
 27 |     freeze("urgency: low, medium, high");
 28 |     Notification::new()
 29 |         .summary("low")
 30 |         .hint(Hint::Urgency(Low))
 31 |         .show()?;
 32 |     Notification::new()
 33 |         .summary("normal")
 34 |         .hint(Hint::Urgency(Normal))
 35 |         .show()?;
 36 |     Notification::new()
 37 |         .summary("critical")
 38 |         .hint(Hint::Urgency(Critical))
 39 |         .show()?;
 40 | 
 41 |     freeze("category");
 42 |     Notification::new()
 43 |         .hint(Hint::Category("device.removed".into()))
 44 |         .show()?;
 45 | 
 46 |     freeze("DesktopEntry");
 47 |     Notification::new()
 48 |         .summary("desktop entry")
 49 |         .hint(Hint::DesktopEntry("firefox".into()))
 50 |         .show()?;
 51 | 
 52 |     freeze("ImagePath");
 53 |     Notification::new()
 54 |         .summary("iconpath")
 55 |         .hint(Hint::ImagePath(
 56 |             "/usr/share/icons/hicolor/128x128/apps/firefox.png".into(),
 57 |         ))
 58 |         .show()?;
 59 | 
 60 |     freeze("Resident");
 61 |     Notification::new()
 62 |         .summary("resident")
 63 |         .hint(Hint::Resident(true))
 64 |         .show()?;
 65 | 
 66 |     freeze("SoundFile");
 67 |     Notification::new()
 68 |         .summary("soundfile")
 69 |         .hint(Hint::SoundFile(
 70 |             "/usr/share/sounds/alsa/Front_Left.wav".to_owned(),
 71 |         ))
 72 |         .hint(Hint::SoundName("system sound".to_owned()))
 73 |         .hint(Hint::SuppressSound(false))
 74 |         .show()?;
 75 | 
 76 |     freeze("Transient");
 77 |     Notification::new()
 78 |         .summary("transient")
 79 |         .hint(Hint::Transient(false))
 80 |         .show()?;
 81 | 
 82 |     freeze("X and Y");
 83 |     Notification::new()
 84 |         .hint(Hint::X(200))
 85 |         .hint(Hint::Y(200))
 86 |         .show()?;
 87 | 
 88 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 89 |     {
 90 |         freeze("ImageData");
 91 |         let mut image_data = vec![0; 128 * 128 * 3];
 92 |         for i in 0..128 * 128 * 3 {
 93 |             image_data[i] = (i % 256) as u8;
 94 |         }
 95 |         Notification::new()
 96 |             .hint(Hint::ImageData(
 97 |                 Image::from_rgb(128, 128, image_data).unwrap(),
 98 |             ))
 99 |             .summary("You should see stripes in this notification");
100 |     }
101 | 
102 |     Ok(())
103 | 
104 |     // freeze("Custom");
105 |     // Notification::new().hint(Hint::Custom("foo","bar")).show();
106 | }
107 | 


--------------------------------------------------------------------------------
/examples/images.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_imports)]
 2 | 
 3 | use notify_rust::Hint;
 4 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 5 | use notify_rust::Image;
 6 | use notify_rust::Notification;
 7 | 
 8 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 9 | fn main() {
10 |     println!("this is a xdg only feature")
11 | }
12 | 
13 | #[cfg(all(not(feature = "images"), unix, not(target_os = "macos")))]
14 | fn main() {
15 |     println!("please build with '--features=images'")
16 | }
17 | 
18 | #[cfg(all(
19 |     feature = "images",
20 |     unix,
21 |     not(target_os = "macos"),
22 |     not(target_os = "windows")
23 | ))]
24 | fn main() -> Result<(), Box<dyn std::error::Error>> {
25 |     fn image_data() -> Vec<u8> {
26 |         let mut image_data = vec![0; 128 * 128 * 3];
27 |         for i in 0..128 * 128 * 3 {
28 |             image_data[i] = (i % 256) as u8;
29 |         }
30 |         image_data
31 |     }
32 | 
33 |     Notification::new()
34 |         .summary("Generated Image (.hint())")
35 |         .body("You should see stripes in this notification")
36 |         .hint(Hint::ImageData(Image::from_rgb(128, 128, image_data())?))
37 |         .show()?;
38 | 
39 |     Notification::new()
40 |         .summary("Generated Image (.image_data())")
41 |         .body("You should see stripes in this notification")
42 |         .image_data(Image::from_rgb(128, 128, image_data())?)
43 |         .show()?;
44 | 
45 |     Notification::new()
46 |         .summary(".image()")
47 |         .body("Trying to open an image")
48 |         .image("./examples/octodex.jpg")?
49 |         .show()?;
50 | 
51 |     Notification::new()
52 |         .summary(".image_path()")
53 |         .body("Trying to open an image")
54 |         .image_path("./examples/octodex.jpg")
55 |         .show()?;
56 | 
57 |     Ok(())
58 | }
59 | 


--------------------------------------------------------------------------------
/examples/info.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(all(unix, not(target_os = "macos")))]
 2 | fn main() {
 3 |     #[cfg(feature = "env_logger")]
 4 |     env_logger::init();
 5 |     match notify_rust::get_server_information() {
 6 |         Ok(info) => {
 7 |             println!("{}:", info.name);
 8 |             println!("  ServerInformation:");
 9 |             println!("    name: {}", info.name);
10 |             println!("    vendor: {}", info.vendor);
11 |             println!("    version: {}", info.version);
12 |             println!("    spec_version: {}", info.spec_version);
13 |             println!(
14 |                 "  capabilities:  {:#?}",
15 |                 notify_rust::get_capabilities().unwrap_or_default()
16 |             );
17 |         }
18 |         Err(err) => eprintln!("error: {}", err),
19 |     }
20 | }
21 | 
22 | #[cfg(any(target_os = "windows", target_os = "macos"))]
23 | fn main() {
24 |     println!("this is a xdg only feature")
25 | }
26 | 


--------------------------------------------------------------------------------
/examples/mac.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(target_os = "macos")]
 2 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 3 |     use notify_rust::Notification;
 4 | 
 5 |     Notification::new()
 6 |         .summary("Safari Crashed")
 7 |         .body("Just kidding, this is just the notify_rust example.")
 8 |         .appname("Toastify")
 9 |         .icon("Toastify")
10 |         .show()?;
11 | 
12 |     Ok(())
13 | }
14 | 
15 | #[cfg(all(unix, not(target_os = "macos")))]
16 | fn main() {
17 |     println!("this is a mac only feature")
18 | }
19 | 
20 | #[cfg(target_os = "windows")]
21 | fn main() {
22 |     println!("this is a mac only feature")
23 | }
24 | 


--------------------------------------------------------------------------------
/examples/mac_app_id.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(target_os = "macos")]
 2 | fn main() -> Result<(), String> {
 3 |     use notify_rust::{
 4 |         error::MacOsError, get_bundle_identifier_or_default, set_application, Notification,
 5 |     };
 6 | 
 7 |     let safari_id = get_bundle_identifier_or_default("Safari");
 8 |     set_application(&safari_id).map_err(|f| format!("{f}"))?;
 9 | 
10 |     match set_application(&safari_id) {
11 |         Ok(_) => {}
12 |         Err(MacOsError::Application(error)) => println!("{error}"),
13 |         Err(MacOsError::Notification(error)) => println!("{error}"),
14 |     }
15 | 
16 |     Notification::new()
17 |         .summary("Safari Crashed")
18 |         .body("Just kidding, this is just the notify_rust example.")
19 |         .appname("Safari")
20 |         .icon("Safari")
21 |         .show()
22 |         .map_err(|f| format!("{f}"))?;
23 | 
24 |     Ok(())
25 | }
26 | 
27 | #[cfg(all(unix, not(target_os = "macos")))]
28 | fn main() {
29 |     println!("this is a mac only feature")
30 | }
31 | 
32 | #[cfg(target_os = "windows")]
33 | fn main() {
34 |     println!("this is a mac only feature")
35 | }
36 | 


--------------------------------------------------------------------------------
/examples/minimal.rs:
--------------------------------------------------------------------------------
1 | use notify_rust::Notification;
2 | 
3 | fn main() -> Result<(), Box<dyn std::error::Error>> {
4 |     Notification::new().summary("minimal notification").show()?;
5 |     Ok(())
6 | }
7 | 


--------------------------------------------------------------------------------
/examples/octodex.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hoodie/notify-rust/895280c0209786f87bb7dbaf751561bed13eb4cd/examples/octodex.jpg


--------------------------------------------------------------------------------
/examples/on_close.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_imports, dead_code)]
 2 | use std::{io, thread};
 3 | 
 4 | use notify_rust::Notification;
 5 | 
 6 | fn wait_for_keypress() {
 7 |     println!("halted until you hit the \"ANY\" key");
 8 |     io::stdin().read_line(&mut String::new()).unwrap();
 9 | }
10 | 
11 | fn print() {
12 |     println!("notification was closed, don't know why");
13 | }
14 | 
15 | #[cfg(any(target_os = "windows", target_os = "macos"))]
16 | fn main() {
17 |     println!("this is a xdg only feature")
18 | }
19 | 
20 | #[cfg(all(unix, not(target_os = "macos")))]
21 | fn main() {
22 |     thread::spawn(|| {
23 |         Notification::new()
24 |             .summary("Time is running out")
25 |             .body("This will go away.")
26 |             .icon("clock")
27 |             .show()
28 |             .map(|handler| handler.on_close(print))
29 |     });
30 |     wait_for_keypress();
31 | }
32 | 


--------------------------------------------------------------------------------
/examples/on_close_reason.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_imports, dead_code)]
 2 | use std::{io, thread};
 3 | 
 4 | #[cfg(all(unix, not(target_os = "macos")))]
 5 | use notify_rust::{CloseReason, Notification};
 6 | 
 7 | fn wait_for_keypress() {
 8 |     println!("halted until you hit the \"ANY\" key");
 9 |     io::stdin().read_line(&mut String::new()).unwrap();
10 | }
11 | 
12 | #[cfg(all(unix, not(target_os = "macos")))]
13 | fn print_reason(reason: CloseReason) {
14 |     println!("notification was closed ({:?})", reason);
15 | }
16 | 
17 | #[cfg(any(target_os = "macos", target_os = "windows"))]
18 | fn main() {
19 |     println!("this is a xdg only feature")
20 | }
21 | 
22 | #[cfg(all(unix, not(target_os = "macos")))]
23 | fn main() {
24 |     thread::spawn(|| {
25 |         Notification::new()
26 |             .summary("Time is running out")
27 |             .body("This will go away.")
28 |             .icon("clock")
29 |             .show()
30 |             .map(|handler| handler.on_close(print_reason))
31 |     });
32 |     wait_for_keypress();
33 | }
34 | 


--------------------------------------------------------------------------------
/examples/persistent.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is a xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 8 |     use notify_rust::{Hint, Timeout};
 9 | 
10 |     notify_rust::Notification::new()
11 |         .summary("Persistent notification")
12 |         .body("This should not go away unless you want it to.")
13 |         .icon("firefox")
14 |         .hint(Hint::Resident(true)) // does not work on kde
15 |         .timeout(Timeout::Never) // works on kde and gnome
16 |         .show()?;
17 |     Ok(())
18 | }
19 | 


--------------------------------------------------------------------------------
/examples/progress.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is an xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 8 |     let mut notification = notify_rust::Notification::new()
 9 |         .summary("progress")
10 |         .show()?;
11 |     for i in 0..=10 {
12 |         let value = i * 10;
13 |         notification
14 |             .body(&format!("progress {}%", value))
15 |             .hint(notify_rust::Hint::CustomInt("value".to_string(), value));
16 |         std::thread::sleep(std::time::Duration::from_secs(1));
17 |         notification.update();
18 |     }
19 |     Ok(())
20 | }
21 | 


--------------------------------------------------------------------------------
/examples/reuse.rs:
--------------------------------------------------------------------------------
 1 | use notify_rust::Notification;
 2 | fn main() {
 3 |     // here we create a notification and then reuse a second time
 4 | 
 5 |     let mut notification = Notification::new()
 6 |         .summary("News update")
 7 |         .icon("computer")
 8 |         .body("Something bad happened")
 9 |         .finalize();
10 | 
11 |     notification.show().unwrap();
12 | 
13 |     std::thread::sleep(std::time::Duration::from_millis(1500));
14 | 
15 |     notification.body("just kidding, nothing happened");
16 |     notification.show().unwrap();
17 | }
18 | 


--------------------------------------------------------------------------------
/examples/schedule.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(target_os = "macos")]
 2 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 3 |     use notify_rust::Notification;
 4 | 
 5 |     let duration = chrono::Duration::milliseconds(4321);
 6 |     let timestamp = (chrono::Utc::now() + duration).timestamp() as f64;
 7 | 
 8 |     Notification::new()
 9 |         .summary("Oh by the way")
10 |         .body(&format!("this was scheduled {:?} ago", duration))
11 |         .schedule(chrono::Utc::now() + duration)?;
12 | 
13 |     Notification::new()
14 |         .summary("Oh by the way")
15 |         .body(&format!("this was scheduled for timestamp {}", timestamp))
16 |         .schedule_raw(timestamp)?;
17 | 
18 |     Ok(())
19 | }
20 | 
21 | #[cfg(all(unix, not(target_os = "macos")))]
22 | fn main() {
23 |     println!("this is a mac only feature")
24 | }
25 | 
26 | #[cfg(target_os = "windows")]
27 | fn main() {
28 |     println!("this is a mac only feature")
29 | }
30 | 


--------------------------------------------------------------------------------
/examples/show_volume.rs:
--------------------------------------------------------------------------------
 1 | //! Show Volume example
 2 | //!
 3 | //! Only works on unity
 4 | //!
 5 | 
 6 | #![allow(unused_imports, dead_code)]
 7 | use notify_rust::Hint;
 8 | use notify_rust::Notification;
 9 | use std::time::Duration;
10 | 
11 | enum Volume {
12 |     Muted,
13 |     Percent(i32),
14 | }
15 | 
16 | #[cfg(all(unix, not(target_os = "macos")))]
17 | fn show_volume(percent: Volume) {
18 |     let icon = match percent {
19 |         Volume::Muted => "notification-audio-volume-muted",
20 |         Volume::Percent(0) => "notification-audio-volume-off",
21 |         Volume::Percent(x) if x < 33 => "notification-audio-volume-low",
22 |         Volume::Percent(x) if x < 67 => "notification-audio-volume-medium",
23 |         _ => "notification-audio-volume-high",
24 |     };
25 | 
26 |     let value = match percent {
27 |         Volume::Muted => 0,
28 |         Volume::Percent(p) => p,
29 |     };
30 | 
31 |     Notification::new()
32 |         .summary(" ")
33 |         .icon(icon)
34 |         .hint(Hint::SoundName("audio-volume-change".into()))
35 |         .hint(Hint::Custom("synchronous".into(), "volume".into()))
36 |         .hint(Hint::CustomInt("value".into(), value))
37 |         .show()
38 |         .unwrap();
39 | }
40 | 
41 | #[cfg(any(windows, target_os = "macos"))]
42 | fn main() {
43 |     println!("this is an xdg only feature")
44 | }
45 | 
46 | #[cfg(all(unix, not(target_os = "macos")))]
47 | fn main() {
48 |     show_volume(Volume::Muted);
49 |     for i in 1..11 {
50 |         std::thread::sleep(Duration::from_millis(1_000));
51 |         show_volume(Volume::Percent(i * 10));
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/examples/simple.rs:
--------------------------------------------------------------------------------
 1 | use notify_rust::Notification;
 2 | 
 3 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 4 |     Notification::new()
 5 |         .summary("Critical Error")
 6 |         .body("Just <b>kidding</b>, this is just the notificationexample.")
 7 |         .icon("dialog-error")
 8 |         .show()?;
 9 |     Ok(())
10 | }
11 | 


--------------------------------------------------------------------------------
/examples/simple_async.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is an xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | #[async_std::main]
 8 | async fn main() -> Result<(), Box<dyn std::error::Error>> {
 9 |     use notify_rust::Notification;
10 |     Notification::new()
11 |         .summary("async notification")
12 |         .body("this notification was sent via an async api")
13 |         .icon("dialog-positive")
14 |         .show_async()
15 |         .await?;
16 |     Ok(())
17 | }
18 | 


--------------------------------------------------------------------------------
/examples/sound.rs:
--------------------------------------------------------------------------------
 1 | #![allow(unused_must_use)]
 2 | use notify_rust::Notification;
 3 | 
 4 | #[cfg(target_os = "macos")]
 5 | static SOUND: &str = "Submarine";
 6 | 
 7 | #[cfg(all(unix, not(target_os = "macos")))]
 8 | static SOUND: &str = "message-new-instant";
 9 | 
10 | #[cfg(target_os = "windows")]
11 | static SOUND: &str = "Mail";
12 | 
13 | fn main() {
14 |     Notification::new()
15 |         .summary("notification with sound")
16 |         .sound_name(SOUND)
17 |         .show()
18 |         .unwrap();
19 | }
20 | 


--------------------------------------------------------------------------------
/examples/stack.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(all(unix, not(target_os = "macos")))]
 2 | fn main() {
 3 |     println!("{:?}", notify_rust::dbus_stack());
 4 | }
 5 | 
 6 | #[cfg(target_os = "macos")]
 7 | fn main() {
 8 |     println!("mac-notification-sys")
 9 | }
10 | 
11 | #[cfg(target_os = "windows")]
12 | fn main() {
13 |     println!("winrt-notification")
14 | }
15 | 


--------------------------------------------------------------------------------
/examples/timeout.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is a xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 8 |     use notify_rust::*;
 9 |     use std::time::Duration;
10 | 
11 |     Notification::new()
12 |         .summary("Notification Duration timeout")
13 |         .body("this one should stay for 2s")
14 |         .icon("timer")
15 |         .timeout(Duration::from_secs(2))
16 |         .show()?;
17 | 
18 |     Notification::new()
19 |         .summary("Notification ms timeout")
20 |         .body("this one should stay for 2s (2000ms)")
21 |         .icon("timer")
22 |         .timeout(2_000)
23 |         .show()?;
24 | 
25 |     Notification::new()
26 |         .summary("Notification string timeout")
27 |         .body("this one should stay for 2s (\"2000\")")
28 |         .icon("timer")
29 |         .timeout("2000".parse::<Timeout>().unwrap())
30 |         .show()?;
31 |     Ok(())
32 | }
33 | 


--------------------------------------------------------------------------------
/examples/update.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use notify_rust::Notification;
 3 | use std::time::Duration;
 4 | 
 5 | #[cfg(target_os = "windows")]
 6 | fn main() {
 7 |     println!("This is not a windows feature")
 8 | }
 9 | 
10 | #[cfg(all(unix, not(target_os = "macos")))]
11 | fn update_via_handle() {
12 |     let mut notification_handle = Notification::new()
13 |         .summary("First Notification")
14 |         .body("This notification will be changed!")
15 |         .icon("dialog-warning")
16 |         .show()
17 |         .unwrap();
18 | 
19 |     std::thread::sleep(Duration::from_millis(1_500));
20 | 
21 |     notification_handle
22 |         .appname("foo") // changing appname to keep plasma from merging the new and the old one
23 |         .icon("dialog-ok")
24 |         .body("<b>This</b> has been changed through the notification_handle");
25 | 
26 |     notification_handle.update();
27 | }
28 | 
29 | #[allow(dead_code)]
30 | #[cfg(all(unix, not(target_os = "macos")))]
31 | fn update_via_manually_stored_id() {
32 |     let handle = Notification::new()
33 |         .summary("First Notification")
34 |         .body("This notification will be changed!")
35 |         .icon("dialog-warning")
36 |         .show()
37 |         .unwrap();
38 | 
39 |     let id = handle.id();
40 |     std::thread::sleep(Duration::from_millis(1_500));
41 | 
42 |     Notification::new()
43 |         .appname("foo") // changing appname to keep plasma from merging the new and the old one
44 |         .icon("dialog-ok")
45 |         .body("<b>This</b> has been changed by sending a new notification with the same id")
46 |         .id(id)
47 |         .show()
48 |         .unwrap();
49 | }
50 | 
51 | fn recycling_one_id() {
52 |     for i in 1..5 {
53 |         let id = 6666; // you should probably not do this at all
54 |         std::thread::sleep(Duration::from_millis(500));
55 |         Notification::new()
56 |             .icon("dialog-ok")
57 |             .body(&format!("notification{i}"))
58 |             .id(id)
59 |             .show()
60 |             .unwrap();
61 |     }
62 | }
63 | 
64 | #[cfg(target_os = "macos")]
65 | fn main() {
66 |     println!("this is a xdg only feature")
67 | }
68 | 
69 | #[cfg(all(unix, not(target_os = "macos")))]
70 | fn main() {
71 |     // please use the handle to update a notification
72 |     update_via_handle();
73 | 
74 |     //// If your really have to, store the if yourself
75 |     // update_via_manually_stored_id();
76 | 
77 |     //// or come up with your own don't do this:
78 |     recycling_one_id()
79 | }
80 | 


--------------------------------------------------------------------------------
/examples/urgency.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is an xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 8 |     use notify_rust::{Notification, Urgency::*};
 9 |     // use it this way
10 |     for urgency in &[Low, Normal, Critical] {
11 |         Notification::new()
12 |             .summary(&format!("Urgency {:?}", urgency))
13 |             .body("This notification uses hints")
14 |             .icon("firefox")
15 |             .urgency(*urgency)
16 |             .show()?;
17 |     }
18 | 
19 |     Notification::new()
20 |         .body("Urgency from String")
21 |         .icon("dialog-warning")
22 |         .urgency("high".try_into()?)
23 |         .show()?;
24 | 
25 |     Ok(())
26 | }
27 | 


--------------------------------------------------------------------------------
/examples/wait_for_closing.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is an xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | 
 8 | fn main() {
 9 |     use notify_rust::CloseReason;
10 | 
11 |     notify_rust::Notification::new()
12 |         .summary("Don't Mind me")
13 |         .hint(notify_rust::Hint::Transient(true))
14 |         .body("I'll be gone soon enough.\nSorry for the inconvenience.")
15 |         .show()
16 |         .unwrap()
17 |         .on_close(|reason: CloseReason| println!("the notification was closed reason: {reason:?}"));
18 | }
19 | 


--------------------------------------------------------------------------------
/examples/wait_for_closing_async.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(any(target_os = "windows", target_os = "macos"))]
 2 | fn main() {
 3 |     println!("this is an xdg only feature")
 4 | }
 5 | 
 6 | #[cfg(all(unix, not(target_os = "macos")))]
 7 | 
 8 | fn main() {
 9 |     use notify_rust::CloseReason;
10 | 
11 |     zbus::block_on(async {
12 |         let handle = notify_rust::Notification::new()
13 |             .summary("Don't Mind me")
14 |             .hint(notify_rust::Hint::Transient(true))
15 |             .body("I'll be gone soon enough.\nSorry for the inconvenience.")
16 |             .show_async()
17 |             .await;
18 | 
19 |         match handle {
20 |             Ok(handle) => handle.on_close(|reason: CloseReason| {
21 |                 println!("the notification was closed reason: {reason:?}")
22 |             }),
23 |             Err(error) => println!("failed to send notification {error}"),
24 |         }
25 |     })
26 | }
27 | 


--------------------------------------------------------------------------------
/examples/windows.rs:
--------------------------------------------------------------------------------
 1 | extern crate notify_rust;
 2 | use notify_rust::Notification;
 3 | 
 4 | fn main() {
 5 |     Notification::new()
 6 |         .summary("Notify Rust Windows")
 7 |         .body("yay, we have limited windows support\nWith multiple lines\nSound\nImages")
 8 |         .show()
 9 |         .unwrap();
10 | }
11 | 


--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": [
3 |     "config:base"
4 |   ]
5 | }
6 | 


--------------------------------------------------------------------------------
/server_infos.yaml:
--------------------------------------------------------------------------------
 1 | # this is to replace capabilities.md
 2 | Plasma:
 3 |   ServerInformation:
 4 |     name: Plasma
 5 |     vendor: KDE
 6 |     version: 2.0
 7 |     spec_version: 1.1
 8 |   capabilities:  [
 9 |     "body",
10 |     "body-hyperlinks",
11 |     "body-markup",
12 |     "icon-static",
13 |     "actions"
14 | ]
15 | notify-osd:
16 |   ServerInformation:
17 |     name: notify-osd
18 |     vendor: Canonical Ltd
19 |     version: 1.0
20 |     spec_version: 1.1
21 |   capabilities:  [
22 |     "body",
23 |     "body-markup",
24 |     "icon-static",
25 |     "image/svg+xml",
26 |     "x-canonical-private-synchronous",
27 |     "x-canonical-append",
28 |     "x-canonical-private-icon-only",
29 |     "x-canonical-truncation",
30 |     "private-synchronous",
31 |     "append",
32 |     "private-icon-only",
33 |     "truncation"
34 | ]
35 | gnome-shell:
36 |   ServerInformation:
37 |     name: gnome-shell
38 |     vendor: GNOME
39 |     version: 3.22.3
40 |     spec_version: 1.2
41 |   capabilities:  [
42 |     "actions",
43 |     "body",
44 |     "body-markup",
45 |     "icon-static",
46 |     "persistence",
47 |     "sound"
48 | ]
49 | Xfce Notify Daemon:
50 |   ServerInformation:
51 |     name: Xfce Notify Daemon
52 |     vendor: Xfce
53 |     version: 0.4.3
54 |     spec_version: 1.2
55 |   capabilities:  [
56 |     "actions",
57 |     "body",
58 |     "body-hyperlinks",
59 |     "body-markup",
60 |     "icon-static",
61 |     "x-canonical-private-icon-only"
62 | ]
63 | 


--------------------------------------------------------------------------------
/src/error.rs:
--------------------------------------------------------------------------------
  1 | #![allow(missing_docs)]
  2 | 
  3 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
  4 | use crate::image::ImageError;
  5 | use std::{fmt, num};
  6 | /// Convenient wrapper around `std::Result`.
  7 | pub type Result<T> = std::result::Result<T, Error>;
  8 | 
  9 | #[cfg(target_os = "macos")]
 10 | pub use crate::macos::{ApplicationError, MacOsError, NotificationError};
 11 | 
 12 | /// The Error type.
 13 | #[derive(Debug)]
 14 | pub struct Error {
 15 |     kind: ErrorKind,
 16 | }
 17 | 
 18 | /// The kind of an error.
 19 | #[derive(Debug)]
 20 | #[non_exhaustive]
 21 | pub enum ErrorKind {
 22 |     /// only here for backwards compatibility
 23 |     Msg(String),
 24 | 
 25 |     #[cfg(all(feature = "dbus", unix, not(target_os = "macos")))]
 26 |     Dbus(dbus::Error),
 27 | 
 28 |     #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
 29 |     Zbus(zbus::Error),
 30 | 
 31 |     #[cfg(target_os = "macos")]
 32 |     MacNotificationSys(mac_notification_sys::error::Error),
 33 | 
 34 |     Parse(num::ParseIntError),
 35 | 
 36 |     SpecVersion(String),
 37 | 
 38 |     Conversion(String),
 39 | 
 40 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 41 |     Image(ImageError),
 42 | 
 43 |     ImplementationMissing,
 44 | }
 45 | 
 46 | impl fmt::Display for Error {
 47 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 48 |         match self.kind {
 49 |             #[cfg(all(feature = "dbus", unix, not(target_os = "macos")))]
 50 |             ErrorKind::Dbus(ref e) => write!(f, "{}", e),
 51 | 
 52 |             #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
 53 |             ErrorKind::Zbus(ref e) => write!(f, "{}", e),
 54 | 
 55 |             #[cfg(target_os = "macos")]
 56 |             ErrorKind::MacNotificationSys(ref e) => write!(f, "{e}"),
 57 | 
 58 |             ErrorKind::Parse(ref e) => write!(f, "Parsing Error: {e}"),
 59 |             ErrorKind::Conversion(ref e) => write!(f, "Conversion Error: {e}"),
 60 |             ErrorKind::SpecVersion(ref e) | ErrorKind::Msg(ref e) => write!(f, "{e}"),
 61 |             #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 62 |             ErrorKind::Image(ref e) => write!(f, "{}", e),
 63 |             ErrorKind::ImplementationMissing => write!(
 64 |                 f,
 65 |                 r#"No Dbus implementation available, please compile with either feature ="z" or feature="d""#
 66 |             ),
 67 |         }
 68 |     }
 69 | }
 70 | 
 71 | impl std::error::Error for Error {}
 72 | 
 73 | impl From<&str> for Error {
 74 |     fn from(e: &str) -> Error {
 75 |         Error {
 76 |             kind: ErrorKind::Msg(e.into()),
 77 |         }
 78 |     }
 79 | }
 80 | 
 81 | #[cfg(all(feature = "dbus", unix, not(target_os = "macos")))]
 82 | impl From<dbus::Error> for Error {
 83 |     fn from(e: dbus::Error) -> Error {
 84 |         Error {
 85 |             kind: ErrorKind::Dbus(e),
 86 |         }
 87 |     }
 88 | }
 89 | 
 90 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
 91 | impl From<zbus::Error> for Error {
 92 |     fn from(e: zbus::Error) -> Error {
 93 |         Error {
 94 |             kind: ErrorKind::Zbus(e),
 95 |         }
 96 |     }
 97 | }
 98 | 
 99 | #[cfg(target_os = "macos")]
100 | impl From<mac_notification_sys::error::Error> for Error {
101 |     fn from(e: mac_notification_sys::error::Error) -> Error {
102 |         Error {
103 |             kind: ErrorKind::MacNotificationSys(e),
104 |         }
105 |     }
106 | }
107 | 
108 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
109 | impl From<ImageError> for Error {
110 |     fn from(e: ImageError) -> Error {
111 |         Error {
112 |             kind: ErrorKind::Image(e),
113 |         }
114 |     }
115 | }
116 | 
117 | impl From<num::ParseIntError> for Error {
118 |     fn from(e: num::ParseIntError) -> Error {
119 |         Error {
120 |             kind: ErrorKind::Parse(e),
121 |         }
122 |     }
123 | }
124 | 
125 | impl From<ErrorKind> for Error {
126 |     fn from(kind: ErrorKind) -> Error {
127 |         Error { kind }
128 |     }
129 | }
130 | 
131 | /// Just the usual bail macro
132 | #[macro_export]
133 | #[doc(hidden)]
134 | macro_rules! bail {
135 |     ($e:expr) => {
136 |         return Err($e.into());
137 |     };
138 |     ($fmt:expr, $($arg:tt)+) => {
139 |         return Err(format!($fmt, $($arg)+).into());
140 |     };
141 | }
142 | 
143 | /// Exits a function early with an `Error` if the condition is not satisfied.
144 | ///
145 | /// Similar to `assert!`, `ensure!` takes a condition and exits the function
146 | /// if the condition fails. Unlike `assert!`, `ensure!` returns an `Error`,
147 | /// it does not panic.
148 | #[macro_export(local_inner_macros)]
149 | #[doc(hidden)]
150 | macro_rules! ensure {
151 |     ($cond:expr, $e:expr) => {
152 |         if !($cond) {
153 |             bail!($e);
154 |         }
155 |     };
156 |     ($cond:expr, $fmt:expr, $($arg:tt)*) => {
157 |         if !($cond) {
158 |             bail!($fmt, $($arg)*);
159 |         }
160 |     };
161 | }
162 | 


--------------------------------------------------------------------------------
/src/hints.rs:
--------------------------------------------------------------------------------
  1 | #![cfg_attr(rustfmt, rustfmt_skip)]
  2 | 
  3 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
  4 | use zbus::zvariant;
  5 | 
  6 | #[cfg(all(unix, not(target_os = "macos")))]
  7 | pub(crate) mod message;
  8 | 
  9 | #[cfg(all(feature = "images", any(feature = "dbus", feature = "zbus"), unix, not(target_os = "macos")))]
 10 | use crate::image::Image;
 11 | 
 12 | #[cfg(all(feature = "images", feature = "zbus", unix, not(target_os = "macos")))]
 13 | use crate::image::image_spec_str;
 14 | use crate::Urgency;
 15 | 
 16 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))] use crate::notification::Notification;
 17 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))] use std::collections::HashMap;
 18 | 
 19 | mod constants;
 20 | 
 21 | #[cfg(all(unix, not(target_os = "macos")))]
 22 | #[derive(Eq, PartialEq, Hash, Clone, Debug)]
 23 | pub(crate) enum CustomHintType {
 24 |     Int,
 25 |     String,
 26 | }
 27 | 
 28 | /// `Hints` allow you to pass extra information to the server.
 29 | ///
 30 | /// Many of these are standardized by:
 31 | ///
 32 | /// * <https://specifications.freedesktop.org/notification-spec/latest/hints.html>
 33 | ///
 34 | /// Which of these are actually implemented depends strongly on the Notification server you talk to.
 35 | /// Usually the [`get_capabilities()`](`crate::get_capabilities`) gives some clues, but the standards usually mention much more
 36 | /// than is actually available.
 37 | ///
 38 | /// you pass these to [`Notification::hint`]
 39 | #[derive(Eq, PartialEq, Hash, Clone, Debug)]
 40 | pub enum Hint {
 41 |     /// If true, server may interpret action identifiers as named icons and display those.
 42 |     ActionIcons(bool),
 43 | 
 44 |     /// Check out:
 45 |     ///
 46 |     /// * <https://specifications.freedesktop.org/notification-spec/latest/hints.html>
 47 |     Category(String),
 48 | 
 49 |     /// Name of the `DesktopEntry` representing the calling application. In case of "firefox.desktop"
 50 |     /// use "firefox". May be used to retrieve the correct icon.
 51 |     DesktopEntry(String),
 52 | 
 53 |     /// Image as raw data
 54 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 55 |     ImageData(Image),
 56 | 
 57 |     /// Display the image at this path.
 58 |     ImagePath(String),
 59 | 
 60 |     /// This does not work on all servers, however timeout=0 will do the job
 61 |     Resident(bool),
 62 | 
 63 |     /// Play the sound at this path.
 64 |     SoundFile(String),
 65 | 
 66 |     /// A themeable named sound from the freedesktop.org [sound naming specification](http://0pointer.de/public/sound-naming-spec.html) to play when the notification pops up. Similar to icon-name, only for sounds. An example would be "message-new-instant".
 67 |     SoundName(String),
 68 | 
 69 |     /// Suppress the notification sound.
 70 |     SuppressSound(bool),
 71 | 
 72 |     /// When set the server will treat the notification as transient and by-pass the server's persistence capability, if it should exist.
 73 |     Transient(bool),
 74 | 
 75 |     /// Lets the notification point to a certain 'x' position on the screen.
 76 |     /// Requires `Y`.
 77 |     X(i32),
 78 | 
 79 |     /// Lets the notification point to a certain 'y' position on the screen.
 80 |     /// Requires `X`.
 81 |     Y(i32),
 82 | 
 83 |     /// Pass me a Urgency, either Low, Normal or Critical
 84 |     Urgency(Urgency),
 85 | 
 86 |     /// If you want to pass something entirely different.
 87 |     Custom(String, String),
 88 | 
 89 |     /// A custom numerical (integer) hint
 90 |     CustomInt(String, i32),
 91 | 
 92 |     /// Only used by this `NotificationServer` implementation
 93 |     Invalid // TODO find a better solution to this
 94 | }
 95 | 
 96 | impl Hint {
 97 |     /// Get the `bool` representation of this hint.
 98 |     pub fn as_bool(&self) -> Option<bool> {
 99 |         match *self {
100 |             | Hint::ActionIcons(inner)
101 |             | Hint::Resident(inner)
102 |             | Hint::SuppressSound(inner)
103 |             | Hint::Transient(inner) => Some(inner),
104 |             _ => None
105 |         }
106 |     }
107 | 
108 |     /// Get the `i32` representation of this hint.
109 |     pub fn as_i32(&self) -> Option<i32> {
110 |         match *self {
111 |             Hint::X(inner) | Hint::Y(inner) => Some(inner),
112 |             _ => None
113 |         }
114 |     }
115 | 
116 |     /// Get the `&str` representation of this hint.
117 |     pub fn as_str(&self) -> Option<&str> {
118 |         match *self {
119 |             Hint::DesktopEntry(ref inner) |
120 |             Hint::ImagePath(ref inner)    |
121 |             Hint::SoundFile(ref inner)    |
122 |             Hint::SoundName(ref inner)    => Some(inner),
123 |             _ => None
124 |         }
125 |     }
126 | 
127 |     /// convenience converting a name and value into a hint
128 |     pub fn from_key_val(name: &str, value: &str) -> Result<Hint, String> {
129 |         match (name,value){
130 |             (constants::ACTION_ICONS,val)    => val.parse::<bool>().map(Hint::ActionIcons).map_err(|e|e.to_string()),
131 |             (constants::CATEGORY, val)       => Ok(Hint::Category(val.to_owned())),
132 |             (constants::DESKTOP_ENTRY, val)  => Ok(Hint::DesktopEntry(val.to_owned())),
133 |             (constants::IMAGE_PATH, val)     => Ok(Hint::ImagePath(val.to_owned())),
134 |             (constants::RESIDENT, val)       => val.parse::<bool>().map(Hint::Resident).map_err(|e|e.to_string()),
135 |             (constants::SOUND_FILE, val)     => Ok(Hint::SoundFile(val.to_owned())),
136 |             (constants::SOUND_NAME, val)     => Ok(Hint::SoundName(val.to_owned())),
137 |             (constants::SUPPRESS_SOUND, val) => val.parse::<bool>().map(Hint::SuppressSound).map_err(|e|e.to_string()),
138 |             (constants::TRANSIENT, val)      => val.parse::<bool>().map(Hint::Transient).map_err(|e|e.to_string()),
139 |             (constants::X, val)              => val.parse::<i32>().map(Hint::X).map_err(|e|e.to_string()),
140 |             (constants::Y, val)              => val.parse::<i32>().map(Hint::Y).map_err(|e|e.to_string()),
141 |             _                                => Err(String::from("unknown name"))
142 |         }
143 |     }
144 | }
145 | 
146 | #[cfg(all(unix, not(target_os = "macos")))]
147 | impl Hint {}
148 | 
149 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
150 | #[test]
151 | fn test_hints_to_map() {
152 | 
153 |     // custom value should only be there once if the names are identical
154 | 
155 |     let n1 = Notification::new()
156 |         .hint(Hint::Custom("foo".into(), "bar1".into()))
157 |         .hint(Hint::Custom("foo".into(), "bar2".into()))
158 |         .hint(Hint::Custom("f00".into(), "bar3".into()))
159 |         .finalize();
160 | 
161 |      assert_eq!(hints_to_map(&n1), maplit::hashmap!{
162 |          "foo" => zvariant::Value::Str("bar2".into()),
163 |          "f00" => zvariant::Value::Str("bar3".into())
164 |      });
165 | }
166 | 
167 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
168 | pub(crate) fn hints_to_map(notification: &Notification) -> HashMap::<&str, zvariant::Value<'_>> {
169 |     notification
170 |         .get_hints()
171 |         .map(Into::into)
172 |         .collect()
173 | }
174 | 
175 | #[cfg(all(feature = "zbus", unix, not(target_os = "macos")))]
176 | impl<'a> From<&'a Hint> for (&'a str, zvariant::Value<'a>) {
177 |     fn from(val: &'a Hint) -> Self {
178 |         use self::constants::*;
179 |         match val {
180 |             Hint::ActionIcons(value)       => (ACTION_ICONS   , zvariant::Value::Bool(*value)), // bool
181 |             Hint::Category(value)          => (CATEGORY       , zvariant::Value::Str(value.as_str().into())),
182 |             Hint::DesktopEntry(value)      => (DESKTOP_ENTRY  , zvariant::Value::Str(value.as_str().into())),
183 | 
184 |             #[cfg(all(feature = "zbus", feature = "images", unix, not(target_os = "macos")))]
185 |             //Hint::ImageData(image)         => (image_spec(*crate::SPEC_VERSION).as_str(), ImagePayload::from(*image).into()),
186 |             Hint::ImageData(image)         => (
187 |                 image_spec_str(*crate::SPEC_VERSION),
188 |                 zvariant::Value::Structure(
189 |                     image.to_tuple().into()
190 |                 )
191 |             ),
192 | 
193 | 
194 |             Hint::ImagePath(value)         => (IMAGE_PATH     , zvariant::Value::Str(value.as_str().into())),
195 |             Hint::Resident(value)          => (RESIDENT       , zvariant::Value::Bool(*value)), // bool
196 |             Hint::SoundFile(value)         => (SOUND_FILE     , zvariant::Value::Str(value.as_str().into())),
197 |             Hint::SoundName(value)         => (SOUND_NAME     , zvariant::Value::Str(value.as_str().into())),
198 |             Hint::SuppressSound(value)     => (SUPPRESS_SOUND , zvariant::Value::Bool(*value)),
199 |             Hint::Transient(value)         => (TRANSIENT      , zvariant::Value::Bool(*value)),
200 |             Hint::X(value)                 => (X              , zvariant::Value::I32(*value)),
201 |             Hint::Y(value)                 => (Y              , zvariant::Value::I32(*value)),
202 |             Hint::Urgency(value)           => (URGENCY        , zvariant::Value::U8(*value as u8)),
203 |             Hint::Custom(key, val)         => (key.as_str()   , zvariant::Value::Str(val.as_str().into())),
204 |             Hint::CustomInt(key, val)      => (key.as_str()   , zvariant::Value::I32(*val)),
205 |             Hint::Invalid                  => (INVALID        , zvariant::Value::Str(INVALID.into()))
206 |         }
207 |     }
208 | }
209 | 
210 | 
211 | #[cfg(all(feature = "dbus", unix, not(target_os = "macos")))]
212 | impl<'a, A: dbus::arg::RefArg> From<(&'a String, &'a A)> for Hint {
213 |     fn from(pair: (&String, &A)) -> Self {
214 | 
215 |         let (key, variant) = pair;
216 |         match (key.as_ref(), variant.as_u64(), variant.as_i64(), variant.as_str().map(String::from)) {
217 | 
218 |             (constants::ACTION_ICONS,   Some(1),  _,       _          ) => Hint::ActionIcons(true),
219 |             (constants::ACTION_ICONS,   _,        _,       _          ) => Hint::ActionIcons(false),
220 |             (constants::URGENCY,        level,    _,       _          ) => Hint::Urgency(level.into()),
221 |             (constants::CATEGORY,       _,        _,       Some(name) ) => Hint::Category(name),
222 | 
223 |             (constants::DESKTOP_ENTRY,  _,        _,       Some(entry)) => Hint::DesktopEntry(entry),
224 |             (constants::IMAGE_PATH,     _,        _,       Some(path) ) => Hint::ImagePath(path),
225 |             (constants::RESIDENT,       Some(1),  _,       _          ) => Hint::Resident(true),
226 |             (constants::RESIDENT,       _,        _,       _          ) => Hint::Resident(false),
227 | 
228 |             (constants::SOUND_FILE,     _,        _,       Some(path) ) => Hint::SoundFile(path),
229 |             (constants::SOUND_NAME,     _,        _,       Some(name) ) => Hint::SoundName(name),
230 |             (constants::SUPPRESS_SOUND, Some(1),  _,       _          ) => Hint::SuppressSound(true),
231 |             (constants::SUPPRESS_SOUND, _,        _,       _          ) => Hint::SuppressSound(false),
232 |             (constants::TRANSIENT,      Some(1),  _,       _          ) => Hint::Transient(true),
233 |             (constants::TRANSIENT,      _,        _,       _          ) => Hint::Transient(false),
234 |             (constants::X,              _,        Some(x), _          ) => Hint::X(x as i32),
235 |             (constants::Y,              _,        Some(y), _          ) => Hint::Y(y as i32),
236 | 
237 |             other => {
238 |                 eprintln!("Invalid Hint {:#?} ", other);
239 |                 Hint::Invalid
240 |             }
241 |         }
242 |     }
243 | }
244 | 


--------------------------------------------------------------------------------
/src/hints/constants.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | 
 3 | pub const ACTION_ICONS: &str    = "action-icons";
 4 | pub const CATEGORY: &str        = "category";
 5 | pub const DESKTOP_ENTRY: &str   = "desktop-entry";
 6 | pub const IMAGE_PATH: &str      = "image-path";
 7 | pub const RESIDENT: &str        = "resident";
 8 | pub const SOUND_FILE: &str      = "sound-file";
 9 | pub const SOUND_NAME: &str      = "sound-name";
10 | pub const SUPPRESS_SOUND: &str  = "suppress-sound";
11 | pub const TRANSIENT: &str       = "transient";
12 | pub const X: &str               = "x";
13 | pub const Y: &str               = "y";
14 | pub const URGENCY: &str         = "urgency";
15 | 
16 | 
17 | pub const INVALID: &str    = "invalid";


--------------------------------------------------------------------------------
/src/hints/message.rs:
--------------------------------------------------------------------------------
  1 | //! `Hints` allow you to pass extra information to the server.
  2 | //!
  3 | //! Many of these are standardized by either:
  4 | //!
  5 | //! [galago-project spec](http://www.galago-project.org/specs/notification/0.9/x344.html) or
  6 | //! [gnome notification-spec](https://developer.gnome.org/notification-spec/#hints)
  7 | //!
  8 | //! Which of these are actually implemented depends strongly on the Notification server you talk to.
  9 | //! Usually the `get_capabilities()` gives some clues, but the standards usually mention much more
 10 | //! than is actually available.
 11 | #![cfg_attr(rustfmt, rustfmt_skip)]
 12 | #![allow(dead_code, unused_imports)]
 13 | 
 14 | 
 15 | use super::{Hint, constants::*};
 16 | use crate ::Urgency;
 17 | 
 18 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 19 | use crate::image::*;
 20 | 
 21 | use std::collections::{HashMap, HashSet};
 22 | #[cfg(feature = "dbus")]
 23 | use dbus::arg::{messageitem::MessageItem, RefArg};
 24 | 
 25 | /// All currently implemented `Hints` that can be sent.
 26 | ///
 27 | /// as found on <https://developer.gnome.org/notification-spec/>
 28 | #[derive(Eq, PartialEq, Hash, Clone, Debug)]
 29 | pub(crate) struct HintMessage(Hint);
 30 | 
 31 | #[cfg(feature = "dbus")]
 32 | impl HintMessage {
 33 |     pub fn wrap_hint(hint: Hint) -> (MessageItem, MessageItem) {
 34 |         Self::from(hint).into()
 35 |     }
 36 | }
 37 | 
 38 | impl From<Hint> for HintMessage {
 39 |     fn from(hint: Hint) -> Self {
 40 |         HintMessage(hint)
 41 |     }
 42 | }
 43 | 
 44 | impl std::ops::Deref for HintMessage {
 45 |     type Target = Hint;
 46 | 
 47 |     fn deref(&self) -> &Self::Target {
 48 |         &self.0
 49 |     }
 50 | }
 51 | 
 52 | #[cfg(feature = "dbus")]
 53 | impl<'a, A: RefArg> From<(&'a String, &'a A)> for HintMessage {
 54 |     fn from(pair: (&String, &A)) -> Self {
 55 | 
 56 |         let (key, variant) = pair;
 57 |         match (key.as_ref(), variant.as_u64(), variant.as_i64(), variant.as_str().map(String::from)) {
 58 | 
 59 |             (ACTION_ICONS,   Some(1),  _,       _          ) => Hint::ActionIcons(true),
 60 |             (ACTION_ICONS,   _,        _,       _          ) => Hint::ActionIcons(false),
 61 |             (URGENCY,        level,    _,       _          ) => Hint::Urgency(level.into()),
 62 |             (CATEGORY,       _,        _,       Some(name) ) => Hint::Category(name),
 63 | 
 64 |             (DESKTOP_ENTRY,  _,        _,       Some(entry)) => Hint::DesktopEntry(entry),
 65 |             (IMAGE_PATH,     _,        _,       Some(path) ) => Hint::ImagePath(path),
 66 |             (RESIDENT,       Some(1),  _,       _          ) => Hint::Resident(true),
 67 |             (RESIDENT,       _,        _,       _          ) => Hint::Resident(false),
 68 | 
 69 |             (SOUND_FILE,     _,        _,       Some(path) ) => Hint::SoundFile(path),
 70 |             (SOUND_NAME,     _,        _,       Some(name) ) => Hint::SoundName(name),
 71 |             (SUPPRESS_SOUND, Some(1),  _,       _          ) => Hint::SuppressSound(true),
 72 |             (SUPPRESS_SOUND, _,        _,       _          ) => Hint::SuppressSound(false),
 73 |             (TRANSIENT,      Some(1),  _,       _          ) => Hint::Transient(true),
 74 |             (TRANSIENT,      _,        _,       _          ) => Hint::Transient(false),
 75 |             (X,              _,        Some(x), _          ) => Hint::X(x as i32),
 76 |             (Y,              _,        Some(y), _          ) => Hint::Y(y as i32),
 77 | 
 78 |             other => {
 79 |                 eprintln!("Invalid Hint{:#?} ", other);
 80 |                 Hint::Invalid
 81 |             }
 82 |         }.into()
 83 |     }
 84 | }
 85 | 
 86 | #[cfg(feature = "dbus")]
 87 | impl From<HintMessage> for (MessageItem, MessageItem) {
 88 |     fn from(hint: HintMessage) -> Self {
 89 | 
 90 |         let (key, value): (String, MessageItem) = match hint.0 {
 91 |             Hint::ActionIcons(value)       => (ACTION_ICONS   .to_owned(), MessageItem::Bool(value)), // bool
 92 |             Hint::Category(ref value)      => (CATEGORY       .to_owned(), MessageItem::Str(value.clone())),
 93 |             Hint::DesktopEntry(ref value)  => (DESKTOP_ENTRY  .to_owned(), MessageItem::Str(value.clone())),
 94 |             #[cfg(all(feature = "images", unix, not(target_os ="macos")))]
 95 |             Hint::ImageData(image)         => (image_spec(*crate::SPEC_VERSION), ImageMessage::from(image).into()),
 96 |             Hint::ImagePath(ref value)     => (IMAGE_PATH     .to_owned(), MessageItem::Str(value.clone())),
 97 |             Hint::Resident(value)          => (RESIDENT       .to_owned(), MessageItem::Bool(value)), // bool
 98 |             Hint::SoundFile(ref value)     => (SOUND_FILE     .to_owned(), MessageItem::Str(value.clone())),
 99 |             Hint::SoundName(ref value)     => (SOUND_NAME     .to_owned(), MessageItem::Str(value.clone())),
100 |             Hint::SuppressSound(value)     => (SUPPRESS_SOUND .to_owned(), MessageItem::Bool(value)),
101 |             Hint::Transient(value)         => (TRANSIENT      .to_owned(), MessageItem::Bool(value)),
102 |             Hint::X(value)                 => (X              .to_owned(), MessageItem::Int32(value)),
103 |             Hint::Y(value)                 => (Y              .to_owned(), MessageItem::Int32(value)),
104 |             Hint::Urgency(value)           => (URGENCY        .to_owned(), MessageItem::Byte(value as u8)),
105 |             Hint::Custom(ref key, ref val) => (key            .to_owned(), MessageItem::Str(val.to_owned ())),
106 |             Hint::CustomInt(ref key, val)  => (key            .to_owned(), MessageItem::Int32(val)),
107 |             Hint::Invalid                  => ("invalid"      .to_owned(), MessageItem::Str("Invalid".to_owned()))
108 |         };
109 | 
110 |         (MessageItem::Str(key), MessageItem::Variant(Box::new(value)))
111 |     }
112 | }
113 | 
114 | 
115 | // TODO: deprecated, Prefer the DBus Arg and RefArg APIs
116 | #[cfg(feature = "dbus")]
117 | impl From<(&MessageItem, &MessageItem)> for HintMessage {
118 |     fn from ((key, mut value): (&MessageItem, &MessageItem)) -> Self {
119 |         use Hint as Hint;
120 | 
121 |         // If this is a variant, consider the thing inside it
122 |         // If it's a nested variant, keep drilling down until we get a real value
123 |         while let MessageItem::Variant(inner) = value {
124 |             value = inner;
125 |         }
126 | 
127 |         let is_stringy = value.inner::<&str>().is_ok();
128 | 
129 |         match key.inner::<&str>() {
130 |             Ok(CATEGORY)        => value.inner::<&str>().map(String::from).map(Hint::Category),
131 |             Ok(ACTION_ICONS)    => value.inner().map(Hint::ActionIcons),
132 |             Ok(DESKTOP_ENTRY)   => value.inner::<&str>().map(String::from).map(Hint::DesktopEntry),
133 |             Ok(IMAGE_PATH)      => value.inner::<&str>().map(String::from).map(Hint::ImagePath),
134 |             Ok(RESIDENT)        => value.inner().map(Hint::Resident),
135 |             Ok(SOUND_FILE)      => value.inner::<&str>().map(String::from).map(Hint::SoundFile),
136 |             Ok(SOUND_NAME)      => value.inner::<&str>().map(String::from).map(Hint::SoundName),
137 |             Ok(SUPPRESS_SOUND)  => value.inner().map(Hint::SuppressSound),
138 |             Ok(TRANSIENT)       => value.inner().map(Hint::Transient),
139 |             Ok(X)               => value.inner().map(Hint::X),
140 |             Ok(Y)               => value.inner().map(Hint::Y),
141 |             Ok(URGENCY)         => value.inner().map(|i| match i {
142 |                 0  => Urgency::Low,
143 |                 2  => Urgency::Critical,
144 |                 _  => Urgency::Normal
145 |             }).map(Hint::Urgency),
146 |             Ok(k) if is_stringy => value.inner::<&str>().map(|v| Hint::Custom(k.to_string(), v.to_string())),
147 |             Ok(k)               => value.inner().map(|v| Hint::CustomInt(k.to_string(), v)),
148 |             _ => Err(()),
149 |         }.unwrap_or(Hint::Invalid)
150 |         .into()
151 |     }
152 | }
153 | 
154 | 
155 | #[allow(missing_docs)]
156 | #[cfg(feature = "dbus")]
157 | pub(crate) fn hints_from_variants<A: RefArg>(hints: &HashMap<String, A>) -> HashSet<HintMessage> {
158 |     hints.iter().map(Into::into).collect()
159 | }
160 | 


--------------------------------------------------------------------------------
/src/hints/tests.rs:
--------------------------------------------------------------------------------
 1 | #![cfg(all(test, unix, not(target_os = "macos")))]
 2 | 
 3 | use dbus::arg::messageitem::MessageItem as Item;
 4 | use ctor::ctor;
 5 | 
 6 | use super::*;
 7 | use self::Hint as Hint;
 8 | use super::Urgency::*;
 9 | 
10 | 
11 | #[ctor]
12 | fn init_color_backtrace() {
13 |     color_backtrace::install();
14 | }
15 | 
16 | #[test]
17 | fn hint_to_item() {
18 |     let category = &Hint::Category("test-me".to_owned());
19 |     let (k, v) = category.into();
20 | 
21 |     let test_k = Item::Str("category".into());
22 |     let test_v = Item::Variant(Box::new(Item::Str("test-me".into())));
23 | 
24 |     assert_eq!(k, test_k);
25 |     assert_eq!(v, test_v);
26 | }
27 | 
28 | #[test]
29 | fn urgency() {
30 |     let low = &Hint::Urgency(Low);
31 |     let (k, v) = low.into();
32 | 
33 |     let test_k = Item::Str("urgency".into());
34 |     let test_v = Item::Variant(Box::new(Item::Byte(0)));
35 | 
36 |     assert_eq!(k, test_k);
37 |     assert_eq!(v, test_v);
38 | }
39 | 
40 | #[test]
41 | fn simple_hint_to_item() {
42 |     let old_hint = &Hint::Custom("foo".into(), "bar".into());
43 | 
44 |     let (k, v) = old_hint.into();
45 |     let hint: Hint = (&k, &v).into();
46 | 
47 |     assert_eq!(old_hint, &hint);
48 | }
49 | 
50 | #[test]
51 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
52 | fn imagedata_hint_to_item() {
53 |     let hint = &Hint::ImageData(Image::from_rgb(1, 1, vec![0, 0, 0]).unwrap());
54 |     let item: MessageItem = hint.into();
55 |     let test_item = Item::DictEntry(
56 |         Box::new(Item::Str(image_spec(*::SPEC_VERSION))),
57 |         Box::new(Item::Variant(Box::new(Item::Struct(vec![
58 |             Item::Int32(1),
59 |             Item::Int32(1),
60 |             Item::Int32(3),
61 |             Item::Bool(false),
62 |             Item::Int32(8),
63 |             Item::Int32(3),
64 |             Item::Array(dbus::MessageItemArray::new(vec![
65 |                 Item::Byte(0),
66 |                 Item::Byte(0),
67 |                 Item::Byte(0),
68 |             ],"ay".into()).unwrap())
69 |         ]))))
70 |     );
71 |     assert_eq!(item, test_item);
72 | }
73 | 
74 | #[test]
75 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
76 | fn imagedata_hint_to_item_with_spec() {
77 |     let key = image_spec(Version::new(1, 0));
78 |     assert_eq!(key, String::from("icon_data"));
79 | 
80 |     let key = image_spec(Version::new(1, 1));
81 |     assert_eq!(key, String::from("image_data"));
82 | 
83 |     let key = image_spec(Version::new(1, 2));
84 |     assert_eq!(key, String::from("image-data"));
85 | }
86 | 


--------------------------------------------------------------------------------
/src/image.rs:
--------------------------------------------------------------------------------
  1 | #[cfg(feature = "dbus")]
  2 | use dbus::arg::messageitem::{MessageItem, MessageItemArray};
  3 | pub use image::DynamicImage;
  4 | 
  5 | use std::cmp::Ordering;
  6 | use std::convert::TryFrom;
  7 | use std::error::Error;
  8 | use std::fmt;
  9 | use std::path::Path;
 10 | 
 11 | use crate::miniver::Version;
 12 | 
 13 | mod constants {
 14 |     pub const IMAGE_DATA: &str = "image-data";
 15 |     pub const IMAGE_DATA_1_1: &str = "image_data";
 16 |     pub const IMAGE_DATA_1_0: &str = "icon_data";
 17 | }
 18 | 
 19 | /// Image representation for images. Send via `Notification::image_data()`
 20 | #[derive(PartialEq, Eq, Debug, Clone, Hash)]
 21 | pub struct Image {
 22 |     width: i32,
 23 |     height: i32,
 24 |     rowstride: i32,
 25 |     alpha: bool,
 26 |     bits_per_sample: i32,
 27 |     channels: i32,
 28 |     data: Vec<u8>,
 29 | }
 30 | 
 31 | impl Image {
 32 |     fn from_raw_data(
 33 |         width: i32,
 34 |         height: i32,
 35 |         data: Vec<u8>,
 36 |         channels: i32,
 37 |         bits_per_sample: i32,
 38 |         alpha: bool,
 39 |     ) -> Result<Self, ImageError> {
 40 |         const MAX_SIZE: i32 = 0x0fff_ffff;
 41 |         if width > MAX_SIZE || height > MAX_SIZE {
 42 |             return Err(ImageError::TooBig);
 43 |         }
 44 | 
 45 |         if data.len() != (width * height * channels) as usize {
 46 |             Err(ImageError::WrongDataSize)
 47 |         } else {
 48 |             Ok(Self {
 49 |                 width,
 50 |                 height,
 51 |                 bits_per_sample,
 52 |                 channels,
 53 |                 data,
 54 |                 rowstride: width * channels,
 55 |                 alpha,
 56 |             })
 57 |         }
 58 |     }
 59 | 
 60 |     /// Creates an image from a raw vector of bytes
 61 |     pub fn from_rgb(width: i32, height: i32, data: Vec<u8>) -> Result<Self, ImageError> {
 62 |         let channels = 3i32;
 63 |         let bits_per_sample = 8;
 64 |         Self::from_raw_data(width, height, data, channels, bits_per_sample, false)
 65 |     }
 66 | 
 67 |     /// Creates an image from a raw vector of bytes with alpha
 68 |     pub fn from_rgba(width: i32, height: i32, data: Vec<u8>) -> Result<Self, ImageError> {
 69 |         let channels = 4i32;
 70 |         let bits_per_sample = 8;
 71 |         Self::from_raw_data(width, height, data, channels, bits_per_sample, true)
 72 |     }
 73 | 
 74 |     ///  Attempts to open the given path as image
 75 |     pub fn open<T: AsRef<Path> + Sized>(path: T) -> Result<Self, ImageError> {
 76 |         let dyn_img = image::open(&path).map_err(ImageError::CantOpen)?;
 77 |         Image::try_from(dyn_img)
 78 |     }
 79 | 
 80 |     #[cfg(all(feature = "images", feature = "zbus"))]
 81 |     pub(crate) fn to_tuple(&self) -> (i32, i32, i32, bool, i32, i32, Vec<u8>) {
 82 |         (
 83 |             self.width,
 84 |             self.height,
 85 |             self.rowstride,
 86 |             self.alpha,
 87 |             self.bits_per_sample,
 88 |             self.channels,
 89 |             self.data.clone(),
 90 |         )
 91 |     }
 92 | }
 93 | 
 94 | impl TryFrom<DynamicImage> for Image {
 95 |     type Error = ImageError;
 96 | 
 97 |     fn try_from(dyn_img: DynamicImage) -> Result<Self, Self::Error> {
 98 |         match dyn_img {
 99 |             DynamicImage::ImageRgb8(img) => Self::try_from(img),
100 |             DynamicImage::ImageRgba8(img) => Self::try_from(img),
101 |             _ => Err(ImageError::CantConvert),
102 |         }
103 |     }
104 | }
105 | 
106 | impl TryFrom<image::RgbImage> for Image {
107 |     type Error = ImageError;
108 | 
109 |     fn try_from(img: image::RgbImage) -> Result<Self, Self::Error> {
110 |         let (width, height) = img.dimensions();
111 |         let image_data = img.into_raw();
112 |         Image::from_rgb(width as i32, height as i32, image_data)
113 |     }
114 | }
115 | 
116 | impl TryFrom<image::RgbaImage> for Image {
117 |     type Error = ImageError;
118 | 
119 |     fn try_from(img: image::RgbaImage) -> Result<Self, Self::Error> {
120 |         let (width, height) = img.dimensions();
121 |         let image_data = img.into_raw();
122 |         Image::from_rgba(width as i32, height as i32, image_data)
123 |     }
124 | }
125 | 
126 | /// Errors that can occur when creating an Image
127 | #[derive(Debug)]
128 | pub enum ImageError {
129 |     /// The given image is too big. DBus only has 32 bits for width / height
130 |     TooBig,
131 |     /// The given bytes don't match the width, height and channel count
132 |     WrongDataSize,
133 |     /// Can't open given path
134 |     CantOpen(image::ImageError),
135 |     /// Can't convert from given input
136 |     CantConvert,
137 | }
138 | 
139 | impl Error for ImageError {
140 |     fn source(&self) -> Option<&(dyn Error + 'static)> {
141 |         use ImageError::*;
142 |         match self {
143 |             TooBig | WrongDataSize | CantConvert => None,
144 |             CantOpen(e) => Some(e),
145 |         }
146 |     }
147 | }
148 | 
149 | impl fmt::Display for ImageError {
150 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
151 |         use ImageError::*;
152 |         match self {
153 |             TooBig => writeln!(
154 |                 f,
155 |                 "The given image is too big. DBus only has 32 bits for width / height"
156 |             ),
157 |             WrongDataSize => writeln!(
158 |                 f,
159 |                 "The given bytes don't match the width, height and channel count"
160 |             ),
161 |             CantOpen(e) => writeln!(f, "Can't open given path {}", e),
162 |             CantConvert => writeln!(f, "Can't convert from given input"),
163 |         }
164 |     }
165 | }
166 | 
167 | /// matching image data key for each spec version
168 | #[cfg(feature = "dbus")]
169 | pub(crate) fn image_spec(version: Version) -> String {
170 |     match version.cmp(&Version::new(1, 1)) {
171 |         Ordering::Less => constants::IMAGE_DATA_1_0.to_owned(),
172 |         Ordering::Equal => constants::IMAGE_DATA_1_1.to_owned(),
173 |         Ordering::Greater => constants::IMAGE_DATA.to_owned(),
174 |     }
175 | }
176 | 
177 | /// matching image data key for each spec version
178 | #[cfg(feature = "zbus")]
179 | pub(crate) fn image_spec_str(version: Version) -> &'static str {
180 |     match version.cmp(&Version::new(1, 1)) {
181 |         Ordering::Less => constants::IMAGE_DATA_1_0,
182 |         Ordering::Equal => constants::IMAGE_DATA_1_1,
183 |         Ordering::Greater => constants::IMAGE_DATA,
184 |     }
185 | }
186 | 
187 | #[cfg(feature = "dbus")]
188 | pub struct ImageMessage(Image);
189 | 
190 | #[cfg(feature = "dbus")]
191 | impl From<Image> for ImageMessage {
192 |     fn from(hint: Image) -> Self {
193 |         ImageMessage(hint)
194 |     }
195 | }
196 | 
197 | impl From<image::ImageError> for ImageError {
198 |     fn from(image_error: image::ImageError) -> Self {
199 |         ImageError::CantOpen(image_error)
200 |     }
201 | }
202 | 
203 | #[cfg(feature = "dbus")]
204 | impl std::ops::Deref for ImageMessage {
205 |     type Target = Image;
206 | 
207 |     fn deref(&self) -> &Self::Target {
208 |         &self.0
209 |     }
210 | }
211 | 
212 | #[cfg(feature = "dbus")]
213 | impl From<ImageMessage> for MessageItem {
214 |     fn from(img_msg: ImageMessage) -> Self {
215 |         let img = img_msg.0;
216 | 
217 |         let bytes = img.data.into_iter().map(MessageItem::Byte).collect();
218 | 
219 |         MessageItem::Struct(vec![
220 |             MessageItem::Int32(img.width),
221 |             MessageItem::Int32(img.height),
222 |             MessageItem::Int32(img.rowstride),
223 |             MessageItem::Bool(img.alpha),
224 |             MessageItem::Int32(img.bits_per_sample),
225 |             MessageItem::Int32(img.channels),
226 |             MessageItem::Array(MessageItemArray::new(bytes, "ay".into()).unwrap()),
227 |         ])
228 |     }
229 | }
230 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | //! Desktop Notifications for Rust.
  2 | //!
  3 | //! Desktop notifications are popup messages generated to notify the user of certain events.
  4 | //!
  5 | //! ## Platform Support
  6 | //!
  7 | //! This library was originally conceived with the [XDG](https://en.wikipedia.org/wiki/XDG) notification specification in mind.
  8 | //! Since version 3.3 this crate also builds on macOS, however the semantics of the [XDG](https://en.wikipedia.org/wiki/XDG) specification and macOS `NSNotifications`
  9 | //! are quite different.
 10 | //! Therefore only a very small subset of functions is supported on macOS.
 11 | //! Certain methods don't have any effect there, others will explicitly fail to compile,
 12 | //! in these cases you will have to add platform specific toggles to your code.
 13 | //! For more see [platform differences](#platform-differences)
 14 | //!
 15 | //! # Examples
 16 | //!
 17 | //! ## Example 1: Simple Notification
 18 | //!
 19 | //! ```no_run
 20 | //! # use notify_rust::*;
 21 | //! Notification::new()
 22 | //!     .summary("Firefox News")
 23 | //!     .body("This will almost look like a real firefox notification.")
 24 | //!     .icon("firefox")
 25 | //!     .timeout(Timeout::Milliseconds(6000)) //milliseconds
 26 | //!     .show().unwrap();
 27 | //! ```
 28 | //!
 29 | //! ## Example 2: Persistent Notification
 30 | //!
 31 | //! ```no_run
 32 | //! # use notify_rust::*;
 33 | //! Notification::new()
 34 | //!     .summary("Category:email")
 35 | //!     .body("This has nothing to do with emails.\nIt should not go away until you acknowledge it.")
 36 | //!     .icon("thunderbird")
 37 | //!     .appname("thunderbird")
 38 | //!     .hint(Hint::Category("email".to_owned()))
 39 | //!     .hint(Hint::Resident(true)) // this is not supported by all implementations
 40 | //!     .timeout(Timeout::Never) // this however is
 41 | //!     .show().unwrap();
 42 | //! ```
 43 | //!
 44 | //! Careful! There are no checks whether you use hints twice.
 45 | //! It is possible to set `urgency=Low` AND `urgency=Critical`, in which case the behavior of the server is undefined.
 46 | //!
 47 | //! ## Example 3: Ask the user to do something
 48 | //!
 49 | //! ```no_run
 50 | //! # use notify_rust::*;
 51 | //! # #[cfg(all(unix, not(target_os = "macos")))]
 52 | //! Notification::new().summary("click me")
 53 | //!                    .action("default", "default")
 54 | //!                    .action("clicked", "click here")
 55 | //!                    .hint(Hint::Resident(true))
 56 | //!                    .show()
 57 | //!                    .unwrap()
 58 | //!                    .wait_for_action(|action| match action {
 59 | //!                                         "default" => println!("you clicked \"default\""),
 60 | //!                                         "clicked" => println!("that was correct"),
 61 | //!                                         // here "__closed" is a hard coded keyword
 62 | //!                                         "__closed" => println!("the notification was closed"),
 63 | //!                                         _ => ()
 64 | //!                                     });
 65 | //! ```
 66 | //!
 67 | //! ## Minimal Example
 68 | //!
 69 | //! You can omit almost everything
 70 | //!
 71 | //! ```no_run
 72 | //! # use notify_rust::Notification;
 73 | //! Notification::new().show();
 74 | //! ```
 75 | //!
 76 | //! more [examples](https://github.com/hoodie/notify-rust/tree/main/examples) in the repository.
 77 | //!
 78 | //! # Platform Differences
 79 | //! <details>
 80 | //! ✔︎ = works <br/>
 81 | //! ❌ = will not compile
 82 | //!
 83 | //! ## `Notification`
 84 | //! | method              | XDG   | macOS | windows |
 85 | //! |---------------------|-------|-------|---------|
 86 | //! |  `fn appname(...)`  |  ✔︎    |       |        |
 87 | //! |  `fn summary(...)`  |  ✔︎    | ✔︎     |  ✔︎    |
 88 | //! |  `fn subtitle(...)` |       | ✔︎     |  ✔︎    |
 89 | //! |  `fn body(...)`     |  ✔︎    | ✔︎     |  ✔︎    |
 90 | //! |  `fn icon(...)`     |  ✔︎    |       |        |
 91 | //! |  `fn auto_icon(...)`|  ✔︎    |       |        |
 92 | //! |  `fn hint(...)`     |  ✔︎    | ❌    | ❌    |
 93 | //! |  `fn timeout(...)`  |  ✔︎    |       |  ✔︎    |
 94 | //! |  `fn urgency(...)`  |  ✔︎    | ❌    | ❌    |
 95 | //! |  `fn action(...)`   |  ✔︎    |       |        |
 96 | //! |  `fn id(...)`       |  ✔︎    |       |        |
 97 | //! |  `fn finalize(...)` |  ✔︎    | ✔︎     |  ✔︎    |
 98 | //! |  `fn show(...)`     |  ✔︎    | ✔︎     |  ✔︎    |
 99 | //!
100 | //! ## `NotificationHandle`
101 | //!
102 | //! | method                   | XDG | macOS | windows |
103 | //! |--------------------------|-----|-------|---------|
104 | //! | `fn wait_for_action(...)`|  ✔︎  |  ❌  |   ❌   |
105 | //! | `fn close(...)`          |  ✔︎  |  ❌  |   ❌   |
106 | //! | `fn on_close(...)`       |  ✔︎  |  ❌  |   ❌   |
107 | //! | `fn update(...)`         |  ✔︎  |  ❌  |   ❌   |
108 | //! | `fn id(...)`             |  ✔︎  |  ❌  |   ❌   |
109 | //!
110 | //! ## Functions
111 | //!
112 | //! |                                            | XDG | macOS | windows |
113 | //! |--------------------------------------------|-----|-------|---------|
114 | //! | `fn get_capabilities(...)`                 | ✔︎   |   ❌ |  ❌    |
115 | //! | `fn get_server_information(...)`           | ✔︎   |   ❌ |  ❌    |
116 | //! | `fn set_application(...)`                  | ❌  |   ✔︎  |  ❌    |
117 | //! | `fn get_bundle_identifier_or_default(...)` | ❌  |   ✔︎  |  ❌    |
118 | //!
119 | //!
120 | //! ### Toggles
121 | //!
122 | //! Please use `target_os` toggles if you plan on using methods labeled with ❌.
123 | //!
124 | //! ```ignore
125 | //! #[cfg(target_os = "macos")]
126 | //! // or
127 | //! // #### #[cfg(all(unix, not(target_os = "macos")))]
128 | //! ```
129 | //! </details>
130 | //!
131 | 
132 | #![deny(
133 |     missing_copy_implementations,
134 |     trivial_casts,
135 |     trivial_numeric_casts,
136 |     unsafe_code,
137 |     unused_import_braces,
138 |     unused_qualifications
139 | )]
140 | #![warn(
141 |     missing_docs,
142 |     clippy::doc_markdown,
143 |     clippy::semicolon_if_nothing_returned,
144 |     clippy::single_match_else,
145 |     clippy::inconsistent_struct_constructor,
146 |     clippy::map_unwrap_or,
147 |     clippy::match_same_arms
148 | )]
149 | 
150 | #[cfg(all(feature = "dbus", unix, not(target_os = "macos")))]
151 | extern crate dbus;
152 | 
153 | #[cfg(target_os = "macos")]
154 | extern crate mac_notification_sys;
155 | 
156 | #[cfg(target_os = "windows")]
157 | extern crate winrt_notification;
158 | 
159 | #[macro_use]
160 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
161 | extern crate lazy_static;
162 | 
163 | pub mod error;
164 | mod hints;
165 | mod miniver;
166 | mod notification;
167 | mod timeout;
168 | pub(crate) mod urgency;
169 | 
170 | #[cfg(target_os = "macos")]
171 | mod macos;
172 | 
173 | #[cfg(target_os = "windows")]
174 | mod windows;
175 | 
176 | #[cfg(all(unix, not(target_os = "macos")))]
177 | mod xdg;
178 | 
179 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
180 | mod image;
181 | 
182 | #[cfg(target_os = "macos")]
183 | pub use mac_notification_sys::{get_bundle_identifier_or_default, set_application};
184 | 
185 | #[cfg(target_os = "macos")]
186 | pub use macos::NotificationHandle;
187 | 
188 | #[cfg(all(
189 |     any(feature = "dbus", feature = "zbus"),
190 |     unix,
191 |     not(target_os = "macos")
192 | ))]
193 | pub use crate::xdg::{
194 |     dbus_stack, get_capabilities, get_server_information, handle_action, ActionResponse,
195 |     CloseHandler, CloseReason, DbusStack, NotificationHandle,
196 | };
197 | 
198 | // #[cfg(all(feature = "server", unix, not(target_os = "macos")))]
199 | // pub use crate::xdg::stop_server;
200 | 
201 | pub use crate::hints::Hint;
202 | 
203 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
204 | pub use crate::image::{Image, ImageError};
205 | 
206 | #[cfg_attr(
207 |     target_os = "macos",
208 |     deprecated(note = "Urgency is not supported on macOS")
209 | )]
210 | pub use crate::urgency::Urgency;
211 | 
212 | pub use crate::{notification::Notification, timeout::Timeout};
213 | 
214 | #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
215 | lazy_static! {
216 |     /// Read once at runtime. Needed for Images
217 |     pub static ref SPEC_VERSION: miniver::Version =
218 |         get_server_information()
219 |         .and_then(|info| info.spec_version.parse::<miniver::Version>())
220 |         .unwrap_or_else(|_| miniver::Version::new(1,1));
221 | }
222 | /// Return value of `get_server_information()`.
223 | #[derive(Debug)]
224 | pub struct ServerInformation {
225 |     /// The product name of the server.
226 |     pub name: String,
227 |     /// The vendor name.
228 |     pub vendor: String,
229 |     /// The server's version string.
230 |     pub version: String,
231 |     /// The specification version the server is compliant with.
232 |     pub spec_version: String,
233 | }
234 | 


--------------------------------------------------------------------------------
/src/macos.rs:
--------------------------------------------------------------------------------
 1 | use crate::{error::*, notification::Notification};
 2 | 
 3 | pub use mac_notification_sys::error::{ApplicationError, Error as MacOsError, NotificationError};
 4 | 
 5 | use std::ops::{Deref, DerefMut};
 6 | 
 7 | /// A handle to a shown notification.
 8 | ///
 9 | /// This keeps a connection alive to ensure actions work on certain desktops.
10 | #[derive(Debug)]
11 | pub struct NotificationHandle {
12 |     notification: Notification,
13 | }
14 | 
15 | impl NotificationHandle {
16 |     #[allow(missing_docs)]
17 |     pub fn new(notification: Notification) -> NotificationHandle {
18 |         NotificationHandle { notification }
19 |     }
20 | }
21 | 
22 | impl Deref for NotificationHandle {
23 |     type Target = Notification;
24 | 
25 |     fn deref(&self) -> &Notification {
26 |         &self.notification
27 |     }
28 | }
29 | 
30 | /// Allow to easily modify notification properties
31 | impl DerefMut for NotificationHandle {
32 |     fn deref_mut(&mut self) -> &mut Notification {
33 |         &mut self.notification
34 |     }
35 | }
36 | 
37 | pub(crate) fn show_notification(notification: &Notification) -> Result<NotificationHandle> {
38 |     mac_notification_sys::Notification::default()
39 |         .title(notification.summary.as_str())
40 |         .message(&notification.body)
41 |         .maybe_subtitle(notification.subtitle.as_deref())
42 |         .maybe_sound(notification.sound_name.as_deref())
43 |         .send()?;
44 | 
45 |     Ok(NotificationHandle::new(notification.clone()))
46 | }
47 | 
48 | pub(crate) fn schedule_notification(
49 |     notification: &Notification,
50 |     delivery_date: f64,
51 | ) -> Result<NotificationHandle> {
52 |     mac_notification_sys::Notification::default()
53 |         .title(notification.summary.as_str())
54 |         .message(&notification.body)
55 |         .maybe_subtitle(notification.subtitle.as_deref())
56 |         .maybe_sound(notification.sound_name.as_deref())
57 |         .delivery_date(delivery_date)
58 |         .send()?;
59 | 
60 |     Ok(NotificationHandle::new(notification.clone()))
61 | }
62 | 


--------------------------------------------------------------------------------
/src/miniver.rs:
--------------------------------------------------------------------------------
 1 | use crate::error::*;
 2 | use std::str::FromStr;
 3 | 
 4 | #[derive(Copy, Clone, Eq, Debug)]
 5 | pub struct Version {
 6 |     pub major: u64,
 7 |     pub minor: u64,
 8 | }
 9 | 
10 | impl Version {
11 |     #[allow(dead_code)]
12 |     pub fn new(major: u64, minor: u64) -> Self {
13 |         Self { major, minor }
14 |     }
15 | }
16 | 
17 | impl FromStr for Version {
18 |     type Err = Error;
19 |     fn from_str(s: &str) -> Result<Version> {
20 |         let vv = s.split('.').collect::<Vec<&str>>();
21 |         match (vv.first(), vv.get(1)) {
22 |             (Some(maj), Some(min)) => Ok(Version {
23 |                 major: maj.parse()?,
24 |                 minor: min.parse()?,
25 |             }),
26 |             _ => Err(ErrorKind::SpecVersion(s.into()).into()),
27 |         }
28 |     }
29 | }
30 | 
31 | use std::cmp;
32 | 
33 | impl PartialOrd for Version {
34 |     fn partial_cmp(&self, other: &Version) -> Option<cmp::Ordering> {
35 |         Some(self.cmp(other))
36 |     }
37 | }
38 | 
39 | impl PartialEq for Version {
40 |     fn eq(&self, other: &Version) -> bool {
41 |         self.major == other.major && self.minor == other.minor
42 |     }
43 | }
44 | 
45 | impl Ord for Version {
46 |     fn cmp(&self, other: &Version) -> cmp::Ordering {
47 |         match self.major.cmp(&other.major) {
48 |             cmp::Ordering::Equal => {}
49 |             r => return r,
50 |         }
51 |         match self.minor.cmp(&other.minor) {
52 |             cmp::Ordering::Equal => {}
53 |             r => return r,
54 |         }
55 |         cmp::Ordering::Equal
56 |     }
57 | }
58 | 
59 | #[cfg(test)]
60 | mod tests {
61 |     use super::*;
62 | 
63 |     #[test]
64 |     fn version_parsing() {
65 |         assert_eq!("1.3".parse::<Version>().unwrap(), Version::new(1, 3));
66 |     }
67 | 
68 |     #[test]
69 |     fn version_comparison() {
70 |         assert!(Version::new(1, 3) >= Version::new(1, 2));
71 |         assert!(Version::new(1, 2) >= Version::new(1, 2));
72 |         assert!(Version::new(1, 2) == Version::new(1, 2));
73 |         assert!(Version::new(1, 1) <= Version::new(1, 2));
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/notification.rs:
--------------------------------------------------------------------------------
  1 | #[cfg(all(unix, not(target_os = "macos")))]
  2 | use crate::{
  3 |     hints::{CustomHintType, Hint},
  4 |     urgency::Urgency,
  5 |     xdg,
  6 | };
  7 | 
  8 | #[cfg(all(unix, not(target_os = "macos"), feature = "images"))]
  9 | use crate::image::Image;
 10 | 
 11 | #[cfg(all(unix, target_os = "macos"))]
 12 | use crate::macos;
 13 | #[cfg(target_os = "windows")]
 14 | use crate::windows;
 15 | 
 16 | use crate::{error::*, timeout::Timeout};
 17 | 
 18 | #[cfg(all(unix, not(target_os = "macos")))]
 19 | use std::collections::{HashMap, HashSet};
 20 | 
 21 | // Returns the name of the current executable, used as a default for `Notification.appname`.
 22 | fn exe_name() -> String {
 23 |     std::env::current_exe()
 24 |         .unwrap()
 25 |         .file_name()
 26 |         .unwrap()
 27 |         .to_str()
 28 |         .unwrap()
 29 |         .to_owned()
 30 | }
 31 | 
 32 | /// Desktop notification.
 33 | ///
 34 | /// A desktop notification is configured via builder pattern, before it is launched with `show()`.
 35 | ///
 36 | /// # Example
 37 | /// ``` no_run
 38 | /// # use notify_rust::*;
 39 | /// # fn _doc() -> Result<(), Box<dyn std::error::Error>> {
 40 | ///     Notification::new()
 41 | ///         .summary("☝️ A notification")
 42 | ///         .show()?;
 43 | /// # Ok(())
 44 | /// # }
 45 | /// ```
 46 | #[derive(Debug, Clone)]
 47 | #[non_exhaustive]
 48 | pub struct Notification {
 49 |     /// Filled by default with executable name.
 50 |     pub appname: String,
 51 | 
 52 |     /// Single line to summarize the content.
 53 |     pub summary: String,
 54 | 
 55 |     /// Subtitle for macOS
 56 |     pub subtitle: Option<String>,
 57 | 
 58 |     /// Multiple lines possible, may support simple markup,
 59 |     /// check out `get_capabilities()` -> `body-markup` and `body-hyperlinks`.
 60 |     pub body: String,
 61 | 
 62 |     /// Use a file:// URI or a name in an icon theme, must be compliant freedesktop.org.
 63 |     pub icon: String,
 64 | 
 65 |     /// Check out `Hint`
 66 |     ///
 67 |     /// # warning
 68 |     /// this does not hold all hints, [`Hint::Custom`] and [`Hint::CustomInt`] are held elsewhere,
 69 |     // /// please access hints via [`Notification::get_hints`].
 70 |     #[cfg(all(unix, not(target_os = "macos")))]
 71 |     pub hints: HashSet<Hint>,
 72 | 
 73 |     #[cfg(all(unix, not(target_os = "macos")))]
 74 |     pub(crate) hints_unique: HashMap<(String, CustomHintType), Hint>,
 75 | 
 76 |     /// See `Notification::actions()` and `Notification::action()`
 77 |     pub actions: Vec<String>,
 78 | 
 79 |     #[cfg(target_os = "macos")]
 80 |     pub(crate) sound_name: Option<String>,
 81 | 
 82 |     #[cfg(target_os = "windows")]
 83 |     pub(crate) sound_name: Option<String>,
 84 | 
 85 |     #[cfg(target_os = "windows")]
 86 |     pub(crate) path_to_image: Option<String>,
 87 | 
 88 |     #[cfg(target_os = "windows")]
 89 |     pub(crate) app_id: Option<String>,
 90 | 
 91 |     #[cfg(all(unix, not(target_os = "macos")))]
 92 |     pub(crate) bus: xdg::NotificationBus,
 93 | 
 94 |     /// Lifetime of the Notification in ms. Often not respected by server, sorry.
 95 |     pub timeout: Timeout, // both gnome and galago want allow for -1
 96 | 
 97 |     /// Only to be used on the receive end. Use Notification hand for updating.
 98 |     pub(crate) id: Option<u32>,
 99 | }
100 | 
101 | impl Notification {
102 |     /// Constructs a new Notification.
103 |     ///
104 |     /// Most fields are empty by default, only `appname` is initialized with the name of the current
105 |     /// executable.
106 |     /// The appname is used by some desktop environments to group notifications.
107 |     pub fn new() -> Notification {
108 |         Notification::default()
109 |     }
110 | 
111 |     /// This is for testing purposes only and will not work with actual implementations.
112 |     #[cfg(all(unix, not(target_os = "macos")))]
113 |     #[doc(hidden)]
114 |     #[deprecated(note = "this is a test only feature")]
115 |     pub fn at_bus(sub_bus: &str) -> Notification {
116 |         let bus = xdg::NotificationBus::custom(sub_bus)
117 |             .ok_or("invalid subpath")
118 |             .unwrap();
119 |         Notification {
120 |             bus,
121 |             ..Notification::default()
122 |         }
123 |     }
124 | 
125 |     /// Overwrite the appname field used for Notification.
126 |     ///
127 |     /// # Platform Support
128 |     /// Please note that this method has no effect on macOS. Here you can only set the application via [`set_application()`](fn.set_application.html)
129 |     pub fn appname(&mut self, appname: &str) -> &mut Notification {
130 |         appname.clone_into(&mut self.appname);
131 |         self
132 |     }
133 | 
134 |     /// Set the `summary`.
135 |     ///
136 |     /// Often acts as title of the notification. For more elaborate content use the `body` field.
137 |     pub fn summary(&mut self, summary: &str) -> &mut Notification {
138 |         summary.clone_into(&mut self.summary);
139 |         self
140 |     }
141 | 
142 |     /// Set the `subtitle`.
143 |     ///
144 |     /// This is only useful on macOS, it's not part of the XDG specification and will therefore be eaten by gremlins under your CPU 😈🤘.
145 |     pub fn subtitle(&mut self, subtitle: &str) -> &mut Notification {
146 |         self.subtitle = Some(subtitle.to_owned());
147 |         self
148 |     }
149 | 
150 |     /// Manual wrapper for `Hint::ImageData`
151 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
152 |     pub fn image_data(&mut self, image: Image) -> &mut Notification {
153 |         self.hint(Hint::ImageData(image));
154 |         self
155 |     }
156 | 
157 |     /// Wrapper for `Hint::ImagePath`
158 |     #[cfg(all(unix, not(target_os = "macos")))]
159 |     pub fn image_path(&mut self, path: &str) -> &mut Notification {
160 |         self.hint(Hint::ImagePath(path.to_string()));
161 |         self
162 |     }
163 | 
164 |     /// Wrapper for `NotificationHint::ImagePath`
165 |     #[cfg(target_os = "windows")]
166 |     pub fn image_path(&mut self, path: &str) -> &mut Notification {
167 |         self.path_to_image = Some(path.to_string());
168 |         self
169 |     }
170 | 
171 |     /// app's System.AppUserModel.ID
172 |     #[cfg(target_os = "windows")]
173 |     pub fn app_id(&mut self, app_id: &str) -> &mut Notification {
174 |         self.app_id = Some(app_id.to_string());
175 |         self
176 |     }
177 | 
178 |     /// Wrapper for `Hint::ImageData`
179 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
180 |     pub fn image<T: AsRef<std::path::Path> + Sized>(
181 |         &mut self,
182 |         path: T,
183 |     ) -> Result<&mut Notification> {
184 |         let img = Image::open(&path)?;
185 |         self.hint(Hint::ImageData(img));
186 |         Ok(self)
187 |     }
188 | 
189 |     /// Wrapper for `Hint::SoundName`
190 |     #[cfg(all(unix, not(target_os = "macos")))]
191 |     pub fn sound_name(&mut self, name: &str) -> &mut Notification {
192 |         self.hint(Hint::SoundName(name.to_owned()));
193 |         self
194 |     }
195 | 
196 |     /// Set the `sound_name` for the `NSUserNotification`
197 |     #[cfg(any(target_os = "macos", target_os = "windows"))]
198 |     pub fn sound_name(&mut self, name: &str) -> &mut Notification {
199 |         self.sound_name = Some(name.to_owned());
200 |         self
201 |     }
202 | 
203 |     /// Set the content of the `body` field.
204 |     ///
205 |     /// Multiline textual content of the notification.
206 |     /// Each line should be treated as a paragraph.
207 |     /// Simple html markup should be supported, depending on the server implementation.
208 |     pub fn body(&mut self, body: &str) -> &mut Notification {
209 |         body.clone_into(&mut self.body);
210 |         self
211 |     }
212 | 
213 |     /// Set the `icon` field.
214 |     ///
215 |     /// You can use common icon names here, usually those in `/usr/share/icons`
216 |     /// can all be used.
217 |     /// You can also use an absolute path to file.
218 |     ///
219 |     /// # Platform support
220 |     /// macOS does not have support manually setting the icon. However you can pretend to be another app using [`set_application()`](fn.set_application.html)
221 |     pub fn icon(&mut self, icon: &str) -> &mut Notification {
222 |         icon.clone_into(&mut self.icon);
223 |         self
224 |     }
225 | 
226 |     /// Set the `icon` field automatically.
227 |     ///
228 |     /// This looks at your binary's name and uses it to set the icon.
229 |     ///
230 |     /// # Platform support
231 |     /// macOS does not support manually setting the icon. However you can pretend to be another app using [`set_application()`](fn.set_application.html)
232 |     pub fn auto_icon(&mut self) -> &mut Notification {
233 |         self.icon = exe_name();
234 |         self
235 |     }
236 | 
237 |     /// Adds a hint.
238 |     ///
239 |     /// This method will add a hint to the internal hint [`HashSet`].
240 |     /// Hints must be of type [`Hint`].
241 |     ///
242 |     /// Many of these are again wrapped by more convenient functions such as:
243 |     ///
244 |     /// * `sound_name(...)`
245 |     /// * `urgency(...)`
246 |     /// * [`image(...)`](#method.image) or
247 |     ///   * [`image_data(...)`](#method.image_data)
248 |     ///   * [`image_path(...)`](#method.image_path)
249 |     ///
250 |     /// ```no_run
251 |     /// # use notify_rust::Notification;
252 |     /// # use notify_rust::Hint;
253 |     /// Notification::new().summary("Category:email")
254 |     ///                    .body("This should not go away until you acknowledge it.")
255 |     ///                    .icon("thunderbird")
256 |     ///                    .appname("thunderbird")
257 |     ///                    .hint(Hint::Category("email".to_owned()))
258 |     ///                    .hint(Hint::Resident(true))
259 |     ///                    .show();
260 |     /// ```
261 |     ///
262 |     /// # Platform support
263 |     /// Most of these hints don't even have an effect on the big XDG Desktops, they are completely tossed on macOS.
264 |     #[cfg(all(unix, not(target_os = "macos")))]
265 |     pub fn hint(&mut self, hint: Hint) -> &mut Notification {
266 |         match hint {
267 |             Hint::CustomInt(k, v) => {
268 |                 self.hints_unique
269 |                     .insert((k.clone(), CustomHintType::Int), Hint::CustomInt(k, v));
270 |             }
271 |             Hint::Custom(k, v) => {
272 |                 self.hints_unique
273 |                     .insert((k.clone(), CustomHintType::String), Hint::Custom(k, v));
274 |             }
275 |             _ => {
276 |                 self.hints.insert(hint);
277 |             }
278 |         }
279 |         self
280 |     }
281 | 
282 |     #[cfg(all(unix, not(target_os = "macos")))]
283 |     pub(crate) fn get_hints(&self) -> impl Iterator<Item = &Hint> {
284 |         self.hints.iter().chain(self.hints_unique.values())
285 |     }
286 | 
287 |     /// Set the `timeout`.
288 |     ///
289 |     /// Accepts multiple types that implement `Into<Timeout>`.
290 |     ///
291 |     /// ## `i31`
292 |     ///
293 |     /// This sets the time (in milliseconds) from the time the notification is displayed until it is
294 |     /// closed again by the Notification Server.
295 |     /// According to [specification](https://developer.gnome.org/notification-spec/)
296 |     /// -1 will leave the timeout to be set by the server and
297 |     /// 0 will cause the notification never to expire.
298 |     /// ## [Duration](`std::time::Duration`)
299 |     ///
300 |     /// When passing a [`Duration`](`std::time::Duration`) we will try convert it into milliseconds.
301 |     ///
302 |     ///
303 |     /// ```
304 |     /// # use std::time::Duration;
305 |     /// # use notify_rust::Timeout;
306 |     /// assert_eq!(Timeout::from(Duration::from_millis(2000)), Timeout::Milliseconds(2000));
307 |     /// ```
308 |     /// ### Caveats!
309 |     ///
310 |     /// 1. If the duration is zero milliseconds then the original behavior will apply and the notification will **Never** timeout.
311 |     /// 2. Should the number of milliseconds not fit within an [`i32`] then we will fall back to the default timeout.
312 |     /// ```
313 |     /// # use std::time::Duration;
314 |     /// # use notify_rust::Timeout;
315 |     /// assert_eq!(Timeout::from(Duration::from_millis(0)), Timeout::Never);
316 |     /// assert_eq!(Timeout::from(Duration::from_millis(u64::MAX)), Timeout::Default);
317 |     /// ```
318 |     ///
319 |     /// # Platform support
320 |     /// This only works on XDG Desktops, macOS does not support manually setting the timeout.
321 |     pub fn timeout<T: Into<Timeout>>(&mut self, timeout: T) -> &mut Notification {
322 |         self.timeout = timeout.into();
323 |         self
324 |     }
325 | 
326 |     /// Set the `urgency`.
327 |     ///
328 |     /// Pick between Medium, Low and High.
329 |     ///
330 |     /// # Platform support
331 |     /// Most Desktops on linux and bsd are far too relaxed to pay any attention to this.
332 |     /// In macOS this does not exist
333 |     #[cfg(all(unix, not(target_os = "macos")))]
334 |     pub fn urgency(&mut self, urgency: Urgency) -> &mut Notification {
335 |         self.hint(Hint::Urgency(urgency)); // TODO impl as T where T: Into<Urgency>
336 |         self
337 |     }
338 | 
339 |     /// Set `actions`.
340 |     ///
341 |     /// To quote <http://www.galago-project.org/specs/notification/0.9/x408.html#command-notify>
342 |     ///
343 |     /// >  Actions are sent over as a list of pairs.
344 |     /// >  Each even element in the list (starting at index 0) represents the identifier for the action.
345 |     /// >  Each odd element in the list is the localized string that will be displayed to the user.y
346 |     ///
347 |     /// There is nothing fancy going on here yet.
348 |     /// **Careful! This replaces the internal list of actions!**
349 |     ///
350 |     /// (xdg only)
351 |     #[deprecated(note = "please use .action() only")]
352 |     pub fn actions(&mut self, actions: Vec<String>) -> &mut Notification {
353 |         self.actions = actions;
354 |         self
355 |     }
356 | 
357 |     /// Add an action.
358 |     ///
359 |     /// This adds a single action to the internal list of actions.
360 |     ///
361 |     /// (xdg only)
362 |     pub fn action(&mut self, identifier: &str, label: &str) -> &mut Notification {
363 |         self.actions.push(identifier.to_owned());
364 |         self.actions.push(label.to_owned());
365 |         self
366 |     }
367 | 
368 |     /// Set an Id ahead of time
369 |     ///
370 |     /// Setting the id ahead of time allows overriding a known other notification.
371 |     /// Though if you want to update a notification, it is easier to use the `update()` method of
372 |     /// the `NotificationHandle` object that `show()` returns.
373 |     ///
374 |     /// (xdg only)
375 |     pub fn id(&mut self, id: u32) -> &mut Notification {
376 |         self.id = Some(id);
377 |         self
378 |     }
379 | 
380 |     /// Finalizes a Notification.
381 |     ///
382 |     /// Part of the builder pattern, returns a complete copy of the built notification.
383 |     pub fn finalize(&self) -> Notification {
384 |         self.clone()
385 |     }
386 | 
387 |     /// Schedules a Notification
388 |     ///
389 |     /// Sends a Notification at the specified date.
390 |     #[cfg(all(target_os = "macos", feature = "chrono"))]
391 |     pub fn schedule<T: chrono::TimeZone>(
392 |         &self,
393 |         delivery_date: chrono::DateTime<T>,
394 |     ) -> Result<macos::NotificationHandle> {
395 |         macos::schedule_notification(self, delivery_date.timestamp() as f64)
396 |     }
397 | 
398 |     /// Schedules a Notification
399 |     ///
400 |     /// Sends a Notification at the specified timestamp.
401 |     /// This is a raw `f64`, if that is a bit too raw for you please activate the feature `"chrono"`,
402 |     /// then you can use `Notification::schedule()` instead, which accepts a `chrono::DateTime<T>`.
403 |     #[cfg(target_os = "macos")]
404 |     pub fn schedule_raw(&self, timestamp: f64) -> Result<macos::NotificationHandle> {
405 |         macos::schedule_notification(self, timestamp)
406 |     }
407 | 
408 |     /// Sends Notification to D-Bus.
409 |     ///
410 |     /// Returns a handle to a notification
411 |     #[cfg(all(unix, not(target_os = "macos")))]
412 |     pub fn show(&self) -> Result<xdg::NotificationHandle> {
413 |         xdg::show_notification(self)
414 |     }
415 | 
416 |     /// Sends Notification to D-Bus.
417 |     ///
418 |     /// Returns a handle to a notification
419 |     #[cfg(all(unix, not(target_os = "macos")))]
420 |     #[cfg(all(feature = "async", feature = "zbus"))]
421 |     pub async fn show_async(&self) -> Result<xdg::NotificationHandle> {
422 |         xdg::show_notification_async(self).await
423 |     }
424 | 
425 |     /// Sends Notification to D-Bus.
426 |     ///
427 |     /// Returns a handle to a notification
428 |     #[cfg(all(unix, not(target_os = "macos")))]
429 |     #[cfg(feature = "async")]
430 |     // #[cfg(test)]
431 |     pub async fn show_async_at_bus(&self, sub_bus: &str) -> Result<xdg::NotificationHandle> {
432 |         let bus = xdg::NotificationBus::custom(sub_bus).ok_or("invalid subpath")?;
433 |         xdg::show_notification_async_at_bus(self, bus).await
434 |     }
435 | 
436 |     /// Sends Notification to `NSUserNotificationCenter`.
437 |     ///
438 |     /// Returns an `Ok` no matter what, since there is currently no way of telling the success of
439 |     /// the notification.
440 |     #[cfg(target_os = "macos")]
441 |     pub fn show(&self) -> Result<macos::NotificationHandle> {
442 |         macos::show_notification(self)
443 |     }
444 | 
445 |     /// Sends Notification to `NSUserNotificationCenter`.
446 |     ///
447 |     /// Returns an `Ok` no matter what, since there is currently no way of telling the success of
448 |     /// the notification.
449 |     #[cfg(target_os = "windows")]
450 |     pub fn show(&self) -> Result<()> {
451 |         windows::show_notification(self)
452 |     }
453 | 
454 |     /// Wraps [`Notification::show()`] but prints notification to stdout.
455 |     #[cfg(all(unix, not(target_os = "macos")))]
456 |     #[deprecated = "this was never meant to be public API"]
457 |     pub fn show_debug(&mut self) -> Result<xdg::NotificationHandle> {
458 |         println!(
459 |             "Notification:\n{appname}: ({icon}) {summary:?} {body:?}\nhints: [{hints:?}]\n",
460 |             appname = self.appname,
461 |             summary = self.summary,
462 |             body = self.body,
463 |             hints = self.hints,
464 |             icon = self.icon,
465 |         );
466 |         self.show()
467 |     }
468 | }
469 | 
470 | impl Default for Notification {
471 |     #[cfg(all(unix, not(target_os = "macos")))]
472 |     fn default() -> Notification {
473 |         Notification {
474 |             appname: exe_name(),
475 |             summary: String::new(),
476 |             subtitle: None,
477 |             body: String::new(),
478 |             icon: String::new(),
479 |             hints: HashSet::new(),
480 |             hints_unique: HashMap::new(),
481 |             actions: Vec::new(),
482 |             timeout: Timeout::Default,
483 |             bus: Default::default(),
484 |             id: None,
485 |         }
486 |     }
487 | 
488 |     #[cfg(target_os = "macos")]
489 |     fn default() -> Notification {
490 |         Notification {
491 |             appname: exe_name(),
492 |             summary: String::new(),
493 |             subtitle: None,
494 |             body: String::new(),
495 |             icon: String::new(),
496 |             actions: Vec::new(),
497 |             timeout: Timeout::Default,
498 |             sound_name: Default::default(),
499 |             id: None,
500 |         }
501 |     }
502 | 
503 |     #[cfg(target_os = "windows")]
504 |     fn default() -> Notification {
505 |         Notification {
506 |             appname: exe_name(),
507 |             summary: String::new(),
508 |             subtitle: None,
509 |             body: String::new(),
510 |             icon: String::new(),
511 |             actions: Vec::new(),
512 |             timeout: Timeout::Default,
513 |             sound_name: Default::default(),
514 |             id: None,
515 |             path_to_image: None,
516 |             app_id: None,
517 |         }
518 |     }
519 | }
520 | 


--------------------------------------------------------------------------------
/src/server.rs:
--------------------------------------------------------------------------------
  1 | //! **Experimental** server taking the place of your Desktop Environment's Notification Server.
  2 | //!
  3 | //! This is not nearly meant for anything but testing, as it only prints notifications to stdout.
  4 | //! It does not respond properly either yet.
  5 | //!
  6 | //! This server will not replace an already running notification server.
  7 | //!
  8 | 
  9 | #![allow(unused_imports, unused_variables, dead_code)]
 10 | 
 11 | use std::cell::Cell;
 12 | use std::collections::{HashMap, HashSet};
 13 | use std::sync::{Arc, Mutex};
 14 | 
 15 | #[cfg(feature = "dbus")]
 16 | use dbus::{
 17 |     arg::{self, RefArg},
 18 |     ffidisp::{BusType, Connection, NameFlag},
 19 |     tree::{self, Factory, Interface, MTFn, MTSync, Tree},
 20 |     Path,
 21 | };
 22 | 
 23 | use super::{Hint, Notification, Timeout};
 24 | use crate::xdg::{NOTIFICATION_NAMESPACE, NOTIFICATION_OBJECTPATH};
 25 | 
 26 | static DBUS_ERROR_FAILED: &str = "org.freedesktop.DBus.Error.Failed";
 27 | /// Version of the crate equals the version server.
 28 | pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 29 | 
 30 | /// An **experimental** notification server.
 31 | /// See [the module level documentation](index.html) for more.
 32 | #[derive(Debug, Default)]
 33 | pub struct NotificationServer {
 34 |     /// Counter for generating notification ids
 35 |     counter: Mutex<Cell<u32>>,
 36 | 
 37 |     /// A flag that stops the server
 38 |     stopped: Mutex<Cell<bool>>,
 39 | }
 40 | 
 41 | impl NotificationServer {
 42 |     fn count_up(&self) {
 43 |         if let Ok(counter) = self.counter.lock() {
 44 |             counter.set(counter.get() + 1);
 45 |         }
 46 |     }
 47 | 
 48 |     fn stop(&self) {
 49 |         if let Ok(stop) = self.stopped.lock() {
 50 |             stop.set(true);
 51 |         }
 52 |     }
 53 | 
 54 |     fn is_stopped(&self) -> bool {
 55 |         if let Ok(stop) = self.stopped.lock() {
 56 |             stop.get()
 57 |         } else {
 58 |             true
 59 |         }
 60 |     }
 61 | 
 62 |     /// Create a new `NotificationServer` instance.
 63 |     pub fn create() -> Arc<NotificationServer> {
 64 |         Arc::new(NotificationServer::default())
 65 |     }
 66 |     // pub fn notify_mothod<F>(&mut self, closure: F)
 67 |     //    -> Method
 68 |     //    where F: Fn(&Notification)
 69 |     // {
 70 | 
 71 |     // fn handle_notification
 72 | 
 73 |     /// Start listening for incoming notifications
 74 |     pub fn start<F: 'static>(me: &Arc<Self>, closure: F)
 75 |     where
 76 |         F: Fn(&Notification),
 77 |     {
 78 |         let connection = Connection::get_private(BusType::Session).unwrap();
 79 | 
 80 |         connection.release_name(NOTIFICATION_NAMESPACE).unwrap();
 81 |         connection
 82 |             .register_name(NOTIFICATION_NAMESPACE, NameFlag::ReplaceExisting as u32)
 83 |             .unwrap();
 84 |         connection
 85 |             .register_object_path(NOTIFICATION_OBJECTPATH)
 86 |             .unwrap();
 87 | 
 88 |         let mytex = Arc::new(Mutex::new(me.clone()));
 89 | 
 90 |         let factory = Factory::new_fn::<()>(); // D::Tree = ()
 91 |         let tree = factory.tree(()).add(
 92 |             factory
 93 |                 .object_path(NOTIFICATION_OBJECTPATH, ())
 94 |                 .introspectable()
 95 |                 .add(
 96 |                     factory
 97 |                         .interface(NOTIFICATION_NAMESPACE, ())
 98 |                         .add_m(method_notify(&factory, closure))
 99 |                         .add_m(method_close_notification(&factory))
100 |                         .add_m(Self::stop_server(mytex.clone(), &factory))
101 |                         // .add_signal(method_notification_closed(&factory))
102 |                         // .add_signal(method_action_invoked(&factory))
103 |                         .add_m(method_get_capabilities(&factory))
104 |                         .add_m(method_get_server_information(&factory)),
105 |                 ),
106 |         );
107 | 
108 |         connection.add_handler(tree);
109 | 
110 |         while !me.is_stopped() {
111 |             // Wait for incoming messages. This will block up to one second.
112 |             // Discard the result - relevant messages have already been handled.
113 |             if let Some(received) = connection.incoming(1000).next() {
114 |                 println!("RECEIVED {:?}", received);
115 |             }
116 |         }
117 |     }
118 | 
119 |     fn stop_server(
120 |         me: Arc<Mutex<Arc<Self>>>,
121 |         factory: &Factory<MTFn>,
122 |     ) -> tree::Method<MTFn<()>, ()> {
123 |         factory
124 |             .method("Stop", (), move |minfo| {
125 |                 if let Ok(me) = me.lock() {
126 |                     me.stop();
127 |                     println!("STOPPING");
128 |                     Ok(vec![])
129 |                 } else {
130 |                     Err(tree::MethodErr::failed(&String::from("nope!")))
131 |                 }
132 |             })
133 |             .out_arg(("", "u"))
134 |     }
135 | }
136 | 
137 | fn hints_from_variants<A: RefArg>(hints: &HashMap<String, A>) -> HashSet<Hint> {
138 |     hints.iter().map(Into::into).collect()
139 | }
140 | 
141 | fn method_notify<F: 'static>(
142 |     factory: &Factory<MTFn>,
143 |     on_notification: F,
144 | ) -> tree::Method<MTFn<()>, ()>
145 | where
146 |     F: Fn(&Notification),
147 | {
148 |     factory
149 |         .method("Notify", (), move |minfo| {
150 |             let mut i = minfo.msg.iter_init();
151 |             let appname: String = i.read()?;
152 |             let replaces_id: u32 = i.read()?;
153 |             let icon: String = i.read()?;
154 |             let summary: String = i.read()?;
155 |             let body: String = i.read()?;
156 |             let actions: Vec<String> = i.read()?;
157 |             let hints: ::std::collections::HashMap<String, arg::Variant<Box<dyn RefArg>>> =
158 |                 i.read()?;
159 |             let timeout: i32 = i.read()?;
160 |             println!("hints {:?} ", hints);
161 | 
162 |             // let arg0 = try!(d.notify(app_name, replaces_id, app_icon, summary, body, actions, hints, timeout));
163 |             let notification = Notification {
164 |                 appname,
165 |                 icon,
166 |                 summary,
167 |                 body,
168 |                 actions,
169 |                 hints: hints_from_variants(&hints),
170 |                 timeout: Timeout::from(timeout),
171 |                 id: if replaces_id == 0 {
172 |                     None
173 |                 } else {
174 |                     Some(replaces_id)
175 |                 },
176 |                 subtitle: None,
177 |             };
178 | 
179 |             on_notification(&notification);
180 | 
181 |             let arg0 = 43;
182 |             let rm = minfo.msg.method_return();
183 |             let rm = rm.append1(arg0);
184 |             Ok(vec![rm])
185 |         })
186 |         .in_arg(("app_name", "s"))
187 |         .in_arg(("replaces_id", "u"))
188 |         .in_arg(("app_icon", "s"))
189 |         .in_arg(("summary", "s"))
190 |         .in_arg(("body", "s"))
191 |         .in_arg(("actions", "as"))
192 |         .in_arg(("hints", "a{sv}"))
193 |         .in_arg(("timeout", "i"))
194 |         .out_arg(("", "u"))
195 | }
196 | 
197 | fn method_close_notification(factory: &Factory<MTFn>) -> tree::Method<MTFn<()>, ()> {
198 |     factory
199 |         .method("CloseNotification", (), |minfo| {
200 |             let i = minfo.msg.iter_init();
201 |             let rm = minfo.msg.method_return();
202 |             Ok(vec![rm])
203 |         })
204 |         .in_arg(("id", "u"))
205 | }
206 | 
207 | fn method_get_capabilities(factory: &Factory<MTFn>) -> tree::Method<MTFn<()>, ()> {
208 |     factory
209 |         .method("GetCapabilities", (), |minfo| {
210 |             let caps: Vec<String> = vec![];
211 |             let rm = minfo.msg.method_return();
212 |             let rm = rm.append1(caps);
213 |             Ok(vec![rm])
214 |         })
215 |         .out_arg(("caps", "as"))
216 | }
217 | 
218 | fn method_get_server_information(factory: &Factory<MTFn>) -> tree::Method<MTFn<()>, ()> {
219 |     factory
220 |         .method("GetServerInformation", (), |minfo| {
221 |             let (name, vendor, version, spec_version) = (
222 |                 "notify-rust",
223 |                 "notify-rust",
224 |                 env!("CARGO_PKG_VERSION"),
225 |                 "0.0.0",
226 |             );
227 |             let rm = minfo.msg.method_return();
228 |             let rm = rm.append1(name);
229 |             let rm = rm.append1(vendor);
230 |             let rm = rm.append1(version);
231 |             let rm = rm.append1(spec_version);
232 |             Ok(vec![rm])
233 |         })
234 |         .out_arg(("name", "s"))
235 |         .out_arg(("vendor", "s"))
236 |         .out_arg(("version", "s"))
237 |         .out_arg(("spec_version", "s"))
238 | }
239 | 


--------------------------------------------------------------------------------
/src/timeout.rs:
--------------------------------------------------------------------------------
  1 | use std::{num::ParseIntError, str::FromStr, time::Duration};
  2 | 
  3 | /// Describes the timeout of a notification
  4 | ///
  5 | /// # `FromStr`
  6 | /// You can also parse a `Timeout` from a `&str`.
  7 | /// ```
  8 | /// # use notify_rust::Timeout;
  9 | /// assert_eq!("default".parse(), Ok(Timeout::Default));
 10 | /// assert_eq!("never".parse(), Ok(Timeout::Never));
 11 | /// assert_eq!("42".parse(), Ok(Timeout::Milliseconds(42)));
 12 | /// ```
 13 | #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
 14 | pub enum Timeout {
 15 |     /// Expires according to server default.
 16 |     ///
 17 |     /// Whatever that might be...
 18 |     #[default]
 19 |     Default,
 20 | 
 21 |     /// Do not expire, user will have to close this manually.
 22 |     Never,
 23 | 
 24 |     /// Expire after n milliseconds.
 25 |     Milliseconds(u32),
 26 | }
 27 | 
 28 | #[test]
 29 | fn timeout_from_i32() {
 30 |     assert_eq!(Timeout::from(234), Timeout::Milliseconds(234));
 31 |     assert_eq!(Timeout::from(-234), Timeout::Default);
 32 |     assert_eq!(Timeout::from(0), Timeout::Never);
 33 | }
 34 | 
 35 | impl From<i32> for Timeout {
 36 |     fn from(int: i32) -> Timeout {
 37 |         use std::cmp::Ordering::*;
 38 |         match int.cmp(&0) {
 39 |             Greater => Timeout::Milliseconds(int as u32),
 40 |             Less => Timeout::Default,
 41 |             Equal => Timeout::Never,
 42 |         }
 43 |     }
 44 | }
 45 | 
 46 | impl From<Duration> for Timeout {
 47 |     fn from(duration: Duration) -> Timeout {
 48 |         if duration.is_zero() {
 49 |             Timeout::Never
 50 |         } else if duration.as_millis() > u32::MAX as u128 {
 51 |             Timeout::Default
 52 |         } else {
 53 |             Timeout::Milliseconds(duration.as_millis().try_into().unwrap_or(u32::MAX))
 54 |         }
 55 |     }
 56 | }
 57 | 
 58 | impl From<Timeout> for i32 {
 59 |     fn from(timeout: Timeout) -> Self {
 60 |         match timeout {
 61 |             Timeout::Default => -1,
 62 |             Timeout::Never => 0,
 63 |             Timeout::Milliseconds(ms) => ms as i32,
 64 |         }
 65 |     }
 66 | }
 67 | 
 68 | impl FromStr for Timeout {
 69 |     type Err = ParseIntError;
 70 | 
 71 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
 72 |         match s {
 73 |             "default" => Ok(Timeout::Default),
 74 |             "never" => Ok(Timeout::Never),
 75 |             milliseconds => Ok(Timeout::Milliseconds(u32::from_str(milliseconds)?)),
 76 |         }
 77 |     }
 78 | }
 79 | 
 80 | pub struct TimeoutMessage(Timeout);
 81 | 
 82 | impl From<Timeout> for TimeoutMessage {
 83 |     fn from(hint: Timeout) -> Self {
 84 |         TimeoutMessage(hint)
 85 |     }
 86 | }
 87 | 
 88 | impl std::ops::Deref for TimeoutMessage {
 89 |     type Target = Timeout;
 90 | 
 91 |     fn deref(&self) -> &Self::Target {
 92 |         &self.0
 93 |     }
 94 | }
 95 | 
 96 | #[cfg(all(feature = "dbus", unix, not(target_os = "macos")))]
 97 | impl TryFrom<&dbus::arg::messageitem::MessageItem> for TimeoutMessage {
 98 |     type Error = ();
 99 | 
100 |     fn try_from(mi: &dbus::arg::messageitem::MessageItem) -> Result<TimeoutMessage, ()> {
101 |         mi.inner::<i32>().map(|i| TimeoutMessage(i.into()))
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/urgency.rs:
--------------------------------------------------------------------------------
 1 | use crate::error::ErrorKind;
 2 | 
 3 | /// Levels of Urgency.
 4 | ///
 5 | /// # Specification
 6 | /// > Developers must use their own judgement when deciding the urgency of a notification. Typically, if the majority of programs are using the same level for a specific type of urgency, other applications should follow them.
 7 | /// >
 8 | /// > For low and normal urgencies, server implementations may display the notifications how they choose. They should, however, have a sane expiration timeout dependent on the urgency level.
 9 | /// >
10 | /// > **Critical notifications should not automatically expire**, as they are things that the user will most likely want to know about. They should only be closed when the user dismisses them, for example, by clicking on the notification.
11 | ///
12 | /// <cite> — see [Galago](http://www.galago-project.org/specs/notification/0.9/x320.html) or [Gnome](https://developer.gnome.org/notification-spec/#urgency-levels) specification.</cite>
13 | ///
14 | /// # Example
15 | /// ```no_run
16 | /// # use notify_rust::*;
17 | /// # fn _doc() -> Result<(), Box<dyn std::error::Error>> {
18 | /// Notification::new()
19 | ///     .summary("oh no")
20 | ///     .icon("dialog-warning")
21 | ///     .urgency(Urgency::Critical)
22 | ///     .show()?;
23 | /// # Ok(())
24 | /// # }
25 | /// ```
26 | ///
27 | #[derive(Eq, PartialEq, Hash, Copy, Clone, Debug)]
28 | pub enum Urgency {
29 |     /// The behavior for `Low` urgency depends on the notification server.
30 |     Low = 0,
31 |     /// The behavior for `Normal` urgency depends on the notification server.
32 |     Normal = 1,
33 |     /// A critical notification will not time out.
34 |     Critical = 2,
35 | }
36 | 
37 | impl TryFrom<&str> for Urgency {
38 |     type Error = crate::error::Error;
39 | 
40 |     #[rustfmt::skip]
41 |     fn try_from(string: &str) -> Result<Urgency, Self::Error> {
42 |         match string.to_lowercase().as_ref() {
43 |             "low"      |
44 |             "lo"       => Ok(Urgency::Low),
45 |             "normal"   |
46 |             "medium"   => Ok(Urgency::Normal),
47 |             "critical" |
48 |             "high"     |
49 |             "hi"       => Ok(Urgency::Critical),
50 |             _ => Err(ErrorKind::Conversion(format!("invalid input {string:?}")).into())
51 |         }
52 |     }
53 | }
54 | 
55 | impl From<Option<u64>> for Urgency {
56 |     fn from(maybe_int: Option<u64>) -> Urgency {
57 |         match maybe_int {
58 |             Some(0) => Urgency::Low,
59 |             Some(x) if x >= 2 => Urgency::Critical,
60 |             _ => Urgency::Normal,
61 |         }
62 |     }
63 | }
64 | 
65 | // TODO: remove this in v5.0
66 | // #[cfg(not(feature = "server"))]
67 | impl From<u64> for Urgency {
68 |     fn from(int: u64) -> Urgency {
69 |         match int {
70 |             0 => Urgency::Low,
71 |             1 => Urgency::Normal,
72 |             2..=u64::MAX => Urgency::Critical,
73 |         }
74 |     }
75 | }
76 | 
77 | // // TODO: make this the default in v5.0
78 | // #[cfg(feature = "server")]
79 | // impl From<u8> for Urgency {
80 | //     fn from(int: u8) -> Urgency {
81 | //         match int {
82 | //             0 => Urgency::Low,
83 | //             1 => Urgency::Normal,
84 | //             2..=std::u8::MAX => Urgency::Critical,
85 | //         }
86 | //     }
87 | // }
88 | 


--------------------------------------------------------------------------------
/src/windows.rs:
--------------------------------------------------------------------------------
 1 | use winrt_notification::Toast;
 2 | 
 3 | pub use crate::{error::*, notification::Notification, timeout::Timeout};
 4 | 
 5 | use std::{path::Path, str::FromStr};
 6 | 
 7 | pub(crate) fn show_notification(notification: &Notification) -> Result<()> {
 8 |     let sound = match &notification.sound_name {
 9 |         Some(chosen_sound_name) => winrt_notification::Sound::from_str(chosen_sound_name).ok(),
10 |         None => None,
11 |     };
12 | 
13 |     let duration = match notification.timeout {
14 |         Timeout::Default => winrt_notification::Duration::Short,
15 |         Timeout::Never => winrt_notification::Duration::Long,
16 |         Timeout::Milliseconds(t) => {
17 |             if t >= 25000 {
18 |                 winrt_notification::Duration::Long
19 |             } else {
20 |                 winrt_notification::Duration::Short
21 |             }
22 |         }
23 |     };
24 | 
25 |     let powershell_app_id = &Toast::POWERSHELL_APP_ID.to_string();
26 |     let app_id = &notification.app_id.as_ref().unwrap_or(powershell_app_id);
27 |     let mut toast = Toast::new(app_id)
28 |         .title(&notification.summary)
29 |         .text1(notification.subtitle.as_ref().map_or("", AsRef::as_ref)) // subtitle
30 |         .text2(&notification.body)
31 |         .sound(sound)
32 |         .duration(duration);
33 |     if let Some(image_path) = &notification.path_to_image {
34 |         toast = toast.image(Path::new(&image_path), "");
35 |     }
36 | 
37 |     toast
38 |         .show()
39 |         .map_err(|error| Error::from(ErrorKind::Msg(format!("{error:?}"))))
40 | }
41 | 


--------------------------------------------------------------------------------
/src/xdg/bus.rs:
--------------------------------------------------------------------------------
 1 | use crate::xdg::NOTIFICATION_DEFAULT_BUS;
 2 | 
 3 | fn skip_first_slash(s: &str) -> &str {
 4 |     if let Some('/') = s.chars().next() {
 5 |         &s[1..]
 6 |     } else {
 7 |         s
 8 |     }
 9 | }
10 | 
11 | use std::path::PathBuf;
12 | 
13 | type BusNameType = std::borrow::Cow<'static, str>;
14 | 
15 | #[derive(Clone, Debug)]
16 | pub struct NotificationBus(BusNameType);
17 | 
18 | impl Default for NotificationBus {
19 |     #[cfg(feature = "zbus")]
20 |     fn default() -> Self {
21 |         Self(
22 |             zbus::names::WellKnownName::from_static_str(NOTIFICATION_DEFAULT_BUS)
23 |                 .unwrap()
24 |                 .to_string()
25 |                 .into(),
26 |         )
27 |     }
28 | 
29 |     #[cfg(all(feature = "dbus", not(feature = "zbus")))]
30 |     fn default() -> Self {
31 |         Self(
32 |             dbus::strings::BusName::from_slice(NOTIFICATION_DEFAULT_BUS)
33 |                 .unwrap()
34 |                 .to_string()
35 |                 .into(),
36 |         )
37 |     }
38 | }
39 | 
40 | impl NotificationBus {
41 |     fn namespaced_custom(custom_path: &str) -> Option<String> {
42 |         // abusing path for semantic join
43 |         skip_first_slash(
44 |             PathBuf::from("/de/hoodie/Notification")
45 |                 .join(custom_path)
46 |                 .to_str()?,
47 |         )
48 |         .replace('/', ".")
49 |         .into()
50 |     }
51 | 
52 |     #[cfg(feature = "zbus")]
53 |     pub fn custom(custom_path: &str) -> Option<Self> {
54 |         let name =
55 |             zbus::names::WellKnownName::try_from(Self::namespaced_custom(custom_path)?).ok()?;
56 |         Some(Self(name.to_string().into()))
57 |     }
58 | 
59 |     #[cfg(all(feature = "dbus", not(feature = "zbus")))]
60 |     pub fn custom(custom_path: &str) -> Option<Self> {
61 |         let name = dbus::strings::BusName::new(Self::namespaced_custom(custom_path)?).ok()?;
62 |         Some(Self(name.to_string().into()))
63 |     }
64 | 
65 |     pub fn into_name(self) -> BusNameType {
66 |         self.0
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/xdg/dbus_rs.rs:
--------------------------------------------------------------------------------
  1 | use dbus::{
  2 |     arg::messageitem::{MessageItem, MessageItemArray},
  3 |     ffidisp::{BusType, Connection, ConnectionItem},
  4 |     Message,
  5 | };
  6 | 
  7 | use super::{
  8 |     bus::NotificationBus, ActionResponse, ActionResponseHandler, CloseReason,
  9 |     NOTIFICATION_INTERFACE,
 10 | };
 11 | 
 12 | use crate::{
 13 |     error::*,
 14 |     hints::message::HintMessage,
 15 |     notification::Notification,
 16 |     xdg::{ServerInformation, NOTIFICATION_OBJECTPATH},
 17 | };
 18 | 
 19 | pub mod bus {
 20 | 
 21 |     use crate::xdg::NOTIFICATION_DEFAULT_BUS;
 22 | 
 23 |     fn skip_first_slash(s: &str) -> &str {
 24 |         if let Some('/') = s.chars().next() {
 25 |             &s[1..]
 26 |         } else {
 27 |             s
 28 |         }
 29 |     }
 30 | 
 31 |     use std::path::PathBuf;
 32 | 
 33 |     type BusNameType = dbus::strings::BusName<'static>;
 34 | 
 35 |     #[derive(Clone, Debug)]
 36 |     pub struct NotificationBus(BusNameType);
 37 | 
 38 |     impl Default for NotificationBus {
 39 |         fn default() -> Self {
 40 |             Self(dbus::strings::BusName::from_slice(NOTIFICATION_DEFAULT_BUS).unwrap())
 41 |         }
 42 |     }
 43 | 
 44 |     impl NotificationBus {
 45 |         fn namespaced_custom(custom_path: &str) -> Option<String> {
 46 |             // abusing path for semantic join
 47 |             skip_first_slash(
 48 |                 PathBuf::from("/de/hoodie/Notification")
 49 |                     .join(custom_path)
 50 |                     .to_str()?,
 51 |             )
 52 |             .replace('/', ".")
 53 |             .into()
 54 |         }
 55 | 
 56 |         pub fn custom(custom_path: &str) -> Option<Self> {
 57 |             let name = dbus::strings::BusName::new(Self::namespaced_custom(custom_path)?).ok()?;
 58 |             Some(Self(name))
 59 |         }
 60 | 
 61 |         pub fn into_name(self) -> BusNameType {
 62 |             self.0
 63 |         }
 64 |     }
 65 | }
 66 | 
 67 | /// A handle to a shown notification.
 68 | ///
 69 | /// This keeps a connection alive to ensure actions work on certain desktops.
 70 | #[derive(Debug)]
 71 | pub struct DbusNotificationHandle {
 72 |     pub(crate) id: u32,
 73 |     pub(crate) connection: Connection,
 74 |     pub(crate) notification: Notification,
 75 | }
 76 | 
 77 | impl DbusNotificationHandle {
 78 |     pub(crate) fn new(
 79 |         id: u32,
 80 |         connection: Connection,
 81 |         notification: Notification,
 82 |     ) -> DbusNotificationHandle {
 83 |         DbusNotificationHandle {
 84 |             id,
 85 |             connection,
 86 |             notification,
 87 |         }
 88 |     }
 89 | 
 90 |     pub fn wait_for_action(self, invocation_closure: impl ActionResponseHandler) {
 91 |         wait_for_action_signal(&self.connection, self.id, invocation_closure);
 92 |     }
 93 | 
 94 |     pub fn close(self) {
 95 |         let mut message = build_message("CloseNotification", Default::default());
 96 |         message.append_items(&[self.id.into()]);
 97 |         let _ = self.connection.send(message); // If closing fails there's nothing we could do anyway
 98 |     }
 99 | 
100 |     pub fn on_close<F>(self, closure: F)
101 |     where
102 |         F: FnOnce(CloseReason),
103 |     {
104 |         self.wait_for_action(|action: &ActionResponse| {
105 |             if let ActionResponse::Closed(reason) = action {
106 |                 closure(*reason);
107 |             }
108 |         });
109 |     }
110 | 
111 |     pub fn update(&mut self) {
112 |         self.id = send_notification_via_connection(&self.notification, self.id, &self.connection)
113 |             .unwrap();
114 |     }
115 | }
116 | 
117 | pub fn send_notification_via_connection(
118 |     notification: &Notification,
119 |     id: u32,
120 |     connection: &Connection,
121 | ) -> Result<u32> {
122 |     send_notification_via_connection_at_bus(notification, id, connection, Default::default())
123 | }
124 | 
125 | pub fn send_notification_via_connection_at_bus(
126 |     notification: &Notification,
127 |     id: u32,
128 |     connection: &Connection,
129 |     bus: NotificationBus,
130 | ) -> Result<u32> {
131 |     let mut message = build_message("Notify", bus);
132 |     let timeout: i32 = notification.timeout.into();
133 |     message.append_items(&[
134 |         notification.appname.to_owned().into(), // appname
135 |         id.into(),                              // notification to update
136 |         notification.icon.to_owned().into(),    // icon
137 |         notification.summary.to_owned().into(), // summary (title)
138 |         notification.body.to_owned().into(),    // body
139 |         pack_actions(notification),             // actions
140 |         pack_hints(notification)?,              // hints
141 |         timeout.into(),                         // timeout
142 |     ]);
143 | 
144 |     let reply = connection.send_with_reply_and_block(message, 2000)?;
145 | 
146 |     match reply.get_items().first() {
147 |         Some(MessageItem::UInt32(ref id)) => Ok(*id),
148 |         _ => Ok(0),
149 |     }
150 | }
151 | 
152 | pub fn connect_and_send_notification(
153 |     notification: &Notification,
154 | ) -> Result<DbusNotificationHandle> {
155 |     let bus = notification.bus.clone();
156 |     connect_and_send_notification_at_bus(notification, bus)
157 | }
158 | 
159 | pub fn connect_and_send_notification_at_bus(
160 |     notification: &Notification,
161 |     bus: NotificationBus,
162 | ) -> Result<DbusNotificationHandle> {
163 |     let connection = Connection::get_private(BusType::Session)?;
164 |     let inner_id = notification.id.unwrap_or(0);
165 |     let id = send_notification_via_connection_at_bus(notification, inner_id, &connection, bus)?;
166 | 
167 |     Ok(DbusNotificationHandle::new(
168 |         id,
169 |         connection,
170 |         notification.clone(),
171 |     ))
172 | }
173 | 
174 | fn build_message(method_name: &str, bus: NotificationBus) -> Message {
175 |     Message::new_method_call(
176 |         bus.into_name(),
177 |         NOTIFICATION_OBJECTPATH,
178 |         NOTIFICATION_INTERFACE,
179 |         method_name,
180 |     )
181 |     .unwrap_or_else(|_| panic!("Error building message call {:?}.", method_name))
182 | }
183 | 
184 | pub fn pack_hints(notification: &Notification) -> Result<MessageItem> {
185 |     if !notification.hints.is_empty() || !notification.hints_unique.is_empty() {
186 |         let hints = notification
187 |             .get_hints()
188 |             .cloned()
189 |             .map(HintMessage::wrap_hint)
190 |             .collect::<Vec<(MessageItem, MessageItem)>>();
191 | 
192 |         if let Ok(array) = MessageItem::new_dict(hints) {
193 |             return Ok(array);
194 |         }
195 |     }
196 | 
197 |     Ok(MessageItem::Array(
198 |         MessageItemArray::new(vec![], "a{sv}".into()).unwrap(),
199 |     ))
200 | }
201 | 
202 | pub fn pack_actions(notification: &Notification) -> MessageItem {
203 |     if !notification.actions.is_empty() {
204 |         let mut actions = vec![];
205 |         for action in &notification.actions {
206 |             actions.push(action.to_owned().into());
207 |         }
208 |         if let Ok(array) = MessageItem::new_array(actions) {
209 |             return array;
210 |         }
211 |     }
212 | 
213 |     MessageItem::Array(MessageItemArray::new(vec![], "as".into()).unwrap())
214 | }
215 | 
216 | pub fn get_capabilities() -> Result<Vec<String>> {
217 |     let mut capabilities = vec![];
218 | 
219 |     let message = build_message("GetCapabilities", Default::default());
220 |     let connection = Connection::get_private(BusType::Session)?;
221 |     let reply = connection.send_with_reply_and_block(message, 2000)?;
222 | 
223 |     if let Some(MessageItem::Array(items)) = reply.get_items().first() {
224 |         for item in items.iter() {
225 |             if let MessageItem::Str(ref cap) = *item {
226 |                 capabilities.push(cap.clone());
227 |             }
228 |         }
229 |     }
230 | 
231 |     Ok(capabilities)
232 | }
233 | 
234 | fn unwrap_message_string(item: Option<&MessageItem>) -> String {
235 |     match item {
236 |         Some(MessageItem::Str(value)) => value.to_owned(),
237 |         _ => "".to_owned(),
238 |     }
239 | }
240 | 
241 | #[allow(clippy::get_first)]
242 | pub fn get_server_information() -> Result<ServerInformation> {
243 |     let message = build_message("GetServerInformation", Default::default());
244 |     let connection = Connection::get_private(BusType::Session)?;
245 |     let reply = connection.send_with_reply_and_block(message, 2000)?;
246 | 
247 |     let items = reply.get_items();
248 | 
249 |     Ok(ServerInformation {
250 |         name: unwrap_message_string(items.get(0)),
251 |         vendor: unwrap_message_string(items.get(1)),
252 |         version: unwrap_message_string(items.get(2)),
253 |         spec_version: unwrap_message_string(items.get(3)),
254 |     })
255 | }
256 | 
257 | /// Listens for the `ActionInvoked(UInt32, String)` Signal.
258 | ///
259 | /// No need to use this, check out `Notification::show_and_wait_for_action(FnOnce(action:&str))`
260 | pub fn handle_action(id: u32, func: impl ActionResponseHandler) {
261 |     let connection = Connection::get_private(BusType::Session).unwrap();
262 |     wait_for_action_signal(&connection, id, func);
263 | }
264 | 
265 | // Listens for the `ActionInvoked(UInt32, String)` signal.
266 | fn wait_for_action_signal(connection: &Connection, id: u32, handler: impl ActionResponseHandler) {
267 |     connection
268 |         .add_match(&format!(
269 |             "interface='{}',member='ActionInvoked'",
270 |             NOTIFICATION_INTERFACE
271 |         ))
272 |         .unwrap();
273 |     connection
274 |         .add_match(&format!(
275 |             "interface='{}',member='NotificationClosed'",
276 |             NOTIFICATION_INTERFACE
277 |         ))
278 |         .unwrap();
279 | 
280 |     for item in connection.iter(1000) {
281 |         if let ConnectionItem::Signal(message) = item {
282 |             let items = message.get_items();
283 | 
284 |             let (path, interface, member) = (
285 |                 message.path().map_or_else(String::new, |p| {
286 |                     p.into_cstring().to_string_lossy().into_owned()
287 |                 }),
288 |                 message.interface().map_or_else(String::new, |p| {
289 |                     p.into_cstring().to_string_lossy().into_owned()
290 |                 }),
291 |                 message.member().map_or_else(String::new, |p| {
292 |                     p.into_cstring().to_string_lossy().into_owned()
293 |                 }),
294 |             );
295 |             match (path.as_str(), interface.as_str(), member.as_str()) {
296 |                 // match (protocol.unwrap(), iface.unwrap(), member.unwrap()) {
297 |                 // Action Invoked
298 |                 (path, interface, "ActionInvoked")
299 |                     if path == NOTIFICATION_OBJECTPATH && interface == NOTIFICATION_INTERFACE =>
300 |                 {
301 |                     if let (&MessageItem::UInt32(nid), MessageItem::Str(ref action)) =
302 |                         (&items[0], &items[1])
303 |                     {
304 |                         if nid == id {
305 |                             handler.call(&ActionResponse::Custom(action));
306 |                             break;
307 |                         }
308 |                     }
309 |                 }
310 | 
311 |                 // Notification Closed
312 |                 (path, interface, "NotificationClosed")
313 |                     if path == NOTIFICATION_OBJECTPATH && interface == NOTIFICATION_INTERFACE =>
314 |                 {
315 |                     if let (&MessageItem::UInt32(nid), &MessageItem::UInt32(reason)) =
316 |                         (&items[0], &items[1])
317 |                     {
318 |                         if nid == id {
319 |                             handler.call(&ActionResponse::Closed(reason.into()));
320 |                             break;
321 |                         }
322 |                     }
323 |                 }
324 |                 (..) => (),
325 |             }
326 |         }
327 |     }
328 | }
329 | 


--------------------------------------------------------------------------------
/src/xdg/zbus_rs.rs:
--------------------------------------------------------------------------------
  1 | use crate::{error::*, notification::Notification, xdg};
  2 | use futures_lite::stream::StreamExt;
  3 | use zbus::MatchRule;
  4 | 
  5 | use super::{bus::NotificationBus, ActionResponse, ActionResponseHandler, CloseReason};
  6 | 
  7 | pub mod bus {
  8 | 
  9 |     use crate::xdg::NOTIFICATION_DEFAULT_BUS;
 10 | 
 11 |     fn skip_first_slash(s: &str) -> &str {
 12 |         if let Some('/') = s.chars().next() {
 13 |             &s[1..]
 14 |         } else {
 15 |             s
 16 |         }
 17 |     }
 18 | 
 19 |     use std::path::PathBuf;
 20 | 
 21 |     type BusNameType = zbus::names::WellKnownName<'static>;
 22 | 
 23 |     #[derive(Clone, Debug)]
 24 |     pub struct NotificationBus(BusNameType);
 25 | 
 26 |     impl Default for NotificationBus {
 27 |         #[cfg(feature = "zbus")]
 28 |         fn default() -> Self {
 29 |             Self(zbus::names::WellKnownName::from_static_str(NOTIFICATION_DEFAULT_BUS).unwrap())
 30 |         }
 31 |     }
 32 | 
 33 |     impl NotificationBus {
 34 |         fn namespaced_custom(custom_path: &str) -> Option<String> {
 35 |             // abusing path for semantic join
 36 |             skip_first_slash(
 37 |                 PathBuf::from("/de/hoodie/Notification")
 38 |                     .join(custom_path)
 39 |                     .to_str()?,
 40 |             )
 41 |             .replace('/', ".")
 42 |             .into()
 43 |         }
 44 | 
 45 |         pub fn custom(custom_path: &str) -> Option<Self> {
 46 |             let name =
 47 |                 zbus::names::WellKnownName::try_from(Self::namespaced_custom(custom_path)?).ok()?;
 48 |             Some(Self(name))
 49 |         }
 50 | 
 51 |         pub fn into_name(self) -> BusNameType {
 52 |             self.0
 53 |         }
 54 |     }
 55 | }
 56 | 
 57 | /// A handle to a shown notification.
 58 | ///
 59 | /// This keeps a connection alive to ensure actions work on certain desktops.
 60 | #[derive(Debug)]
 61 | pub struct ZbusNotificationHandle {
 62 |     pub(crate) id: u32,
 63 |     pub(crate) connection: zbus::Connection,
 64 |     pub(crate) notification: Notification,
 65 | }
 66 | 
 67 | impl ZbusNotificationHandle {
 68 |     pub(crate) fn new(
 69 |         id: u32,
 70 |         connection: zbus::Connection,
 71 |         notification: Notification,
 72 |     ) -> ZbusNotificationHandle {
 73 |         ZbusNotificationHandle {
 74 |             id,
 75 |             connection,
 76 |             notification,
 77 |         }
 78 |     }
 79 | 
 80 |     pub async fn wait_for_action(self, invocation_closure: impl ActionResponseHandler) {
 81 |         wait_for_action_signal(&self.connection, self.id, invocation_closure).await;
 82 |     }
 83 | 
 84 |     pub async fn close_fallible(self) -> Result<()> {
 85 |         self.connection
 86 |             .call_method(
 87 |                 Some(self.notification.bus.clone().into_name()),
 88 |                 xdg::NOTIFICATION_OBJECTPATH,
 89 |                 Some(xdg::NOTIFICATION_INTERFACE),
 90 |                 "CloseNotification",
 91 |                 &(self.id),
 92 |             )
 93 |             .await?;
 94 |         Ok(())
 95 |     }
 96 | 
 97 |     pub async fn close(self) {
 98 |         self.close_fallible().await.unwrap();
 99 |     }
100 | 
101 |     pub fn on_close<F>(self, closure: F)
102 |     where
103 |         F: FnOnce(CloseReason),
104 |     {
105 |         zbus::block_on(self.wait_for_action(|action: &ActionResponse| {
106 |             if let ActionResponse::Closed(reason) = action {
107 |                 closure(*reason);
108 |             }
109 |         }));
110 |     }
111 | 
112 |     pub fn update_fallible(&mut self) -> Result<()> {
113 |         self.id = zbus::block_on(send_notification_via_connection(
114 |             &self.notification,
115 |             self.id,
116 |             &self.connection,
117 |         ))?;
118 |         Ok(())
119 |     }
120 | 
121 |     pub fn update(&mut self) {
122 |         self.update_fallible().unwrap();
123 |     }
124 | }
125 | 
126 | async fn send_notification_via_connection(
127 |     notification: &Notification,
128 |     id: u32,
129 |     connection: &zbus::Connection,
130 | ) -> Result<u32> {
131 |     send_notification_via_connection_at_bus(notification, id, connection, Default::default()).await
132 | }
133 | 
134 | async fn send_notification_via_connection_at_bus(
135 |     notification: &Notification,
136 |     id: u32,
137 |     connection: &zbus::Connection,
138 |     bus: NotificationBus,
139 | ) -> Result<u32> {
140 |     let reply: u32 = connection
141 |         .call_method(
142 |             Some(bus.into_name()),
143 |             xdg::NOTIFICATION_OBJECTPATH,
144 |             Some(xdg::NOTIFICATION_INTERFACE),
145 |             "Notify",
146 |             &(
147 |                 &notification.appname,
148 |                 id,
149 |                 &notification.icon,
150 |                 &notification.summary,
151 |                 &notification.body,
152 |                 &notification.actions,
153 |                 crate::hints::hints_to_map(notification),
154 |                 i32::from(notification.timeout),
155 |             ),
156 |         )
157 |         .await?
158 |         .body()
159 |         .deserialize()?;
160 |     Ok(reply)
161 | }
162 | 
163 | pub async fn connect_and_send_notification(
164 |     notification: &Notification,
165 | ) -> Result<ZbusNotificationHandle> {
166 |     let bus = notification.bus.clone();
167 |     connect_and_send_notification_at_bus(notification, bus).await
168 | }
169 | 
170 | pub(crate) async fn connect_and_send_notification_at_bus(
171 |     notification: &Notification,
172 |     bus: NotificationBus,
173 | ) -> Result<ZbusNotificationHandle> {
174 |     let connection = zbus::Connection::session().await?;
175 |     let inner_id = notification.id.unwrap_or(0);
176 |     let id =
177 |         send_notification_via_connection_at_bus(notification, inner_id, &connection, bus).await?;
178 | 
179 |     Ok(ZbusNotificationHandle::new(
180 |         id,
181 |         connection,
182 |         notification.clone(),
183 |     ))
184 | }
185 | 
186 | pub async fn get_capabilities_at_bus(bus: NotificationBus) -> Result<Vec<String>> {
187 |     let connection = zbus::Connection::session().await?;
188 |     let info: Vec<String> = connection
189 |         .call_method(
190 |             Some(bus.into_name()),
191 |             xdg::NOTIFICATION_OBJECTPATH,
192 |             Some(xdg::NOTIFICATION_INTERFACE),
193 |             "GetCapabilities",
194 |             &(),
195 |         )
196 |         .await?
197 |         .body()
198 |         .deserialize()?;
199 |     Ok(info)
200 | }
201 | 
202 | pub async fn get_capabilities() -> Result<Vec<String>> {
203 |     get_capabilities_at_bus(Default::default()).await
204 | }
205 | 
206 | pub async fn get_server_information_at_bus(bus: NotificationBus) -> Result<xdg::ServerInformation> {
207 |     let connection = zbus::Connection::session().await?;
208 |     let info: xdg::ServerInformation = connection
209 |         .call_method(
210 |             Some(bus.into_name()),
211 |             xdg::NOTIFICATION_OBJECTPATH,
212 |             Some(xdg::NOTIFICATION_INTERFACE),
213 |             "GetServerInformation",
214 |             &(),
215 |         )
216 |         .await?
217 |         .body()
218 |         .deserialize()?;
219 | 
220 |     Ok(info)
221 | }
222 | 
223 | pub async fn get_server_information() -> Result<xdg::ServerInformation> {
224 |     get_server_information_at_bus(Default::default()).await
225 | }
226 | 
227 | /// Listens for the `ActionInvoked(UInt32, String)` Signal.
228 | ///
229 | /// No need to use this, check out `Notification::show_and_wait_for_action(FnOnce(action:&str))`
230 | pub async fn handle_action(id: u32, func: impl ActionResponseHandler) {
231 |     let connection = zbus::Connection::session().await.unwrap();
232 |     wait_for_action_signal(&connection, id, func).await;
233 | }
234 | 
235 | async fn wait_for_action_signal(
236 |     connection: &zbus::Connection,
237 |     id: u32,
238 |     handler: impl ActionResponseHandler,
239 | ) {
240 |     let action_signal_rule = MatchRule::builder()
241 |         .msg_type(zbus::message::Type::Signal)
242 |         .interface(xdg::NOTIFICATION_INTERFACE)
243 |         .unwrap()
244 |         .member("ActionInvoked")
245 |         .unwrap()
246 |         .build();
247 | 
248 |     let proxy = zbus::fdo::DBusProxy::new(connection).await.unwrap();
249 |     proxy.add_match_rule(action_signal_rule).await.unwrap();
250 | 
251 |     let close_signal_rule = MatchRule::builder()
252 |         .msg_type(zbus::message::Type::Signal)
253 |         .interface(xdg::NOTIFICATION_INTERFACE)
254 |         .unwrap()
255 |         .member("NotificationClosed")
256 |         .unwrap()
257 |         .build();
258 |     proxy.add_match_rule(close_signal_rule).await.unwrap();
259 | 
260 |     while let Ok(Some(msg)) = zbus::MessageStream::from(connection).try_next().await {
261 |         let header = msg.header();
262 |         if let zbus::message::Type::Signal = header.message_type() {
263 |             match header.member() {
264 |                 Some(name) if name == "ActionInvoked" => {
265 |                     match msg.body().deserialize::<(u32, String)>() {
266 |                         Ok((nid, action)) if nid == id => {
267 |                             handler.call(&ActionResponse::Custom(&action));
268 |                             break;
269 |                         }
270 |                         _ => {}
271 |                     }
272 |                 }
273 |                 Some(name) if name == "NotificationClosed" => {
274 |                     match msg.body().deserialize::<(u32, u32)>() {
275 |                         Ok((nid, reason)) if nid == id => {
276 |                             handler.call(&ActionResponse::Closed(reason.into()));
277 |                             break;
278 |                         }
279 |                         _ => {}
280 |                     }
281 |                 }
282 |                 _ => {}
283 |             }
284 |         }
285 |     }
286 | }
287 | 


--------------------------------------------------------------------------------
/tests/conversion.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(test)]
 2 | mod conversion {
 3 | 
 4 |     use notify_rust::Urgency;
 5 | 
 6 |     #[test]
 7 |     fn urgency_from_int() {
 8 |         assert_eq!(Urgency::from(0), Urgency::Low);
 9 |         assert_eq!(Urgency::from(1), Urgency::Normal);
10 |         assert_eq!(Urgency::from(2), Urgency::Critical);
11 |         assert_eq!(Urgency::from(900), Urgency::Critical);
12 |         assert_eq!(Urgency::from(u64::MAX), Urgency::Critical);
13 |     }
14 | 
15 |     #[test]
16 |     fn urgency_from_option_int() {
17 |         assert_eq!(Urgency::from(Some(0)), Urgency::Low);
18 |         assert_eq!(Urgency::from(Some(1)), Urgency::Normal);
19 |         assert_eq!(Urgency::from(None), Urgency::Normal);
20 |         assert_eq!(Urgency::from(Some(2)), Urgency::Critical);
21 |     }
22 | 
23 |     #[test]
24 |     fn str_into_urgency() {
25 |         let u0: Urgency = "low".try_into().unwrap();
26 |         assert_eq!(u0, Urgency::Low);
27 |     }
28 | 
29 |     #[test]
30 |     fn urgency_from_str() {
31 |         assert_eq!(Urgency::try_from("low").ok(), Some(Urgency::Low));
32 |         assert_eq!(Urgency::try_from("medium").ok(), Some(Urgency::Normal));
33 |         assert_eq!(Urgency::try_from("Normal").ok(), Some(Urgency::Normal));
34 |         assert_eq!(Urgency::try_from("NoRmaL").ok(), Some(Urgency::Normal));
35 |         assert_eq!(Urgency::try_from("High").ok(), Some(Urgency::Critical));
36 |         assert_eq!(Urgency::try_from("Hi").ok(), Some(Urgency::Critical));
37 |         assert_eq!(Urgency::try_from("Critical").ok(), Some(Urgency::Critical));
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/ownworld.rs:
--------------------------------------------------------------------------------
  1 | #![cfg(feature = "server")]
  2 | #![allow(unused_must_use)]
  3 | #![cfg(all(unix, not(target_os = "macos")))]
  4 | extern crate notify_rust;
  5 | 
  6 | #[cfg(test)]
  7 | mod ownworld {
  8 | 
  9 |     use notify_rust::server::*;
 10 |     use notify_rust::*;
 11 |     use std::thread;
 12 | 
 13 |     #[test]
 14 |     #[ignore]
 15 |     fn server_can_be_stopped() {
 16 |         let thread_handle = thread::spawn(move || {
 17 |             let server = NotificationServer::create();
 18 |             NotificationServer::start(&server, |_| {})
 19 |         });
 20 | 
 21 |         stop_server();
 22 |         assert!(thread_handle.join().is_ok());
 23 |     }
 24 | 
 25 |     #[test]
 26 |     #[ignore]
 27 |     fn actions_vec() {
 28 |         let thread_handle = thread::spawn(move || {
 29 |             let server = NotificationServer::create();
 30 |             NotificationServer::start(&server, |notification| {
 31 |                 assert_eq!(notification.actions[0], "actions_vec0");
 32 |                 assert_eq!(notification.actions[1], "actions_vec1");
 33 |                 assert_eq!(notification.actions[2], "actions_vec2");
 34 |                 assert_eq!(notification.actions[3], "actions_vec3");
 35 |             })
 36 |         });
 37 | 
 38 |         #[allow(deprecated)]
 39 |         Notification::new()
 40 |             .summary("Notification with actions")
 41 |             .body("action1=\"Action One\", something_else=\"Something Else\"")
 42 |             .icon("dialog-information")
 43 |             .actions(vec![
 44 |                 "actions_vec0".into(),
 45 |                 "actions_vec1".into(),
 46 |                 "actions_vec2".into(),
 47 |                 "actions_vec3".into(),
 48 |             ])
 49 |             .show();
 50 | 
 51 |         stop_server();
 52 |         assert!(thread_handle.join().is_ok());
 53 |     }
 54 | 
 55 |     #[test]
 56 |     #[ignore]
 57 |     fn actions_automatic() {
 58 |         let server = NotificationServer::create();
 59 |         let thread_handle = thread::spawn(move || {
 60 |             NotificationServer::start(&server, |notification| {
 61 |                 assert_eq!(notification.actions[0], "actions_built0");
 62 |                 assert_eq!(notification.actions[1], "actions_built1");
 63 |                 assert_eq!(notification.actions[2], "actions_built2");
 64 |                 assert_eq!(notification.actions[3], "actions_built3");
 65 |                 assert_eq!(notification.timeout, Timeout::Milliseconds(6000));
 66 |             })
 67 |         });
 68 | 
 69 |         Notification::new()
 70 |             .summary("Another notification with actions")
 71 |             .body("action0=\"Press me please\", action1=\"firefox\"")
 72 |             .icon("dialog-information")
 73 |             .timeout(6000) //miliseconds
 74 |             .action("actions_built0", "actions_built1")
 75 |             .action("actions_built2", "actions_built3")
 76 |             .show();
 77 | 
 78 |         stop_server();
 79 |         assert!(thread_handle.join().is_ok());
 80 |     }
 81 | 
 82 |     #[test]
 83 |     #[ignore]
 84 |     #[should_panic]
 85 |     fn no_server() {
 86 |         let server = NotificationServer::create();
 87 |         thread::spawn(move || {
 88 |             NotificationServer::start(&server, |notification| println!("{:#?}", notification))
 89 |         });
 90 | 
 91 |         stop_server();
 92 |         Notification::new()
 93 |             .summary("Another notification with actions")
 94 |             .body("action0=\"Press me please\", action1=\"firefox\"")
 95 |             .show()
 96 |             .unwrap();
 97 |     }
 98 | 
 99 |     #[test]
100 |     #[ignore]
101 |     #[should_panic]
102 |     fn join_failed() {
103 |         let thread_handle = thread::spawn(|| {
104 |             let server = NotificationServer::create();
105 |             NotificationServer::start(&server, |notification| {
106 |                 assert_eq!(notification.timeout, Timeout::Milliseconds(6000));
107 |                 assert_eq!(notification.actions[0], "this is no action");
108 |             })
109 |         });
110 | 
111 |         Notification::new()
112 |             .summary("Notification without timeout")
113 |             .show();
114 |         stop_server();
115 |         assert!(thread_handle.join().is_ok());
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/tests/realworld.rs:
--------------------------------------------------------------------------------
  1 | #![allow(unused_must_use)]
  2 | extern crate notify_rust;
  3 | 
  4 | #[cfg(test)]
  5 | mod realworld {
  6 | 
  7 |     use std::time::Duration;
  8 | 
  9 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
 10 |     use notify_rust::Image;
 11 |     use notify_rust::*;
 12 | 
 13 |     use ctor::ctor;
 14 | 
 15 |     #[ctor]
 16 |     fn init_color_backtrace() {
 17 |         color_backtrace::install();
 18 |     }
 19 | 
 20 |     #[test]
 21 |     fn burst() {
 22 |         for msg in &[
 23 |             "These should each",
 24 |             "come in their own pop up.",
 25 |             "If they don't than",
 26 |             "I will have to complain about it.",
 27 |         ] {
 28 |             Notification::new()
 29 |                 .summary("burst")
 30 |                 .appname(msg)
 31 |                 .body(msg)
 32 |                 .icon("media-floppy")
 33 |                 .show()
 34 |                 .unwrap();
 35 |         }
 36 | 
 37 |         for msg in &[
 38 |             "These may be grouped",
 39 |             "together by the server.",
 40 |             "that is because the all have the same",
 41 |             "appname.",
 42 |         ] {
 43 |             Notification::new()
 44 |                 .summary("merged burst")
 45 |                 .body(msg)
 46 |                 .icon("applications-toys")
 47 |                 .show()
 48 |                 .unwrap();
 49 |         }
 50 |     }
 51 | 
 52 |     #[test]
 53 |     #[cfg(all(unix, not(target_os = "macos")))]
 54 |     fn closing() {
 55 |         Notification::new()
 56 |             .summary("You see me")
 57 |             .body("you don't see me!")
 58 |             .show()
 59 |             .unwrap()
 60 |             .close();
 61 |     }
 62 | 
 63 |     #[test]
 64 |     #[cfg(all(unix, not(target_os = "macos")))]
 65 |     fn capabilities() {
 66 |         let capabilities: Vec<String> = get_capabilities().unwrap();
 67 |         for capability in capabilities {
 68 |             Notification::new()
 69 |                 .summary("capability")
 70 |                 .body(&capability)
 71 |                 .show()
 72 |                 .unwrap();
 73 |         }
 74 |     }
 75 | 
 76 |     #[test]
 77 |     fn build_pattern() {
 78 |         let notification = Notification::new().summary("foo").finalize();
 79 |         assert_eq!(notification.summary, "foo");
 80 | 
 81 |         let mut notification = Notification::new();
 82 |         notification.body = "foo".to_string();
 83 |         assert_eq!(notification.body, "foo");
 84 | 
 85 |         let mut notification = Notification::new();
 86 |         notification.icon = "foo".to_string();
 87 |         assert_eq!(notification.icon, "foo");
 88 | 
 89 |         let mut notification = Notification::new();
 90 |         notification.summary = "foo".to_string();
 91 |         assert_eq!(notification.summary, "foo");
 92 | 
 93 |         let mut notification = Notification::new();
 94 |         notification.timeout = Timeout::Milliseconds(42);
 95 |         assert_eq!(notification.timeout, Timeout::Milliseconds(21 * 2));
 96 | 
 97 |         let mut notification = Notification::new();
 98 |         notification.summary = "foo".to_string();
 99 |         assert_eq!(notification.summary, "foo");
100 |     }
101 | 
102 |     #[test]
103 |     fn init() {
104 |         let mut message = Notification::new();
105 |         message.summary("invocation type 2");
106 |         message.body("your <b>body</b> is a <u>wonderland</u>");
107 |         message.show().unwrap();
108 | 
109 |         Notification::new()
110 |             .summary("this is the summary")
111 |             .summary("invocation type 3")
112 |             .body("this is the body\nnewline<br/>linebreak")
113 |             .show()
114 |             .unwrap();
115 |     }
116 | 
117 |     #[test]
118 |     fn should_allow_timeout_with_duration() {
119 |         let mut notification = Notification::new();
120 |         notification.timeout(Duration::from_secs(15));
121 |         assert!(matches!(
122 |             notification.timeout,
123 |             Timeout::Milliseconds(15_000)
124 |         ));
125 |     }
126 | 
127 |     #[test]
128 |     #[cfg(all(unix, not(target_os = "macos")))]
129 |     fn urgency() {
130 |         // use it this way
131 |         use Urgency::*;
132 |         for urgency in &[
133 |             Hint::Urgency(Low),
134 |             Hint::Urgency(Normal),
135 |             Hint::Urgency(Critical),
136 |         ] {
137 |             Notification::new()
138 |                 .summary(&format!("Urgency {:?}", urgency))
139 |                 .hint(urgency.clone())
140 |                 .show()
141 |                 .unwrap();
142 |         }
143 |     }
144 | 
145 |     #[test]
146 |     #[cfg(all(unix, not(target_os = "macos")))]
147 |     fn category() {
148 |         Notification::new()
149 |             .appname("thunderbird")
150 |             .summary("Category:email")
151 |             .icon("thunderbird")
152 |             .hint(Hint::Category("email".to_string()))
153 |             .show()
154 |             .unwrap();
155 |     }
156 | 
157 |     #[test]
158 |     #[cfg(all(unix, not(target_os = "macos")))]
159 |     fn persistent() {
160 |         Notification::new()
161 |             .summary("Incoming Call: Your Mom!")
162 |             .body("Resident:True")
163 |             .icon("call-start")
164 |             .hint(Hint::Resident(true))
165 |             .show()
166 |             .unwrap();
167 | 
168 |         Notification::new()
169 |             .summary("Incoming Call: Your Mom!")
170 |             .body("Resident:False, but Timeout=0")
171 |             .icon("call-start")
172 |             .hint(Hint::Resident(false))
173 |             .timeout(0)
174 |             .show()
175 |             .unwrap();
176 |     }
177 | 
178 |     #[test]
179 |     #[cfg(all(feature = "images", unix, not(target_os = "macos")))]
180 |     fn imagedata() {
181 |         let mut data: Vec<u8> = vec![0 as u8; 64 * 64 * 3];
182 |         for x in 0..64 {
183 |             for y in 0..64 {
184 |                 let offset = (y * 64 + x) * 3;
185 |                 data[offset] = (x + y) as u8;
186 |                 data[offset + 1] = x as u8;
187 |                 data[offset + 2] = y as u8;
188 |             }
189 |         }
190 | 
191 |         Notification::new()
192 |             .summary("I can haz image data!")
193 |             .hint(Hint::ImageData(Image::from_rgb(64, 64, data).unwrap()))
194 |             .show()
195 |             .unwrap();
196 |     }
197 | }
198 | 


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