hasufell/pnmixer-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: hasufell:doc
Branches Tags
hasufell:master
hasufell:audio-reload
hasufell:pulseaudio
hasufell:audio_trait
hasufell:gh-pages
hasufell:hotkeys
hasufell:travis
hasufell:doc
hasufell:dev
..
compare: hasufell:master
Branches Tags
hasufell:audio-reload
hasufell:master
hasufell:pulseaudio
hasufell:audio_trait
hasufell:gh-pages
hasufell:hotkeys
hasufell:travis
hasufell:doc
hasufell:dev

40 Commits
doc ... master

Author SHA1 Message Date
Julian Ospald
c7a200085b Update dependencies and fix build 2018-01-25 22:40:13 +01:00
Julian Ospald
cd0b9bea93 Make logging configurable 
Fixes #8
 2017-09-29 17:24:33 +02:00
Julian Ospald
29332b939e Update dependencies 2017-09-28 16:40:24 +02:00
Julian Ospald
83381a9ffa
Add latest version badge 2017-09-02 01:50:52 +02:00
Julian Ospald
176816ff83
Update package metadata 2017-09-02 01:39:27 +02:00
Julian Ospald
05e8c772c2
Update libnotify dep 2017-09-02 01:24:20 +02:00
Julian Ospald
31eb47a26b
Bump to 0.1.1 2017-09-02 01:19:56 +02:00
Julian Ospald
2b9b382883
Revert "Fix build with latest gtk-rs" 
This reverts commit 01a8a57235.
 2017-09-02 01:18:49 +02:00
Julian Ospald
c543bb8ce5
Remove obsolete comment 2017-09-02 01:18:16 +02:00
Julian Ospald
6639d4a577
Build with latest libs 2017-09-02 01:18:16 +02:00
Julian Ospald
ef2eb24328
Remove obsolete copy_pixbuf() function 
This is now in gdk_pixbuf library anyway.
 2017-09-02 01:18:15 +02:00
Julian Ospald
7904c00aa8
Improve error handling 2017-09-02 01:18:11 +02:00
Julian Ospald
01a8a57235
Fix build with latest gtk-rs 2017-08-24 17:41:58 +02:00
Julian Ospald
910baff12a
Fix hotkey assignment 2017-07-19 23:46:00 +02:00
Julian Ospald
8cc453e6cd Fix memory leak in Pixbuf copying 2017-07-19 17:51:52 +02:00
Julian Ospald
a64923b818 Improve some debug messages 2017-07-19 17:51:38 +02:00
Julian Ospald
3613f8831b Fix build when notify is disabled 2017-07-19 13:09:04 +02:00
Julian Ospald
506ad72015 Remove some unwrap()s 2017-07-19 13:03:54 +02:00
Julian Ospald
72cc33ac7d Restructure modules 2017-07-19 12:15:56 +02:00
Julian Ospald
d8f1a794ac Update .gitignore 2017-07-19 12:11:49 +02:00
Julian Ospald
6fc9d80ab0
Rename audio/alsa modules 2017-07-19 02:51:42 +02:00
Julian Ospald
9cc6921194
Add PulseAudio support to TODO list 2017-07-19 02:24:39 +02:00
Julian Ospald
a47bede4a7
Merge branch 'audio_trait' 2017-07-19 02:23:15 +02:00
Julian Ospald
6251a65764
Make Audio subsystem a trait 'AudioFrontend' 
Fixes #10
 2017-07-19 02:23:03 +02:00
Julian Ospald
a9145628a8
Fix tray icon toggle mute signal origin 2017-07-17 01:43:44 +02:00
Julian Ospald
590f803cd9
'pub' all the modules, so they show up in the documentation 2017-07-16 23:41:00 +02:00
Julian Ospald
02c60b23ea
Improve error handling 2017-07-16 23:28:21 +02:00
Julian Ospald
686f5a0f4c
Update README 2017-07-16 23:08:40 +02:00
Julian Ospald
687a3f7393
Merge branch 'hotkeys' 2017-07-16 22:49:39 +02:00
Julian Ospald
ee847ff896
Implement hotkey support and improve error handling 
Fixes #5
 2017-07-16 22:48:55 +02:00
Julian Ospald
b7beebc20f
Fix extern crate/mod visibility 2017-07-15 11:19:55 +02:00
Julian Ospald
28df945631
try_er! is obsolete, since it's the same as try_e! 2017-07-15 01:55:45 +02:00
Julian Ospald
7542d8beaf
Document error macros 2017-07-15 01:54:22 +02:00
Julian Ospald
c57622fad5
Add top-level documentation 2017-07-15 01:43:57 +02:00
Julian Ospald
996ac058c4
Documentation done 2017-07-15 01:38:07 +02:00
Julian Ospald
a8e90cb8f3
Add documentation link 2017-07-15 01:36:01 +02:00
Julian Ospald
1428055c31
Cosmetics 2017-07-15 01:20:47 +02:00
Julian Ospald
4d4d11ebb1
Rename pixbuf_new_from_file! to pixbuf_new_from_png! 2017-07-15 01:19:27 +02:00
Julian Ospald
0343ec6221
Don't invoke alsa functions from the high-level UI code 
Instead, call indirection functions from the audio subsystem, so
we don't break module hierarchy.
 2017-07-15 01:19:10 +02:00
Julian Ospald
bdcf8b0436
Document code, fixes #3 2017-07-15 01:17:19 +02:00
38 changed files with 4055 additions and 1833 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -2,3 +2,4 @@ target
Cargo.lock
*.bk
*~
core

114
Cargo.toml
View File

@ -1,61 +1,83 @@
[package]
name = "pnmixer-rs"
version = "0.1.0"
authors = ["Julian Ospald <hasufell@posteo.de>"]
[lib]
name = "pnmixerlib"
path = "src/lib.rs"
doc = true
categories = [ "multimedia::audio" ]
description = "Volume mixer for the system tray"
documentation = "https://hasufell.github.io/pnmixer-rust/pnmixerlib/"
homepage = "https://github.com/hasufell/pnmixer-rust"
keywords = [ "alsa", "gtk", "mixer" ]
license = "GPL-3.0"
name = "pnmixer-rs"
readme = "README.md"
repository = "https://github.com/hasufell/pnmixer-rust"
version = "0.1.2"
[[bin]]
doc = false
name = "pnmixer-rs"
path = "src/bin.rs"
doc = false
[dependencies]
alsa = "^0.1.8"
alsa-sys = "^0.1.1"
error-chain = { git = "https://github.com/hasufell/error-chain.git", branch = "PR-from-error" }
ffi = "^0.0.2"
flexi_logger = "^0.5.1"
gdk-pixbuf = { git = "https://github.com/gtk-rs/gdk-pixbuf.git" }
gdk-pixbuf-sys = { git = "https://github.com/gtk-rs/sys" }
gdk-sys = { git = "https://github.com/gtk-rs/sys" }
gio = { git = "https://github.com/gtk-rs/gio.git" }
glib = { git = "https://github.com/gtk-rs/glib.git" }
glib-sys = { git = "https://github.com/gtk-rs/sys" }
gobject-sys = { git = "https://github.com/gtk-rs/sys" }
gtk-sys = { git = "https://github.com/gtk-rs/sys" }
libc = "^0.2.23"
log = "^0.3.8"
serde = "^1.0.9"
serde_derive = "^1.0.9"
toml = "^0.4.2"
which = "*"
xdg = "*"
libnotify = { git = "https://github.com/hasufell/rust-libnotify.git", branch = "git-deps", optional = true }
png = "^0.9.0"
[dependencies.gtk]
git = "https://github.com/gtk-rs/gtk.git"
features = [ "v3_10", "v3_12", "v3_22" ]
alsa = "0.2.0"
alsa-sys = "0.1.1"
error-chain = "0.11.0"
ffi = "0.0.2"
flexi_logger = "0.6.11"
gdk-pixbuf = "0.3.0"
gdk-pixbuf-sys = "0.5.0"
gdk-sys = "0.5.0"
getopts = "0.2.17"
gio = "0.3.0"
glib = "0.4.1"
glib-sys = "0.5.0"
gobject-sys = "0.5.0"
gtk-sys = "0.5.0"
lazy_static = "1.0.0"
libc = "0.2.36"
libnotify = { version = "1.0.2", optional = true }
log = "0.4.1"
png = "0.11.0"
serde = "1.0.27"
serde_derive = "1.0.27"
toml = "0.4.5"
w_result = "0.1.2"
which = "1.0.3"
xdg = "2.1.0"
[dependencies.gdk]
git = "https://github.com/gtk-rs/gdk.git"
features = [ "v3_10", "v3_12", "v3_22" ]
features = [
"v3_10",
"v3_12",
"v3_22",
]
version = "0.7.0"
[profile.dev]
opt-level = 0 # controls the `--opt-level` the compiler builds with
debug = true # controls whether the compiler passes `-C debuginfo`
# a value of `true` is equivalent to `2`
rpath = false # controls whether the compiler passes `-C rpath`
lto = false # controls `-C lto` for binaries and staticlibs
debug-assertions = false # controls whether debug assertions are enabled
codegen-units = 1 # controls whether the compiler passes `-C codegen-units`
# `codegen-units` is ignored when `lto = true`
panic = 'unwind' # panic strategy (`-C panic=...`), can also be 'abort'
[dependencies.gtk]
features = [
"v3_10",
"v3_12",
"v3_22",
]
version = "0.3.0"
[dependencies.x11]
features = [
"xlib",
"xtst",
]
version = "2.17.2"
[features]
notify = ["libnotify"]
[lib]
doc = true
name = "pnmixerlib"
path = "src/lib.rs"
[profile.dev]
codegen-units = 1
debug = true
debug-assertions = false
lto = false
opt-level = 0
panic = "unwind"
rpath = false

15
README.md
View File

@ -1,5 +1,7 @@
[![Latest Version](https://img.shields.io/crates/v/pnmixer-rs.svg)](https://crates.io/crates/pnmixer-rs)
[![Build Status](https://travis-ci.org/hasufell/pnmixer-rust.svg)](https://travis-ci.org/hasufell/pnmixer-rust)
[![Join the chat at https://gitter.im/hasufell/pnmixer-rust](https://badges.gitter.im/hasufell/pnmixer-rust.svg)](https://gitter.im/hasufell/pnmixer-rust?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Documentation (master)](https://img.shields.io/badge/documentation-master-yellow.svg)](https://hasufell.github.io/pnmixer-rust/pnmixerlib/)
[![License](https://img.shields.io/github/license/hasufell/pnmixer-rust.svg)](https://github.com/hasufell/pnmixer-rust)
PNMixer-rs
@ -26,7 +28,7 @@ the cloned repository:
cargo install
```
Features
Features/Differences
--------
Additonal features compared to [nicklan/pnmixer](https://github.com/nicklan/pnmixer):
@ -39,17 +41,16 @@ Removed features:
* normalize volume
* slider orientation of volume popup
* settings for displaying text volume on volume popup
* gtk+:2 support
Behavior
--------
Pretty much the same. Differences are:
Differences:
* volume slider is shown even when volume is muted
TODO
----
- [ ] [hotkey support](https://github.com/hasufell/pnmixer-rust/issues/5)
- [x] [hotkey support](https://github.com/hasufell/pnmixer-rust/issues/5)
- [ ] [translation](https://github.com/hasufell/pnmixer-rust/issues/4)
- [ ] [documentation](https://github.com/hasufell/pnmixer-rust/issues/3)
- [X] [documentation](https://github.com/hasufell/pnmixer-rust/issues/3)
- [ ] [PulseAudio support](https://github.com/hasufell/pnmixer-rust/issues/11)

188
data/ui/hotkey-dialog.glade Normal file
View File

@ -0,0 +1,188 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.18.3 -->
<interface>
<requires lib="gtk+" version="3.12"/>
<object class="GtkDialog" id="hotkey_dialog">
<property name="width_request">300</property>
<property name="height_request">200</property>
<property name="can_focus">False</property>
<property name="border_width">5</property>
<property name="title">Set xxx HotKey</property>
<property name="modal">True</property>
<property name="destroy_with_parent">True</property>
<property name="icon_name">input-keyboard</property>
<property name="type_hint">dialog</property>
<child internal-child="vbox">
<object class="GtkBox" id="dialog-vbox1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="spacing">2</property>
<child internal-child="action_area">
<object class="GtkButtonBox" id="dialog-action_area1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="layout_style">end</property>
<child>
<object class="GtkButton" id="button1">
<property name="use_action_appearance">False</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="receives_default">True</property>
<child>
<object class="GtkBox" id="box4">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="halign">center</property>
<child>
<object class="GtkImage" id="image4">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="icon_name">gtk-cancel</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="label2">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="margin_start">5</property>
<property name="label" translatable="yes">Cancel</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
</child>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">False</property>
<property name="position">0</property>
</packing>
</child>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="pack_type">end</property>
<property name="position">3</property>
</packing>
</child>
<child>
<object class="GtkBox" id="hbox1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkImage" id="image1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="margin_start">10</property>
<property name="margin_end">10</property>
<property name="pixel_size">57</property>
<property name="icon_name">input-keyboard</property>
<property name="icon_size">3</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">False</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkBox" id="vbox1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="orientation">vertical</property>
<child>
<object class="GtkLabel" id="label1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">Defining HotKey</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="hotkey_reset_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">(press &lt;Ctrl&gt;C to reset)</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkHSeparator" id="hseparator1">
<property name="visible">True</property>
<property name="can_focus">False</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="instruction_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label">Press new HotKey for xxx</property>
<property name="use_markup">True</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">2</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="key_pressed_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">4</property>
</packing>
</child>
</object>
</child>
<action-widgets>
<action-widget response="0">button1</action-widget>
</action-widgets>
</object>
</interface>

223
data/ui/prefs-dialog.glade
View File

@ -926,10 +926,229 @@
</packing>
</child>
<child>
<placeholder/>
<object class="GtkBox" id="hotkeys_vbox">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="valign">start</property>
<property name="margin_start">5</property>
<property name="margin_end">5</property>
<property name="margin_top">5</property>
<property name="margin_bottom">5</property>
<property name="orientation">vertical</property>
<child>
<object class="GtkFrame" id="frame8">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label_xalign">0</property>
<property name="shadow_type">none</property>
<child>
<object class="GtkBox" id="vbox6">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="margin_start">12</property>
<property name="orientation">vertical</property>
<child>
<object class="GtkCheckButton" id="hotkeys_enable_check">
<property name="label" translatable="yes">Enable HotKeys</property>
<property name="use_action_appearance">False</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="receives_default">False</property>
<property name="halign">start</property>
<property name="draw_indicator">True</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">False</property>
<property name="padding">5</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkGrid" id="hotkeys_grid">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="row_spacing">12</property>
<property name="column_spacing">12</property>
<property name="column_homogeneous">True</property>
<child>
<object class="GtkLabel" id="label20">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="halign">start</property>
<property name="label" translatable="yes">Command</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
<packing>
<property name="left_attach">0</property>
<property name="top_attach">0</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="label7">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="halign">start</property>
<property name="label" translatable="yes">Mute/Unmute:</property>
</object>
<packing>
<property name="left_attach">0</property>
<property name="top_attach">1</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="label8">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="halign">start</property>
<property name="label" translatable="yes">Volume Up:</property>
</object>
<packing>
<property name="left_attach">0</property>
<property name="top_attach">2</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="label18">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="halign">start</property>
<property name="label" translatable="yes">Volume Down:</property>
</object>
<packing>
<property name="left_attach">0</property>
<property name="top_attach">3</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="label21">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">HotKey</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
<packing>
<property name="left_attach">1</property>
<property name="top_attach">0</property>
</packing>
</child>
<child>
<object class="GtkEventBox" id="hotkeys_mute_eventbox">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkLabel" id="hotkeys_mute_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">(None)</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
</child>
</object>
<packing>
<property name="left_attach">1</property>
<property name="top_attach">1</property>
</packing>
</child>
<child>
<object class="GtkEventBox" id="hotkeys_up_eventbox">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkLabel" id="hotkeys_up_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">(None)</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
</child>
</object>
<packing>
<property name="left_attach">1</property>
<property name="top_attach">2</property>
</packing>
</child>
<child>
<object class="GtkEventBox" id="hotkeys_down_eventbox">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkLabel" id="hotkeys_down_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">(None)</property>
<attributes>
<attribute name="weight" value="bold"/>
</attributes>
</object>
</child>
</object>
<packing>
<property name="left_attach">1</property>
<property name="top_attach">3</property>
</packing>
</child>
<child>
<object class="GtkLabel" id="label19">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">Double-click a HotKey to assign a new HotKey</property>
</object>
<packing>
<property name="left_attach">0</property>
<property name="top_attach">4</property>
<property name="width">2</property>
</packing>
</child>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
</child>
<child type="label">
<object class="GtkLabel" id="label24">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="margin_bottom">5</property>
<property name="label" translatable="yes">&lt;b&gt;HotKey Settings&lt;/b&gt;</property>
<property name="use_markup">True</property>
</object>
</child>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">False</property>
<property name="padding">5</property>
<property name="position">0</property>
</packing>
</child>
</object>
<packing>
<property name="position">3</property>
</packing>
</child>
<child type="tab">
<placeholder/>
<object class="GtkLabel" id="hotkeys_label">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">HotKeys</property>
</object>
<packing>
<property name="position">3</property>
<property name="tab_fill">False</property>
</packing>
</child>
</object>
<packing>

130
src/app_state.rs
View File

@ -1,10 +1,16 @@
use audio::{Audio, AudioUser};
//! Global application state.
use audio::alsa::backend::*;
use audio::frontend::*;
use errors::*;
use gtk;
use hotkeys::Hotkeys;
use prefs::*;
use std::cell::RefCell;
use support_audio::*;
use ui_entry::Gui;
use std::rc::Rc;
use support::audio::*;
use ui::entry::Gui;
#[cfg(feature = "notify")]
use notif::*;
@ -12,81 +18,131 @@ use notif::*;
// TODO: destructors
pub struct AppS {
/// The global application state struct.
pub struct AppS<T>
where
T: AudioFrontend,
{
_cant_construct: (),
/// Mostly static GUI state.
pub gui: Gui,
pub audio: Audio,
/// Audio state.
pub audio: Rc<T>,
/// Preferences state.
pub prefs: RefCell<Prefs>,
#[cfg(feature = "notify")]
pub notif: Notif,
/// Notification state. In case of initialization failure, this
/// is set to `None`.
pub notif: Option<Notif>,
/// Hotkey state.
pub hotkeys: RefCell<Box<Hotkeys<T>>>, // Gets an Rc to Audio.
}
impl AppS {
pub fn new() -> AppS {
let builder_popup_window =
gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
"/data/ui/popup-window.glade")));
let builder_popup_menu =
gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
"/data/ui/popup-menu.glade")));
let prefs = RefCell::new(Prefs::new().unwrap());
let gui =
Gui::new(builder_popup_window, builder_popup_menu, &prefs.borrow());
/// Create a new application state using the `AlsaBackend`.
pub fn new_alsa_appstate() -> AppS<AlsaBackend> {
let prefs = RefCell::new(unwrap_error!(Prefs::new(), None));
let card_name = prefs.borrow().device_prefs.card.clone();
let chan_name = prefs.borrow().device_prefs.channel.clone();
let audio = Rc::new(unwrap_error!(
AlsaBackend::new(Some(card_name), Some(chan_name)),
None
));
return AppS::new(prefs, audio);
}
impl<T> AppS<T>
where
T: AudioFrontend,
{
/// Create an application state instance. There should really only be one.
pub fn new(prefs: RefCell<Prefs>, audio: Rc<T>) -> Self {
let builder_popup_window =
gtk::Builder::new_from_string(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/data/ui/popup-window.glade"
)));
let builder_popup_menu =
gtk::Builder::new_from_string(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/data/ui/popup-menu.glade"
)));
let card_name = prefs.borrow()
.device_prefs
.card
.clone();
let chan_name = prefs.borrow()
.device_prefs
.channel
.clone();
// TODO: better error handling
#[cfg(feature = "notify")]
let notif = Notif::new(&prefs.borrow()).unwrap();
let notif = result_warn!(Notif::new(&prefs.borrow()), None).ok();
let hotkeys =
unwrap_error!(
wresult_warn!(Hotkeys::new(&prefs.borrow(), audio.clone()), None),
None
);
let gui =
Gui::new(builder_popup_window, builder_popup_menu, &prefs.borrow());
return AppS {
_cant_construct: (),
gui,
audio: Audio::new(Some(card_name), Some(chan_name)).unwrap(),
audio,
prefs,
#[cfg(feature = "notify")]
notif,
hotkeys: RefCell::new(hotkeys),
};
}
/* some functions that need to be easily accessible */
/// Update the tray icon state.
pub fn update_tray_icon(&self) -> Result<()> {
debug!("Update tray icon!");
return self.gui.tray_icon.update_all(&self.prefs.borrow(),
&self.audio,
None);
return self.gui.tray_icon.update_all(
&self.prefs.borrow(),
self.audio.as_ref(),
None,
);
}
/// Update the Popup Window state.
pub fn update_popup_window(&self) -> Result<()> {
debug!("Update PopupWindow!");
return self.gui.popup_window.update(&self.audio);
return self.gui.popup_window.update(self.audio.as_ref());
}
#[cfg(feature = "notify")]
pub fn update_notify(&self) -> Result<()> {
return self.notif.reload(&self.prefs.borrow());
/// Update the notification state.
pub fn update_notify(&self) {
match self.notif {
Some(ref n) => n.reload(&self.prefs.borrow()),
None => {
warn!("Notification system not unitialized, skipping update")
}
}
}
#[cfg(not(feature = "notify"))]
pub fn update_notify(&self) -> Result<()> {
return Ok(());
}
/// Update the notification state.
pub fn update_notify(&self) {}
/// Update the audio state.
pub fn update_audio(&self, user: AudioUser) -> Result<()> {
return audio_reload(&self.audio, &self.prefs.borrow(), user);
return audio_reload(self.audio.as_ref(), &self.prefs.borrow(), user);
}
/// Update the config file.
pub fn update_config(&self) -> Result<()> {
let prefs = self.prefs.borrow_mut();
return prefs.store_config();
}
/// Update hotkey state.
pub fn update_hotkeys(&self) -> Result<()> {
let prefs = self.prefs.borrow();
return self.hotkeys.borrow_mut().reload(&prefs);
}
}

358
src/audio.rs
View File

@ -1,358 +0,0 @@
use alsa_card::*;
use errors::*;
use glib;
use std::cell::Cell;
use std::cell::Ref;
use std::cell::RefCell;
use std::f64;
use std::rc::Rc;
use support_audio::*;
#[derive(Clone, Copy, Debug)]
pub enum VolLevel {
Muted,
Low,
Medium,
High,
Off,
}
#[derive(Clone, Copy, Debug)]
pub enum AudioUser {
Unknown,
Popup,
TrayIcon,
Hotkeys,
PrefsWindow,
}
#[derive(Clone, Copy, Debug)]
pub enum AudioSignal {
NoCard,
CardInitialized,
CardCleanedUp,
CardDisconnected,
CardError,
ValuesChanged,
}
#[derive(Clone)]
pub struct Handlers {
inner: Rc<RefCell<Vec<Box<Fn(AudioSignal, AudioUser)>>>>,
}
impl Handlers {
fn new() -> Handlers {
return Handlers { inner: Rc::new(RefCell::new(vec![])) };
}
fn borrow(&self) -> Ref<Vec<Box<Fn(AudioSignal, AudioUser)>>> {
return self.inner.borrow();
}
fn add_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>) {
self.inner.borrow_mut().push(cb);
}
}
pub struct Audio {
_cannot_construct: (),
pub acard: RefCell<Box<AlsaCard>>,
pub last_action_timestamp: Rc<RefCell<i64>>,
pub handlers: Handlers,
pub scroll_step: Cell<u32>,
}
impl Audio {
pub fn new(card_name: Option<String>,
elem_name: Option<String>)
-> Result<Audio> {
let handlers = Handlers::new();
let last_action_timestamp = Rc::new(RefCell::new(0));
let cb = {
let myhandler = handlers.clone();
let ts = last_action_timestamp.clone();
Rc::new(move |event| {
on_alsa_event(&mut *ts.borrow_mut(),
&myhandler.borrow(),
event)
})
};
let acard = AlsaCard::new(card_name, elem_name, cb);
/* additionally dispatch signals */
if acard.is_err() {
invoke_handlers(&handlers.borrow(),
AudioSignal::NoCard,
AudioUser::Unknown);
} else {
invoke_handlers(&handlers.borrow(),
AudioSignal::CardInitialized,
AudioUser::Unknown);
}
let audio = Audio {
_cannot_construct: (),
acard: RefCell::new(acard?),
last_action_timestamp: last_action_timestamp.clone(),
handlers: handlers.clone(),
scroll_step: Cell::new(5),
};
return Ok(audio);
}
pub fn switch_acard(&self,
card_name: Option<String>,
elem_name: Option<String>,
user: AudioUser)
-> Result<()> {
debug!("Switching cards");
debug!("Old card name: {}",
self.acard
.borrow()
.card_name()
.unwrap());
debug!("Old chan name: {}",
self.acard
.borrow()
.chan_name()
.unwrap());
let cb = self.acard
.borrow()
.cb
.clone();
{
let mut ac = self.acard.borrow_mut();
*ac = AlsaCard::new(card_name, elem_name, cb)?;
}
// invoke_handlers(&self.handlers.borrow(),
// AudioSignal::CardCleanedUp,
// user);
invoke_handlers(&self.handlers.borrow(),
AudioSignal::CardInitialized,
user);
return Ok(());
}
pub fn vol(&self) -> Result<f64> {
let alsa_vol = self.acard
.borrow()
.get_vol()?;
return vol_to_percent(alsa_vol, self.acard.borrow().get_volume_range());
}
pub fn vol_level(&self) -> VolLevel {
let muted = self.get_mute().unwrap_or(false);
if muted {
return VolLevel::Muted;
}
let cur_vol = try_r!(self.vol(), VolLevel::Muted);
match cur_vol {
0. => return VolLevel::Off,
0.0...33.0 => return VolLevel::Low,
0.0...66.0 => return VolLevel::Medium,
0.0...100.0 => return VolLevel::High,
_ => return VolLevel::Off,
}
}
pub fn set_vol(&self,
new_vol: f64,
user: AudioUser,
dir: VolDir,
auto_unmute: bool)
-> Result<()> {
{
let mut rc = self.last_action_timestamp.borrow_mut();
*rc = glib::get_monotonic_time();
}
let alsa_vol = percent_to_vol(new_vol,
self.acard.borrow().get_volume_range(),
dir)?;
/* only invoke handlers etc. if volume did actually change */
{
let old_alsa_vol =
percent_to_vol(self.vol()?,
self.acard.borrow().get_volume_range(),
dir)?;
if old_alsa_vol == alsa_vol {
return Ok(());
}
}
/* auto-unmute */
if auto_unmute && self.has_mute() && self.get_mute()? {
self.set_mute(false, user)?;
}
debug!("Setting vol on card {:?} and chan {:?} to {:?} by user {:?}",
self.acard
.borrow()
.card_name()
.unwrap(),
self.acard
.borrow()
.chan_name()
.unwrap(),
new_vol,
user);
self.acard
.borrow()
.set_vol(alsa_vol)?;
invoke_handlers(&self.handlers.borrow(),
AudioSignal::ValuesChanged,
user);
return Ok(());
}
pub fn increase_vol(&self,
user: AudioUser,
auto_unmute: bool)
-> Result<()> {
let old_vol = self.vol()?;
let new_vol = old_vol + (self.scroll_step.get() as f64);
return self.set_vol(new_vol, user, VolDir::Up, auto_unmute);
}
pub fn decrease_vol(&self,
user: AudioUser,
auto_unmute: bool)
-> Result<()> {
let old_vol = self.vol()?;
let new_vol = old_vol - (self.scroll_step.get() as f64);
return self.set_vol(new_vol, user, VolDir::Down, auto_unmute);
}
pub fn has_mute(&self) -> bool {
return self.acard.borrow().has_mute();
}
pub fn get_mute(&self) -> Result<bool> {
return self.acard.borrow().get_mute();
}
pub fn set_mute(&self, mute: bool, user: AudioUser) -> Result<()> {
let mut rc = self.last_action_timestamp.borrow_mut();
*rc = glib::get_monotonic_time();
debug!("Setting mute to {} on card {:?} and chan {:?} by user {:?}",
mute,
self.acard
.borrow()
.card_name()
.unwrap(),
self.acard
.borrow()
.chan_name()
.unwrap(),
user);
self.acard
.borrow()
.set_mute(mute)?;
invoke_handlers(&self.handlers.borrow(),
AudioSignal::ValuesChanged,
user);
return Ok(());
}
pub fn toggle_mute(&self, user: AudioUser) -> Result<()> {
let muted = self.get_mute()?;
return self.set_mute(!muted, user);
}
pub fn connect_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>) {
self.handlers.add_handler(cb);
}
}
fn invoke_handlers(handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
signal: AudioSignal,
user: AudioUser) {
debug!("Invoking handlers for signal {:?} by user {:?}",
signal,
user);
if handlers.is_empty() {
debug!("No handler found");
} else {
debug!("Executing handlers")
}
for handler in handlers {
let unboxed = handler.as_ref();
unboxed(signal, user);
}
}
fn on_alsa_event(last_action_timestamp: &mut i64,
handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
alsa_event: AlsaEvent) {
let last: i64 = *last_action_timestamp;
if last != 0 {
let now: i64 = glib::get_monotonic_time();
let delay: i64 = now - last;
if delay < 1000000 {
return;
}
debug!("Discarding last time stamp, too old");
*last_action_timestamp = 0;
}
/* external change */
match alsa_event {
AlsaEvent::AlsaCardError => {
invoke_handlers(handlers,
self::AudioSignal::CardError,
self::AudioUser::Unknown);
}
AlsaEvent::AlsaCardDiconnected => {
invoke_handlers(handlers,
self::AudioSignal::CardDisconnected,
self::AudioUser::Unknown);
}
AlsaEvent::AlsaCardValuesChanged => {
invoke_handlers(handlers,
self::AudioSignal::ValuesChanged,
self::AudioUser::Unknown);
}
e => warn!("Unhandled alsa event: {:?}", e),
}
}

356
src/audio/alsa/backend.rs Normal file
View File

@ -0,0 +1,356 @@
#![allow(illegal_floating_point_literal_pattern)]
//! Alsa audio backend subsystem.
//!
//! This mod mainly defines the `AlsaBackend` struct.
use alsa_lib::mixer::SelemChannelId::*;
use audio::alsa::card::*;
use audio::frontend::*;
use errors::*;
use glib;
use std::cell::Cell;
use std::cell::RefCell;
use std::rc::Rc;
use support::alsa::*;
use support::audio::*;
/// Alsa implementation of the `AudioFrontend`.
pub struct AlsaBackend {
_cannot_construct: (),
/// The alsa card.
pub acard: RefCell<Box<AlsaCard>>,
/// Last timestamp of an internal action we triggered, e.g.
/// by setting the volume or the mute state.
pub last_action_timestamp: Rc<RefCell<i64>>,
/// A set of handlers that react to audio signals. We can
/// connect to these.
pub handlers: Handlers,
/// The step at which to increase/decrease the volume.
/// This value is basically from the preferences.
pub scroll_step: Cell<u32>,
}
impl AlsaBackend {
/// Creates the `AlsaBackend`, containing an `AlsaCard`
/// and additional information.
pub fn new(
card_name: Option<String>,
elem_name: Option<String>,
) -> Result<AlsaBackend> {
let last_action_timestamp = Rc::new(RefCell::new(0));
let handlers = Handlers::new();
let cb = {
let myhandler = handlers.clone();
let ts = last_action_timestamp.clone();
Rc::new(move |event| {
on_alsa_event(&mut *ts.borrow_mut(), &myhandler.borrow(), event)
})
};
let acard = AlsaCard::new(card_name, elem_name, cb);
if acard.is_err() {
invoke_handlers(
&handlers.borrow(),
AudioSignal::NoCard,
AudioUser::Unknown,
);
} else {
invoke_handlers(
&handlers.borrow(),
AudioSignal::CardInitialized,
AudioUser::Unknown,
);
}
let alsa_backend = AlsaBackend {
_cannot_construct: (),
acard: RefCell::new(acard?),
last_action_timestamp: last_action_timestamp.clone(),
handlers,
scroll_step: Cell::new(5),
};
return Ok(alsa_backend);
}
/// Gets the volume range of the currently selected card configuration.
///
/// # Returns
///
/// `(min, max)`
fn get_volume_range(&self) -> (i64, i64) {
let acard = self.acard.borrow();
let selem = acard.selem();
return selem.get_playback_volume_range();
}
}
impl AudioFrontend for AlsaBackend {
fn switch_card(
&self,
card_name: Option<String>,
elem_name: Option<String>,
user: AudioUser,
) -> Result<()> {
debug!("Switching cards");
debug!("Old card name: {}", self.card_name().unwrap());
debug!("Old chan name: {}", self.chan_name().unwrap());
let cb = self.acard.borrow().cb.clone();
{
let mut ac = self.acard.borrow_mut();
*ac = AlsaCard::new(card_name, elem_name, cb)?;
}
debug!("New card name: {}", self.card_name().unwrap());
debug!("New chan name: {}", self.chan_name().unwrap());
invoke_handlers(
&self.handlers.borrow(),
AudioSignal::CardInitialized,
user,
);
return Ok(());
}
fn card_name(&self) -> Result<String> {
return Ok(self.acard.borrow().card.get_name()?);
}
fn chan_name(&self) -> Result<String> {
let n = self.acard.borrow().selem_id.get_name().map(
|y| String::from(y),
)?;
return Ok(n);
}
fn playable_chan_names(&self) -> Vec<String> {
return get_playable_selem_names(&self.acard.borrow().mixer);
}
fn get_vol(&self) -> Result<f64> {
let acard = self.acard.borrow();
let selem = acard.selem();
let volume = selem.get_playback_volume(FrontRight)?;
return vol_to_percent(volume, self.get_volume_range());
}
fn set_vol(
&self,
new_vol: f64,
user: AudioUser,
dir: VolDir,
auto_unmute: bool,
) -> Result<()> {
{
let mut rc = self.last_action_timestamp.borrow_mut();
*rc = glib::get_monotonic_time();
}
let alsa_vol = percent_to_vol(new_vol, self.get_volume_range(), dir)?;
/* only invoke handlers etc. if volume did actually change */
{
let old_alsa_vol =
percent_to_vol(self.get_vol()?, self.get_volume_range(), dir)?;
if old_alsa_vol == alsa_vol {
return Ok(());
}
}
/* auto-unmute */
if auto_unmute && self.has_mute() && self.get_mute()? {
self.set_mute(false, user)?;
}
debug!(
"Setting vol on card {:?} and chan {:?} to {:?} by user {:?}",
self.card_name().unwrap(),
self.chan_name().unwrap(),
new_vol,
user
);
self.acard.borrow().selem().set_playback_volume_all(
alsa_vol,
)?;
invoke_handlers(
&self.handlers.borrow(),
AudioSignal::ValuesChanged,
user,
);
return Ok(());
}
fn vol_level(&self) -> VolLevel {
let muted = self.get_mute().unwrap_or(false);
if muted {
return VolLevel::Muted;
}
let cur_vol = try_r!(self.get_vol(), VolLevel::Muted);
match cur_vol {
0. => return VolLevel::Off,
0.0...33.0 => return VolLevel::Low,
0.0...66.0 => return VolLevel::Medium,
0.0...100.0 => return VolLevel::High,
_ => return VolLevel::Off,
}
}
fn increase_vol(&self, user: AudioUser, auto_unmute: bool) -> Result<()> {
let old_vol = self.get_vol()?;
let new_vol = old_vol + (self.scroll_step.get() as f64);
return self.set_vol(new_vol, user, VolDir::Up, auto_unmute);
}
fn decrease_vol(&self, user: AudioUser, auto_unmute: bool) -> Result<()> {
let old_vol = self.get_vol()?;
let new_vol = old_vol - (self.scroll_step.get() as f64);
return self.set_vol(new_vol, user, VolDir::Down, auto_unmute);
}
fn has_mute(&self) -> bool {
let acard = self.acard.borrow();
let selem = acard.selem();
return selem.has_playback_switch();
}
fn get_mute(&self) -> Result<bool> {
let acard = self.acard.borrow();
let selem = acard.selem();
let val = selem.get_playback_switch(FrontRight)?;
return Ok(val == 0);
}
fn set_mute(&self, mute: bool, user: AudioUser) -> Result<()> {
let mut rc = self.last_action_timestamp.borrow_mut();
*rc = glib::get_monotonic_time();
debug!(
"Setting mute to {} on card {:?} and chan {:?} by user {:?}",
mute,
self.card_name().unwrap(),
self.chan_name().unwrap(),
user
);
let acard = self.acard.borrow();
let selem = acard.selem();
/* true -> mute, false -> unmute */
let _ = selem.set_playback_switch_all(!mute as i32)?;
invoke_handlers(
&self.handlers.borrow(),
AudioSignal::ValuesChanged,
user,
);
return Ok(());
}
fn toggle_mute(&self, user: AudioUser) -> Result<()> {
let muted = self.get_mute()?;
return self.set_mute(!muted, user);
}
fn connect_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>) {
self.handlers.add_handler(cb);
}
fn set_scroll_step(&self, scroll_step: u32) {
self.scroll_step.set(scroll_step);
}
fn get_scroll_step(&self) -> u32 {
return self.scroll_step.get();
}
}
/// Invokes the registered handlers.
fn invoke_handlers(
handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
signal: AudioSignal,
user: AudioUser,
) {
debug!(
"Invoking handlers for signal {:?} by user {:?}",
signal,
user
);
if handlers.is_empty() {
debug!("No handler found");
} else {
debug!("Executing handlers")
}
for handler in handlers {
let unboxed = handler.as_ref();
unboxed(signal, user);
}
}
/// The callback for alsa events that is passed to the alsa subsystem.
/// This is the bridge between low-level alsa events and "high-level"
/// audio system signals.
fn on_alsa_event(
last_action_timestamp: &mut i64,
handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
alsa_event: AlsaEvent,
) {
let last: i64 = *last_action_timestamp;
if last != 0 {
let now: i64 = glib::get_monotonic_time();
let delay: i64 = now - last;
if delay < 1000000 {
return;
}
debug!("Discarding last time stamp, too old");
*last_action_timestamp = 0;
}
/* external change */
match alsa_event {
AlsaEvent::AlsaCardError => {
invoke_handlers(
handlers,
self::AudioSignal::CardError,
self::AudioUser::Unknown,
);
}
AlsaEvent::AlsaCardDiconnected => {
invoke_handlers(
handlers,
self::AudioSignal::CardDisconnected,
self::AudioUser::Unknown,
);
}
AlsaEvent::AlsaCardValuesChanged => {
invoke_handlers(
handlers,
self::AudioSignal::ValuesChanged,
self::AudioUser::Unknown,
);
}
}
}

182
src/alsa_card.rs → src/audio/alsa/card.rs
View File

@ -5,10 +5,9 @@
//! No other struct should directly interact with the alsa bindings.
use alsa::card::Card;
use alsa::mixer::SelemChannelId::*;
use alsa::mixer::{Mixer, Selem, SelemId};
use alsa::poll::PollDescriptors;
use alsa_lib::card::Card;
use alsa_lib::mixer::{Mixer, Selem, SelemId};
use alsa_lib::poll::PollDescriptors;
use alsa_sys;
use errors::*;
use glib_sys;
@ -20,33 +19,62 @@ use std::mem;
use std::ptr;
use std::rc::Rc;
use std::u8;
use support_alsa::*;
use support::alsa::*;
#[derive(Clone, Copy, Debug)]
/// An "external" alsa card event, potentially triggered by anything.
pub enum AlsaEvent {
/// An error.
AlsaCardError,
/// Alsa card is disconnected.
AlsaCardDiconnected,
/// The values of the mixer changed, including mute state.
AlsaCardValuesChanged,
}
/// A fairly high-level alsa card struct. We save some redundant
/// information in order to access it more easily, in addition to
/// some information that is not purely alsa related (like callbacks).
pub struct AlsaCard {
_cannot_construct: (),
/// The raw alsa card.
pub card: Card,
/// The raw mixer.
pub mixer: Mixer,
/// The simple element ID. `Selem` doesn't implement the Copy trait
/// so we save the ID instead and can get the `Selem` by lookup.
pub selem_id: SelemId,
/// Watch IDs from polling the alsa card. We need them when we
/// drop the card, so we can unregister the polling.
pub watch_ids: Cell<Vec<u32>>,
/// Callback for the various `AlsaEvent`s.
pub cb: Rc<Fn(AlsaEvent)>,
}
impl AlsaCard {
pub fn new(card_name: Option<String>,
/// Create a new alsa card. Tries very hard to get a valid, playable
/// card and mixer, so this is not a 'strict' function.
/// ## `card_name`
/// If a card name is provided, it will be tried. If `None` is provided
/// or the given card name does not exist or is not playable, any other
/// playable card is tried.
/// ## `elem_name`
/// If an elem name is provided, it will be tried. If `None` is provided
/// or the given elem name does not exist or is not playable, any other
/// playable elem is tried.
///
/// # Returns
///
/// `Ok(Box<AlsaCard>)` on success, `Err(error)` otherwise.
pub fn new(
card_name: Option<String>,
elem_name: Option<String>,
cb: Rc<Fn(AlsaEvent)>)
-> Result<Box<AlsaCard>> {
cb: Rc<Fn(AlsaEvent)>,
) -> Result<Box<AlsaCard>> {
let card = {
match card_name {
Some(name) => {
@ -55,7 +83,9 @@ impl AlsaCard {
if alsa_card_has_playable_selem(&default) {
default
} else {
warn!("Default alsa card not playabla, trying others");
warn!(
"Default alsa card not playabla, trying others"
);
get_first_playable_alsa_card()?
}
} else {
@ -63,8 +93,10 @@ impl AlsaCard {
match mycard {
Ok(card) => card,
Err(_) => {
warn!("Card {} not playable, trying others",
name);
warn!(
"Card {} not playable, trying others",
name
);
get_first_playable_alsa_card()?
}
}
@ -76,9 +108,10 @@ impl AlsaCard {
let mixer = get_mixer(&card)?;
let selem_id = {
let requested_selem =
get_playable_selem_by_name(&mixer,
elem_name.unwrap_or(String::from("Master")));
let requested_selem = get_playable_selem_by_name(
&mixer,
elem_name.unwrap_or(String::from("Master")),
);
match requested_selem {
Ok(s) => s.get_id(),
Err(_) => {
@ -92,83 +125,34 @@ impl AlsaCard {
let acard = Box::new(AlsaCard {
_cannot_construct: (),
card: card,
mixer: mixer,
selem_id: selem_id,
card,
mixer,
selem_id,
watch_ids: Cell::new(vec![]),
cb: cb,
cb,
});
let watch_ids = AlsaCard::watch_poll_descriptors(vec_pollfd,
acard.as_ref());
let watch_ids =
AlsaCard::watch_poll_descriptors(vec_pollfd, acard.as_ref());
acard.watch_ids.set(watch_ids);
return Ok(acard);
}
pub fn card_name(&self) -> Result<String> {
return self.card.get_name().from_err();
}
pub fn chan_name(&self) -> Result<String> {
let n = self.selem_id
.get_name()
.map(|y| String::from(y))?;
return Ok(n);
}
/// Get the `Selem`, looked up by the `SelemId`.
pub fn selem(&self) -> Selem {
return self.mixer.find_selem(&self.selem_id).unwrap();
let selem_id = &self.selem_id;
let selem = self.mixer.find_selem(selem_id);
return selem.unwrap();
}
pub fn get_vol(&self) -> Result<i64> {
let selem = self.selem();
let volume = selem.get_playback_volume(FrontRight);
return volume.from_err();
}
pub fn set_vol(&self, new_vol: i64) -> Result<()> {
let selem = self.selem();
return selem.set_playback_volume_all(new_vol).from_err();
}
pub fn get_volume_range(&self) -> (i64, i64) {
let selem = self.selem();
return selem.get_playback_volume_range();
}
pub fn has_mute(&self) -> bool {
let selem = self.selem();
return selem.has_playback_switch();
}
pub fn get_mute(&self) -> Result<bool> {
let selem = self.selem();
let val = selem.get_playback_switch(FrontRight)?;
return Ok(val == 0);
}
pub fn set_mute(&self, mute: bool) -> Result<()> {
let selem = self.selem();
/* true -> mute, false -> unmute */
let _ = selem.set_playback_switch_all(!mute as i32)?;
return Ok(());
}
fn watch_poll_descriptors(polls: Vec<pollfd>,
acard: &AlsaCard)
-> Vec<c_uint> {
/// Watch the given alsa card poll descriptors and
/// return the corresponding watch IDs for saving
/// in the `AlsaCard` struct.
fn watch_poll_descriptors(
polls: Vec<pollfd>,
acard: &AlsaCard,
) -> Vec<c_uint> {
let mut watch_ids: Vec<c_uint> = vec![];
let acard_ptr =
unsafe { mem::transmute::<&AlsaCard, glib_sys::gpointer>(acard) };
@ -192,7 +176,7 @@ impl AlsaCard {
return watch_ids;
}
/// Unwatch the given poll descriptors.
fn unwatch_poll_descriptors(watch_ids: &Vec<u32>) {
for watch_id in watch_ids {
unsafe {
@ -204,19 +188,7 @@ impl AlsaCard {
impl Drop for AlsaCard {
// call Box::new(x), transmute the Box into a raw pointer, and then
// std::mem::forget
//
// if you unregister the callback, you should keep a raw pointer to the
// box
//
// For instance, `register` could return a raw pointer to the
// Box + a std::marker::PhantomData with the appropriate
// lifetime (if applicable)
//
// The struct could implement Drop, which unregisters the
// callback and frees the Box, by simply transmuting the
// raw pointer to a Box<T>
/// Destructs the watch IDs corresponding to the current poll descriptors.
fn drop(&mut self) {
debug!("Destructing watch_ids: {:?}", self.watch_ids.get_mut());
AlsaCard::unwatch_poll_descriptors(&self.watch_ids.get_mut());
@ -224,10 +196,12 @@ impl Drop for AlsaCard {
}
extern "C" fn watch_cb(chan: *mut glib_sys::GIOChannel,
/// The C callback function registered in `watch_poll_descriptors()`.
extern "C" fn watch_cb(
chan: *mut glib_sys::GIOChannel,
cond: glib_sys::GIOCondition,
data: glib_sys::gpointer)
-> glib_sys::gboolean {
data: glib_sys::gpointer,
) -> glib_sys::gboolean {
let acard =
unsafe { mem::transmute::<glib_sys::gpointer, &AlsaCard>(data) };
@ -247,18 +221,18 @@ extern "C" fn watch_cb(chan: *mut glib_sys::GIOChannel,
let mut buf: Vec<u8> = vec![0; 256];
while sread > 0 {
let stat: glib_sys::GIOStatus =
unsafe {
glib_sys::g_io_channel_read_chars(chan,
let stat: glib_sys::GIOStatus = unsafe {
glib_sys::g_io_channel_read_chars(
chan,
buf.as_mut_ptr() as *mut u8,
256,
&mut sread as *mut size_t,
ptr::null_mut())
ptr::null_mut(),
)
};
match stat {
glib_sys::G_IO_STATUS_AGAIN => {
debug!("G_IO_STATUS_AGAIN");
continue;
}
glib_sys::G_IO_STATUS_NORMAL => {
@ -270,7 +244,9 @@ extern "C" fn watch_cb(chan: *mut glib_sys::GIOChannel,
error!("GIO error has occurred");
cb(AlsaEvent::AlsaCardError);
}
_ => warn!("Unknown status from g_io_channel_read_chars()"),
_ => {
error!("Internal error: unknown status!");
},
}
return true as glib_sys::gboolean;
}

4
src/audio/alsa/mod.rs Normal file
View File

@ -0,0 +1,4 @@
//! The alsa backend subsystem.
pub mod backend;
pub mod card;

167
src/audio/frontend.rs Normal file
View File

@ -0,0 +1,167 @@
#![allow(missing_docs)] // enums
//! High-level audio subsystem.
//!
//! This is the middleman between the low-level audio backend (alsa),
//! and the high-level ui code.
//! This abstraction layer allows the high-level code to be completely unaware
//! of the underlying audio implementation, may it be alsa or whatever.
use errors::*;
use std::cell::Ref;
use std::cell::RefCell;
use std::f64;
use std::rc::Rc;
use support::audio::*;
#[derive(Clone, Copy, Debug)]
/// The volume level of the current audio configuration.
pub enum VolLevel {
Muted,
Low,
Medium,
High,
Off,
}
/// An audio user, used to determine from where a signal originated.
#[derive(Clone, Copy, Debug)]
pub enum AudioUser {
Unknown,
Popup,
TrayIcon,
Hotkeys,
PrefsWindow,
}
/// An audio signal. This will be used to connect callbacks to the
/// audio system and react appropriately.
#[derive(Clone, Copy, Debug)]
pub enum AudioSignal {
NoCard,
CardInitialized,
CardCleanedUp,
CardDisconnected,
CardError,
ValuesChanged,
}
#[derive(Clone)]
/// Convenience struct to make handling this madness easier.
pub struct Handlers {
inner: Rc<RefCell<Vec<Box<Fn(AudioSignal, AudioUser)>>>>,
}
impl Handlers {
pub fn new() -> Handlers {
return Handlers { inner: Rc::new(RefCell::new(vec![])) };
}
pub fn borrow(&self) -> Ref<Vec<Box<Fn(AudioSignal, AudioUser)>>> {
return self.inner.borrow();
}
pub fn add_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>) {
self.inner.borrow_mut().push(cb);
}
}
/// This is the audio frontend, which can be implemented by different backends,
/// e.g. Alsa or PulseAudio. The high-level UI code only calls these
/// functions, never the underlying backend functions. The backend
/// implementation must ensure proper state and consistency, especially
/// wrt handlers and switching the card.
pub trait AudioFrontend {
/// Switches the current card. Must invoke handlers.
/// ## `user`
/// Where the card switch originates from.
fn switch_card(
&self,
card_name: Option<String>,
elem_name: Option<String>,
user: AudioUser,
) -> Result<()>;
/// Current volume. Between 0 and 100.
/// This always gets the volume of the `FrontRight` channel, because that
/// seems to be the safest bet.
fn get_vol(&self) -> Result<f64>;
/// Set the current volume. Must invoke handlers.
/// ## `new_vol`
/// Set the volume to this value. From 0 to 100.
/// ## `user`
/// Where the card switch originates from.
/// ## `dir`
/// The "direction" of the volume change, e.g. is it a decrease
/// or increase. This helps with rounding problems.
/// ## `auto_unmute`
/// Whether to automatically unmute if the volume changes.
fn set_vol(
&self,
new_vol: f64,
user: AudioUser,
dir: VolDir,
auto_unmute: bool,
) -> Result<()>;
/// Current volume level, nicely usable for e.g. selecting from a set
/// of images.
fn vol_level(&self) -> VolLevel;
/// Increase the volume. The step to increasy by is taken from
/// `self.scroll_step`.
/// ## `user`
/// Where the card switch originates from.
fn increase_vol(&self, user: AudioUser, auto_unmute: bool) -> Result<()>;
/// Decrease the volume. The step to decrease by is taken from
/// `self.scroll_step`.
/// ## `user`
/// Where the card switch originates from.
fn decrease_vol(&self, user: AudioUser, auto_unmute: bool) -> Result<()>;
/// Whether the current audio configuration can be muted.
fn has_mute(&self) -> bool;
/// Get the mute state of the current audio configuration.
fn get_mute(&self) -> Result<bool>;
/// Set the mute state of the current audio configuration.
/// Must invoke handlers.
fn set_mute(&self, mute: bool, user: AudioUser) -> Result<()>;
/// Toggle the mute state of the current audio configuration.
fn toggle_mute(&self, user: AudioUser) -> Result<()>;
/// Connect a signal handler to the audio subsystem. This can
/// be done from anywhere, e.g. in the UI code to react to
/// certain signals. Multiple handlers for the same signals are fine,
/// they will be executed in order.
fn connect_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>);
/// Get the current card name.
fn card_name(&self) -> Result<String>;
/// Get the currently playable channel names.
fn playable_chan_names(&self) -> Vec<String>;
/// Get the current active channel name.
fn chan_name(&self) -> Result<String>;
/// Set the scroll step.
fn set_scroll_step(&self, scroll_step: u32);
/// Get the scroll step.
fn get_scroll_step(&self) -> u32;
}

4
src/audio/mod.rs Normal file
View File

@ -0,0 +1,4 @@
//! The audio subsystem with its frontend and backends.
pub mod alsa;
pub mod frontend;

74
src/bin.rs
View File

@ -1,34 +1,78 @@
#![feature(alloc_system)]
extern crate alloc_system;
extern crate getopts;
extern crate pnmixerlib;
use pnmixerlib::*;
use app_state::*;
#[cfg(feature = "notify")]
use libnotify::*;
use getopts::Options;
use std::rc::Rc;
use std::env;
fn main() {
gtk::init().unwrap();
let args: Vec<String> = env::args().collect();
// TODO: error handling
#[cfg(feature = "notify")]
init("PNMixer-rs").unwrap();
let mut opts = Options::new();
opts.optflag("h", "help", "Show help");
opts.optopt("", "log-to-file",
"Log files to the specified dir instead of stderr",
"DIRECTORY");
opts.optflagopt("l", "log-level",
"Set the log level (trace/debug/info/warn/error/off)",
"LEVEL");
flexi_logger::LogOptions::new()
.log_to_file(false)
// ... your configuration options go here ...
.init(Some("pnmixer=debug".to_string()))
.unwrap_or_else(|e| panic!("Logger initialization failed with {}", e));
let matches = match opts.parse(&args[1..]) {
Ok(m) => { m }
Err(f) => { panic!(f.to_string()) }
};
let apps = Rc::new(AppS::new());
if matches.opt_present("h") {
print_usage(opts);
return;
}
ui_entry::init(apps);
let log_dir = matches.opt_str("log-to-file");
let log_level = matches.opt_default("log-level", "debug").map(|s| {
match s.to_lowercase().as_str() {
"trace" => flexi_logger::LevelFilter::Trace,
"debug" => flexi_logger::LevelFilter::Debug,
"info" => flexi_logger::LevelFilter::Info,
"warn" => flexi_logger::LevelFilter::Warn,
"error" => flexi_logger::LevelFilter::Error,
"off" => flexi_logger::LevelFilter::Off,
_ => flexi_logger::LevelFilter::Debug,
}
}).unwrap_or(flexi_logger::LevelFilter::Off);
let mut flogger = flexi_logger::Logger::with(
flexi_logger::LogSpecification::default(log_level).build());
if let Some(dir) = log_dir {
flogger = flogger.log_to_file().directory(dir);
}
flogger
.start()
.unwrap_or_else(|e|{panic!("Logger initialization failed with {}",e)});
gtk::init()
.unwrap_or_else(|e| panic!("Gtk initialization failed with {}", e));
let apps = Rc::new(new_alsa_appstate());
ui::entry::init(apps);
gtk::main();
#[cfg(feature = "notify")]
uninit();
// TODO: clean deallocation?
}
fn print_usage(opts: Options) {
let brief = format!("Usage: pnmixer-rs [options]");
print!("{}", opts.usage(&brief));
}

161
src/errors.rs
View File

@ -1,4 +1,6 @@
use alsa;
#![allow(missing_docs)]
use alsa_lib;
use glib;
use png;
use std::convert::From;
@ -9,10 +11,18 @@ use toml;
error_chain! {
foreign_links {
Alsa(alsa::Error);
Alsa(alsa_lib::Error);
IO(std::io::Error);
Toml(toml::de::Error);
Png(png::DecodingError);
GlibError(glib::Error);
}
errors {
GtkResponseCancel(t: String) {
description("User hit cancel")
display("User hit cancel: {}", t)
}
}
}
@ -20,6 +30,8 @@ error_chain! {
#[macro_export]
/// Try to unwrap a `Result<T, E>`. If there is a value `T`, yield it,
/// otherwise print a warning and `return ()` from the function.
macro_rules! try_w {
($expr:expr) => {
try_wr!($expr, ())
@ -34,6 +46,8 @@ macro_rules! try_w {
#[macro_export]
/// Try to unwrap a `Result<T, E>`. If there is a value `T`, yield it,
/// otherwise print a warning and return from the function with the given value.
macro_rules! try_wr {
($expr:expr, $ret:expr) => (match $expr {
::std::result::Result::Ok(val) => val,
@ -62,6 +76,8 @@ macro_rules! try_wr {
#[macro_export]
/// Try to unwrap a `Result<T, E>`. If there is a value `T`, yield it,
/// otherwise return from the function with the given value.
macro_rules! try_r {
($expr:expr, $ret:expr) => (match $expr {
::std::result::Result::Ok(val) => val,
@ -72,31 +88,18 @@ macro_rules! try_r {
}
#[macro_export]
/// Try to unwrap a `Result<T, E>`. If there is a value `T`, yield it,
/// otherwise print an error and exit the program.
macro_rules! try_e {
($expr:expr) => {
try_er!($expr, ())
};
($expr:expr, $fmt:expr, $($arg:tt)+) => {
try_er!($expr, (), $fmt, $(arg)+)
};
($expr:expr, $fmt:expr) => {
try_er!($expr, (), $fmt)
}
}
#[macro_export]
macro_rules! try_er {
($expr:expr, $ret:expr) => (match $expr {
($expr:expr) => (match $expr {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => {
error!("{:?}", err);
::std::process::exit(1);
},
});
($expr:expr, $ret:expr, $fmt:expr) => (match $expr {
($expr:expr, $fmt:expr) => (match $expr {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => {
error!("Original error: {:?}", err);
@ -104,7 +107,7 @@ macro_rules! try_er {
std::process::exit(1);
},
});
($expr:expr, $ret:expr, $fmt:expr, $($arg:tt)+) => (match $expr {
($expr:expr, $fmt:expr, $($arg:tt)+) => (match $expr {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => {
error!("Original error: {:?}", err);
@ -113,3 +116,121 @@ macro_rules! try_er {
},
})
}
#[macro_export]
/// Unwraps a `Result<T, E>` by yielding a value of the samet ype
/// for either case.
macro_rules! unwrap_any {
($expr:expr, $fmt_ok:expr, $fmt_err:expr) => (match $expr {
::std::result::Result::Ok(val) => $fmt_ok,
::std::result::Result::Err(err) => $fmt_err,
})
}
#[macro_export]
/// Warns on err and yields `()` without returning the function.
macro_rules! just_warn {
($expr:expr) => (match $expr {
::std::result::Result::Ok(_) => (),
::std::result::Result::Err(err) => {
warn!("{:?}", err);
()
},
});
}
#[macro_export]
/// Present a gtk error dialog with given message.
/// Provides only a close button.
macro_rules! error_dialog {
($msg:expr, $parent:expr) => {
{
use gtk::DialogExt;
use gtk::prelude::GtkWindowExt;
use gtk::WidgetExt;
let parent: Option<&gtk::Window> = $parent;
let dialog = gtk::MessageDialog::new(parent,
gtk::DialogFlags::DESTROY_WITH_PARENT,
gtk::MessageType::Error,
gtk::ButtonsType::Close,
$msg);
dialog.set_title("PNMixer-rs Error");
dialog.run();
dialog.destroy();
}
};
}
#[macro_export]
/// Present a gtk error dialog with the error from the `Result` type,
/// if any.
/// Provides only a close button.
macro_rules! result_warn {
($expr:expr, $parent:expr) => (match $expr {
::std::result::Result::Ok(v) => Ok(v),
::std::result::Result::Err(err) => {
use std::error::Error;
let warn_string = format!("{}{}", err.description(),
err.cause().map(|e| format!("\n\nCause: {}", e.description())).unwrap_or(String::from("")));
warn!("{}", warn_string);
error_dialog!(warn_string.as_str(), $parent);
Err(err)
},
});
}
#[macro_export]
/// Convert `WResult` to `Result`. All warnings are printed via the `log`
/// crate and are shown via Gtk dialogs.
macro_rules! wresult_warn {
($expr:expr, $parent:expr) => (match $expr {
::w_result::WResult::WOk(t, ws) => {
use std::error::Error;
for w in ws {
let warn_string = format!("{}{}", w.description(),
w.cause().map(|e| format!("\n\nCause: {}", e.description())).unwrap_or(String::from("")));
warn!("{}", warn_string);
error_dialog!(warn_string.as_str(), $parent);
}
Ok(t)
},
::w_result::WResult::WErr(err) => Err(err),
});
}
#[macro_export]
/// If there is an error in the expression, push it to
/// the given mutable warning vector.
macro_rules! push_warning {
($expr:expr, $vec:ident) => (match $expr {
Err(e) => $vec.push(e),
_ => ()
});
}
#[macro_export]
/// If there is a value in the Result type, unwrap it, otherwise error-log
/// the error, show it via gtk dialog and exit the whole program.
macro_rules! unwrap_error {
($expr:expr, $parent:expr) => (match $expr {
::std::result::Result::Ok(v) => v,
::std::result::Result::Err(err) => {
use std::error::Error;
let err_string = format!("{}{}", err.description(),
err.cause().map(|e| format!("\n\nCause: {}", e.description())).unwrap_or(String::from("")));
error!("{}", err_string);
error_dialog!(err_string.as_str(), $parent);
::std::process::exit(1);
},
});
}

189
src/hotkey.rs Normal file
View File

@ -0,0 +1,189 @@
//! The hotkey subsystem.
//!
//! This file defines what's a hotkey and deals with the low-level XKBlib and
//! Gtk/Gdk.
use errors::*;
use gdk;
use gdk_sys;
use gtk;
use libc::c_int;
use libc::c_uint;
use support::gdk_x11::*;
use x11;
/// `xmodmap -pm`
/// List of key modifiers which will be ignored whenever
/// we check whether the defined hotkeys have been pressed.
lazy_static! {
static ref KEY_MASKS: Vec<c_uint> = vec![
gdk_sys::GdkModifierType::empty().bits(), // No Modkey
gdk_sys::GDK_MOD2_MASK.bits(), // Numlock
gdk_sys::GDK_LOCK_MASK.bits(), // Capslock
gdk_sys::GDK_MOD2_MASK.bits() | gdk_sys::GDK_LOCK_MASK.bits(),
];
}
#[derive(Debug)]
/// A hotkey, described by the underlying gdk/X11 representation.
pub struct Hotkey {
/// The hardware keycode.
pub code: gdk::key,
/// The modifier keys and mouse button that have been pressed
/// in addition to the main key (e.g. Numlock/Capslock).
/// This is the raw bit representation and can be converted to
/// `gtk::ModifierType` via `self.mods()`.
pub mod_bits: u32, // Makes serialize/deserialize easier
/// X key symbol.
pub sym: u64,
/// Gtk Accelerator string.
pub gtk_accel: String,
}
impl Hotkey {
/// Creates a new hotkey and grabs it.
pub fn new(code: gdk::key, mods: gdk::ModifierType) -> Result<Hotkey> {
let display = gdk_x11_get_default_xdisplay();
let mod_bits = mods.bits();
let sym =
unsafe { x11::xlib::XkbKeycodeToKeysym(display, code as u8, 0, 0) };
let gtk_accel = gtk::accelerator_name(sym as u32, mods).ok_or(
"Could net get accelerator name",
)?;
let hotkey = Hotkey {
code,
mod_bits,
sym,
gtk_accel,
};
hotkey.grab()?;
return Ok(hotkey);
}
/// Creates a new hotkey from an accelerator string and grabs it.
pub fn new_from_accel(accel: &str) -> Result<Hotkey> {
let (code, mods) = hotkey_accel_to_code(accel);
return Hotkey::new(code, mods);
}
/// Grab a key manually. Should be paired with a ungrab() call.
pub fn grab(&self) -> Result<()> {
let display = gdk_x11_get_default_xdisplay();
/* Init error handling */
let old_hdlr = unsafe {
GRAB_ERROR = 0;
x11::xlib::XSetErrorHandler(Some(grab_error_handler))
};
/* Grab the key */
for key in KEY_MASKS.iter() {
unsafe {
x11::xlib::XGrabKey(
display,
self.code,
self.mod_bits | key,
gdk_x11_get_default_root_xwindow(),
1,
x11::xlib::GrabModeAsync,
x11::xlib::GrabModeAsync,
);
}
}
/* Synchronize X */
unsafe {
x11::xlib::XFlush(display);
x11::xlib::XSync(display, false as c_int);
}
/* Restore error handler */
unsafe {
x11::xlib::XSetErrorHandler(old_hdlr);
}
/* Check for error */
unsafe {
ensure!(GRAB_ERROR == 0, "Error grabbing");
}
return Ok(());
}
/// Ungrab a key manually. Should be paired with a grab() call.
pub fn ungrab(&self) {
let display = gdk_x11_get_default_xdisplay();
for key in KEY_MASKS.iter() {
unsafe {
x11::xlib::XUngrabKey(
display,
self.code,
self.mod_bits | key,
gdk_x11_get_default_root_xwindow(),
);
}
}
}
/// Checks if the keycode we got (minus modifiers like
/// numlock/capslock) matches the hotkey.
/// Thus numlock + o will match o.
pub fn matches(&self, code: gdk::key, mods: gdk::ModifierType) -> bool {
if code != self.code {
return false;
}
for key in KEY_MASKS.iter() {
if (self.mod_bits | key) == mods.bits() {
return true;
}
}
return false;
}
}
impl Drop for Hotkey {
fn drop(&mut self) {
debug!("Ungrabbing hotkey");
self.ungrab();
}
}
/// Translate a Gtk Accelerator string to a key code and mods.
pub fn hotkey_accel_to_code(accel: &str) -> (gdk::key, gdk::ModifierType) {
let display = gdk_x11_get_default_xdisplay();
let (sym, mods) = gtk::accelerator_parse(accel);
unsafe {
if sym != 0 {
return (
x11::xlib::XKeysymToKeycode(display, sym as u64) as i32,
mods,
);
} else {
return (-1, mods);
}
}
}
static mut GRAB_ERROR: u8 = 0;
extern "C" fn grab_error_handler(
_: *mut x11::xlib::Display,
_: *mut x11::xlib::XErrorEvent,
) -> c_int {
warn!("Error while grabbing hotkey");
unsafe {
GRAB_ERROR = 1;
}
return 0;
}

301
src/hotkeys.rs Normal file
View File

@ -0,0 +1,301 @@
//! The hotkeys subsystem.
//!
//! This handles the PNMixer-rs specific hotkeys as a whole,
//! including communication with Xlib and intercepting key presses
//! before they can be interpreted by Gtk/Gdk.
use audio::frontend::*;
use errors::*;
use errors;
use gdk;
use gdk_sys;
use glib::translate::*;
use glib_sys;
use hotkey::*;
use prefs::*;
use std::mem;
use std::rc::Rc;
use support::gdk_x11;
use w_result::*;
use x11;
/// The possible Hotkeys for manipulating the volume.
pub struct Hotkeys<T>
where
T: AudioFrontend,
{
enabled: bool,
mute_key: Option<Hotkey>,
up_key: Option<Hotkey>,
down_key: Option<Hotkey>,
// need this to access audio in 'key_filter'
audio: Rc<T>,
auto_unmute: bool,
}
impl<T> Hotkeys<T>
where
T: AudioFrontend,
{
/// Creates the hotkeys subsystem and binds the hotkeys.
pub fn new(
prefs: &Prefs,
audio: Rc<T>,
) -> WResult<Box<Hotkeys<T>>, errors::Error, errors::Error> {
debug!("Creating hotkeys control");
let mut hotkeys = Box::new(Hotkeys {
enabled: false,
mute_key: None,
up_key: None,
down_key: None,
audio: audio,
auto_unmute: prefs.behavior_prefs.unmute_on_vol_change,
});
let mut warn = vec![];
push_warning!(hotkeys.reload(prefs), warn);
/* bind hotkeys */
let data_ptr = unsafe {
mem::transmute::<&Hotkeys<T>, glib_sys::gpointer>(hotkeys.as_ref())
};
hotkeys_add_filter(Some(key_filter::<T>), data_ptr);
return WOk(hotkeys, warn);
}
/// Reload the Hotkeys from the preferences.
/// If hotkeys are disabled, just sets all members to `None`.
/// This has to be called each time the preferences are modified.
///
/// # Returns
///
/// `Ok(())` on success, otherwise `Err(str)` if some of the hotkeys
/// could not be grabbed, where `str` is a String that can be
/// presented via e.g. `run_error_dialog()`.
pub fn reload(&mut self, prefs: &Prefs) -> Result<()> {
self.enabled = prefs.hotkey_prefs.enable_hotkeys;
self.mute_key = None;
self.up_key = None;
self.down_key = None;
/* Return if hotkeys are disabled */
if self.enabled == false {
return Ok(());
}
let hotkey_prefs = &prefs.hotkey_prefs;
let new_hotkey = |keyname: &Option<String>| -> (Option<Hotkey>, bool) {
match keyname {
&Some(ref k) => {
let hotkey = Hotkey::new_from_accel(k.as_str());
if hotkey.as_ref().is_err() {
(None, true)
} else {
(Some(hotkey.unwrap()), false)
}
}
&None => (None, false), // no actual error, just no key
}
};
/* Setup mute hotkey */
let (m_unmute_key, mute_err) =
new_hotkey(&hotkey_prefs.mute_unmute_key);
if let Some(key) = m_unmute_key {
self.mute_key = Some(key);
}
/* Setup volume uphotkey */
let (m_up_key, up_err) = new_hotkey(&hotkey_prefs.vol_up_key);
if let Some(key) = m_up_key {
self.up_key = Some(key);
}
/* Setup volume down hotkey */
let (m_down_key, down_err) = new_hotkey(&hotkey_prefs.vol_down_key);
if let Some(key) = m_down_key {
self.down_key = Some(key);
}
if mute_err || up_err || down_err {
bail!("Could not grab the following hotkeys:\n{}{}{}",
if mute_err { "(Mute/Unmute)\n" } else { "" },
if up_err { "(Volume Up)\n" } else { "" },
if down_err { "(Volume Down)\n" } else { "" },
);
}
return Ok(());
}
/// Bind hotkeys manually. Should be paired with an `unbind()` call.
pub fn bind(&self) {
debug!("Bind hotkeys");
if let Some(ref key) = self.mute_key {
if key.grab().is_err() {
warn!("Could not grab mute key");
}
}
if let Some(ref key) = self.up_key {
if key.grab().is_err() {
warn!("Could not grab mute key");
}
}
if let Some(ref key) = self.down_key {
if key.grab().is_err() {
warn!("Could not grab mute key");
}
}
let data_ptr =
unsafe { mem::transmute::<&Hotkeys<T>, glib_sys::gpointer>(self) };
hotkeys_add_filter(Some(key_filter::<T>), data_ptr);
}
/// Unbind hotkeys manually. Should be paired with a `bind()` call.
pub fn unbind(&self) {
debug!("Unbind hotkeys");
if let Some(ref key) = self.mute_key {
key.ungrab();
}
if let Some(ref key) = self.up_key {
key.ungrab();
}
if let Some(ref key) = self.down_key {
key.ungrab();
}
let data_ptr =
unsafe { mem::transmute::<&Hotkeys<T>, glib_sys::gpointer>(self) };
hotkeys_remove_filter(Some(key_filter::<T>), data_ptr);
}
}
impl<T> Drop for Hotkeys<T>
where
T: AudioFrontend,
{
fn drop(&mut self) {
debug!("Freeing hotkeys");
self.mute_key = None;
self.up_key = None;
self.down_key = None;
let data_ptr = unsafe {
mem::transmute::<&mut Hotkeys<T>, glib_sys::gpointer>(self)
};
hotkeys_remove_filter(Some(key_filter::<T>), data_ptr)
}
}
/// Attaches the `key_filter()` function as a filter
/// to the root window, so it will intercept window events.
fn hotkeys_add_filter(
function: gdk_sys::GdkFilterFunc,
data: glib_sys::gpointer,
) {
// TODO: all the unwrapping :/
let window = gdk_x11::gdk_x11_window_foreign_new_for_display(
&mut gdk::Display::get_default().unwrap(),
gdk_x11::gdk_x11_get_default_root_xwindow(),
).unwrap();
unsafe {
gdk_sys::gdk_window_add_filter(window.to_glib_none().0, function, data);
}
}
/// Removes the previously attached `key_filter()` function from
/// the root window.
fn hotkeys_remove_filter(
function: gdk_sys::GdkFilterFunc,
data: glib_sys::gpointer,
) {
// TODO: all the unwrapping :/
let window = gdk_x11::gdk_x11_window_foreign_new_for_display(
&mut gdk::Display::get_default().unwrap(),
gdk_x11::gdk_x11_get_default_root_xwindow(),
).unwrap();
unsafe {
gdk_sys::gdk_window_remove_filter(
window.to_glib_none().0,
function,
data,
);
}
}
/// This function is called before Gtk/Gdk can respond
/// to any(!) window event and handles pressed hotkeys.
extern "C" fn key_filter<T>(
gdk_xevent: *mut gdk_sys::GdkXEvent,
_: *mut gdk_sys::GdkEvent,
data: glib_sys::gpointer,
) -> gdk_sys::GdkFilterReturn
where
T: AudioFrontend,
{
let xevent = gdk_xevent as *mut x11::xlib::XKeyEvent;
let hotkeys: &Hotkeys<T> =
unsafe { mem::transmute::<glib_sys::gpointer, &Hotkeys<T>>(data) };
let mute_key = &hotkeys.mute_key;
let up_key = &hotkeys.up_key;
let down_key = &hotkeys.down_key;
let audio = &hotkeys.audio;
let xevent_type = unsafe { (*xevent).type_ };
if xevent_type == x11::xlib::KeyPress {
return gdk_sys::GDK_FILTER_CONTINUE;
}
let xevent_key = unsafe { (*xevent).keycode };
let xevent_state = unsafe { (*xevent).state };
if mute_key.as_ref().is_some() &&
mute_key.as_ref().unwrap().matches(
xevent_key as i32,
gdk::ModifierType::from_bits(xevent_state)
.unwrap(),
)
{
just_warn!(audio.toggle_mute(AudioUser::Hotkeys));
} else if up_key.as_ref().is_some() &&
up_key.as_ref().unwrap().matches(
xevent_key as i32,
gdk::ModifierType::from_bits(
xevent_state,
).unwrap(),
)
{
just_warn!(audio.increase_vol(AudioUser::Hotkeys, hotkeys.auto_unmute));
} else if down_key.as_ref().is_some() &&
down_key.as_ref().unwrap().matches(
xevent_key as i32,
gdk::ModifierType::from_bits(
xevent_state,
).unwrap(),
)
{
just_warn!(audio.decrease_vol(AudioUser::Hotkeys, hotkeys.auto_unmute));
}
return gdk_sys::GDK_FILTER_CONTINUE;
}

97
src/lib.rs
View File

@ -1,60 +1,87 @@
//! PNMixer-rs is a mixer for the system tray.
//!
//! # Design Overview
//!
//! The lowest level part of the code is the sound backend. Only Alsa is supported
//! at the moment, but more backends may be added in the future.
//!
//! The backend is hidden behind a frontend, defined in `audio.rs`. Only `audio.rs`
//! deals with audio backends. This means that the whole of the code is blissfully
//! ignorant of the audio backend in use.
//!
//! `audio.rs` is also in charge of emitting signals whenever a change happens.
//! This means that PNMixer-rs design is quite signal-oriented, so to say.
//!
//! The ui code is nothing fancy. Each ui element...
//!
//! * is defined in a single file
//! * strives to be standalone
//! * accesses the sound system with function calls
//! * listens to signals from the audio subsystem to update its appearance
//!
//! There's something you should keep in mind. Audio on a computer is a shared
//! resource. PNMixer-rs isn't the only one that can change it. At any moment the
//! audio volume may be modified by someone else, and we must update the ui
//! accordingly. So listening to changes from the audio subsystem (and therefore
//! having a signal-oriented design) is the most obvious solution to solve that
//! problem.
#![warn(missing_docs)]
#![feature(alloc_system)]
extern crate alloc_system;
pub extern crate flexi_logger;
#[macro_use]
pub extern crate log;
extern crate log;
#[macro_use]
pub extern crate error_chain;
extern crate error_chain;
#[macro_use]
pub extern crate serde_derive;
pub extern crate toml;
pub extern crate serde;
extern crate serde_derive;
extern crate toml;
extern crate serde;
pub extern crate alsa;
pub extern crate alsa_sys;
pub extern crate ffi;
pub extern crate gdk;
pub extern crate gdk_pixbuf;
pub extern crate gdk_pixbuf_sys;
pub extern crate gdk_sys;
pub extern crate gio;
pub extern crate glib;
pub extern crate glib_sys;
pub extern crate gobject_sys;
extern crate alsa as alsa_lib;
extern crate alsa_sys;
extern crate ffi;
extern crate gdk;
extern crate gdk_pixbuf;
extern crate gdk_pixbuf_sys;
extern crate gdk_sys;
extern crate gio;
extern crate glib;
extern crate glib_sys;
extern crate gobject_sys;
pub extern crate gtk;
pub extern crate gtk_sys;
pub extern crate libc;
pub extern crate png;
pub extern crate which;
pub extern crate xdg;
extern crate gtk_sys;
extern crate libc;
extern crate png;
extern crate w_result;
extern crate which;
extern crate x11;
extern crate xdg;
#[cfg(feature = "notify")]
pub extern crate libnotify;
#[macro_use]
extern crate lazy_static;
#[macro_use]
pub mod errors;
#[macro_use]
pub mod glade_helpers;
pub mod alsa_card;
pub mod app_state;
pub mod audio;
pub mod hotkey;
pub mod hotkeys;
pub mod prefs;
pub mod support_alsa;
pub mod support_audio;
pub mod support_cmd;
#[macro_use]
pub mod support_ui;
pub mod ui_entry;
pub mod ui_popup_menu;
pub mod ui_popup_window;
pub mod ui_prefs_dialog;
pub mod ui_tray_icon;
pub mod support;
#[macro_use]
pub mod ui;
#[cfg(feature = "notify")]
pub mod notif;

127
src/notif.rs
View File

@ -1,36 +1,27 @@
//! The notification subsystem.
//!
//! This subsystem utilizes libnotify to send notifications as popups
//! to the desktop.
use app_state::*;
use audio::*;
use audio::frontend::*;
use errors::*;
use glib::Variant;
use glib::prelude::*;
use gtk::DialogExt;
use gtk::MessageDialogExt;
use gtk::WidgetExt;
use gtk::WindowExt;
use gtk;
use gtk_sys::{GTK_DIALOG_DESTROY_WITH_PARENT, GTK_RESPONSE_YES};
use libnotify;
use prefs::*;
use std::cell::Cell;
use std::cell::RefCell;
use std::rc::Rc;
use std::thread;
use std::time::Duration;
use support_audio::*;
use support_ui::*;
use ui_popup_menu::*;
use ui_popup_window::*;
use ui_prefs_dialog::*;
use ui_tray_icon::*;
/// An expression of our notification system. Holds all the relevant information
/// needed by Gtk+ callbacks to interact with libnotify.
pub struct Notif {
enabled: Cell<bool>,
from_popup: Cell<bool>,
from_tray: Cell<bool>,
// TODO: from hotkey
from_hotkeys: Cell<bool>,
from_external: Cell<bool>,
volume_notif: libnotify::Notification,
@ -38,44 +29,59 @@ pub struct Notif {
}
impl Notif {
/// Create a new notification instance from the current preferences.
/// This should only be done once at startup. This also initializes
/// the libnotify system.
pub fn new(prefs: &Prefs) -> Result<Self> {
libnotify::init("PNMixer-rs")?;
let notif = Notif {
enabled: Cell::new(false),
from_popup: Cell::new(false),
from_tray: Cell::new(false),
from_hotkeys: Cell::new(false),
from_external: Cell::new(false),
volume_notif: libnotify::Notification::new("", None, None),
text_notif: libnotify::Notification::new("", None, None),
};
notif.reload(prefs)?;
notif.reload(prefs);
return Ok(notif);
}
pub fn reload(&self, prefs: &Prefs) -> Result<()> {
/// Reload the notification instance from the current
/// preferences.
pub fn reload(&self, prefs: &Prefs) {
let timeout = prefs.notify_prefs.notifcation_timeout;
self.enabled.set(prefs.notify_prefs.enable_notifications);
self.from_popup.set(prefs.notify_prefs.notify_popup);
self.from_tray.set(prefs.notify_prefs.notify_mouse_scroll);
self.from_hotkeys.set(prefs.notify_prefs.notify_hotkeys);
self.from_external.set(prefs.notify_prefs.notify_external);
self.volume_notif.set_timeout(timeout as i32);
self.volume_notif.set_hint("x-canonical-private-synchronous",
Some("".to_variant()));
self.volume_notif.set_hint(
"x-canonical-private-synchronous",
Some("".to_variant()),
);
self.text_notif.set_timeout(timeout as i32);
self.text_notif.set_hint("x-canonical-private-synchronous",
Some("".to_variant()));
return Ok(());
self.text_notif.set_hint(
"x-canonical-private-synchronous",
Some("".to_variant()),
);
}
pub fn show_volume_notif(&self, audio: &Audio) -> Result<()> {
let vol = audio.vol()?;
/// Shows a volume notification, e.g. for volume or mute state change.
pub fn show_volume_notif<T>(&self, audio: &T) -> Result<()>
where
T: AudioFrontend,
{
let vol = audio.get_vol()?;
let vol_level = audio.vol_level();
let icon = {
@ -92,69 +98,80 @@ impl Notif {
match vol_level {
VolLevel::Muted => String::from("Volume muted"),
_ => {
format!("{} ({})\nVolume: {}",
audio.acard
.borrow()
.card_name()?,
audio.acard
.borrow()
.chan_name()?,
vol as i32)
format!(
"{} ({})\nVolume: {}",
audio.card_name()?,
audio.chan_name()?,
vol as i32
)
}
}
};
// TODO: error handling
self.volume_notif.update(summary.as_str(), None, Some(icon)).unwrap();
self.volume_notif.set_hint("value", Some((vol as i32).to_variant()));
// TODO: error handling
self.volume_notif.show().unwrap();
self.volume_notif
.update(summary.as_str(), None, Some(icon))?;
self.volume_notif.set_hint(
"value",
Some((vol as i32).to_variant()),
);
self.volume_notif.show()?;
return Ok(());
}
/// Shows a text notification, e.g. for warnings or errors.
pub fn show_text_notif(&self, summary: &str, body: &str) -> Result<()> {
// TODO: error handling
self.text_notif.update(summary, Some(body), None).unwrap();
// TODO: error handling
self.text_notif.show().unwrap();
self.text_notif.update(summary, Some(body), None)?;
self.text_notif.show()?;
return Ok(());
}
}
impl Drop for Notif {
fn drop(&mut self) {
libnotify::uninit();
}
}
pub fn init_notify(appstate: Rc<AppS>) {
debug!("Blah");
/// Initialize the notification subsystem.
pub fn init_notify<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
{
/* connect handler */
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
let notif = &apps.notif;
if !notif.enabled.get() {
if notif.is_none() || !notif.as_ref().unwrap().enabled.get() {
return;
}
let notif = notif.as_ref().unwrap();
match (s,
u,
(notif.from_popup.get(),
notif.from_tray.get(),
notif.from_external.get())) {
notif.from_external.get(),
notif.from_hotkeys.get())) {
(AudioSignal::NoCard, _, _) => try_w!(notif.show_text_notif("No sound card", "No playable soundcard found")),
(AudioSignal::CardDisconnected, _, _) => try_w!(notif.show_text_notif("Soundcard disconnected", "Soundcard has been disconnected, reloading sound system...")),
(AudioSignal::CardError, _, _) => (),
(AudioSignal::ValuesChanged,
AudioUser::TrayIcon,
(_, true, _)) => try_w!(notif.show_volume_notif(&apps.audio)),
(_, true, _, _)) => try_w!(notif.show_volume_notif(apps.audio.as_ref())),
(AudioSignal::ValuesChanged,
AudioUser::Popup,
(true, _, _)) => try_w!(notif.show_volume_notif(&apps.audio)),
(true, _, _, _)) => try_w!(notif.show_volume_notif(apps.audio.as_ref())),
(AudioSignal::ValuesChanged,
AudioUser::Unknown,
(_, _, true)) => try_w!(notif.show_volume_notif(&apps.audio)),
// TODO hotkeys
(_, _, true, _)) => try_w!(notif.show_volume_notif(apps.audio.as_ref())),
(AudioSignal::ValuesChanged,
AudioUser::Hotkeys,
(_, _, _, true)) => try_w!(notif.show_volume_notif(apps.audio.as_ref())),
_ => (),
}
}));

71
src/prefs.rs
View File

@ -1,3 +1,12 @@
#![allow(missing_docs)]
//! The preferences subsystem.
//!
//! These are the global application preferences, which can be set
//! by the user. They read from a file in TOML format, presented
//! in the preferences dialog and saved back to the file on request.
use errors::*;
use std::fmt::Display;
use std::fmt::Formatter;
@ -18,6 +27,7 @@ const VOL_CONTROL_COMMANDS: [&str; 3] =
#[derive(Deserialize, Debug, Serialize, Clone, Copy)]
#[serde(rename_all = "snake_case")]
/// When the tray icon is middle-clicked.
pub enum MiddleClickAction {
ToggleMute,
ShowPreferences,
@ -60,6 +70,7 @@ impl From<MiddleClickAction> for i32 {
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// Device preferences tab.
pub struct DevicePrefs {
pub card: String,
pub channel: String,
@ -78,6 +89,7 @@ impl Default for DevicePrefs {
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// View preferences tab.
pub struct ViewPrefs {
pub draw_vol_meter: bool,
pub vol_meter_offset: i32,
@ -100,6 +112,7 @@ impl Default for ViewPrefs {
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// Volume color setting in the view preferences tab.
pub struct VolColor {
pub red: f64,
pub green: f64,
@ -119,13 +132,14 @@ impl Default for VolColor {
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// Behavior preferences tab.
pub struct BehaviorPrefs {
pub unmute_on_vol_change: bool,
pub vol_control_cmd: Option<String>,
pub vol_scroll_step: f64,
pub vol_fine_scroll_step: f64,
pub middle_click_action: MiddleClickAction,
pub custom_command: Option<String>, // TODO: fine scroll step?
pub custom_command: Option<String>,
}
impl Default for BehaviorPrefs {
@ -145,13 +159,14 @@ impl Default for BehaviorPrefs {
#[cfg(feature = "notify")]
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// Notifications preferences tab.
pub struct NotifyPrefs {
pub enable_notifications: bool,
pub notifcation_timeout: i64,
pub notify_mouse_scroll: bool,
pub notify_popup: bool,
pub notify_external: bool,
// TODO: notify_hotkeys?
pub notify_hotkeys: bool,
}
#[cfg(feature = "notify")]
@ -163,20 +178,33 @@ impl Default for NotifyPrefs {
notify_mouse_scroll: true,
notify_popup: true,
notify_external: true,
notify_hotkeys: true,
};
}
}
#[derive(Deserialize, Debug, Serialize, Default)]
/// Hotkey preferences.
/// The `String`s represent gtk accelerator strings.
pub struct HotkeyPrefs {
pub enable_hotkeys: bool,
pub mute_unmute_key: Option<String>,
pub vol_up_key: Option<String>,
pub vol_down_key: Option<String>,
}
#[derive(Deserialize, Debug, Serialize, Default)]
#[serde(default)]
/// Main preferences struct, holding all sub-preferences.
pub struct Prefs {
pub device_prefs: DevicePrefs,
pub view_prefs: ViewPrefs,
pub behavior_prefs: BehaviorPrefs,
#[cfg(feature = "notify")]
pub notify_prefs: NotifyPrefs,
// TODO: HotKeys?
pub hotkey_prefs: HotkeyPrefs,
}
impl Prefs {
@ -207,6 +235,8 @@ impl Prefs {
}
// TODO: unused
/// Reload the current preferences from the config file.
pub fn reload_config(&mut self) -> Result<()> {
debug!("Reloading config...");
@ -217,24 +247,43 @@ impl Prefs {
}
/// Store the current preferences to the config file.
pub fn store_config(&self) -> Result<()> {
let config_path = get_xdg_dirs().place_config_file("pnmixer.toml")
.from_err()?;
let config_path = get_xdg_dirs()
.place_config_file("pnmixer.toml")
.chain_err(|| {
format!(
"Could not create config directory at {:?}",
get_xdg_dirs().get_config_home()
)
})?;
debug!("Storing config in {:?}", config_path);
let mut f = File::create(config_path)?;
f.write_all(self.to_str().as_bytes())?;
let mut f = File::create(config_path.clone()).chain_err(|| {
format!(
"Could not open/create config file {:?} for writing",
config_path
)
})?;
f.write_all(self.to_str().as_bytes()).chain_err(|| {
format!("Could not write to config file {:?}", config_path)
})?;
return Ok(());
}
/// Conver the current preferences to a viewable String.
pub fn to_str(&self) -> String {
return toml::to_string(self).unwrap();
}
/// Get an available volume control command, which must exist in `$PATH`.
/// Tries hard to fine one,
/// starting with the given preference setting and falling back to the
/// `VOL_CONTROL_COMMANDS` slice.
pub fn get_avail_vol_control_cmd(&self) -> Option<String> {
match self.behavior_prefs.vol_control_cmd {
Some(ref c) => return Some(c.clone()),
@ -252,15 +301,17 @@ impl Prefs {
}
impl Display for Prefs {
fn fmt(&self,
f: &mut Formatter)
-> std::result::Result<(), std::fmt::Error> {
fn fmt(
&self,
f: &mut Formatter,
) -> std::result::Result<(), std::fmt::Error> {
let s = self.to_str();
return write!(f, "{}", s);
}
}
/// Get the set of XDG directories, relative to our project.
fn get_xdg_dirs() -> xdg::BaseDirectories {
return xdg::BaseDirectories::with_prefix("pnmixer-rs").unwrap();
}

42
src/support_alsa.rs → src/support/alsa.rs
View File

@ -1,35 +1,36 @@
//! Alsa audio helper functions.
//!
//! This mod wraps around a few low-level alsa functions and abstracts
//! out the details we don't care about. Mainly used by the
//! [alsa_card mod](./alsa_card.html).
//! out the details we don't care about.
use alsa::card::Card;
use alsa::mixer::{Mixer, Selem, SelemId, Elem};
use alsa;
use alsa_lib::card::Card;
use alsa_lib::mixer::{Mixer, Selem, Elem};
use alsa_lib;
use errors::*;
use libc::c_int;
use std::iter::Map;
use std::iter::Filter;
/// Get the default alsa card. This is the one with the ID `0`.
pub fn get_default_alsa_card() -> Card {
return get_alsa_card_by_id(0);
}
/// Get an alsa card corresponding to the given ID.
pub fn get_alsa_card_by_id(index: c_int) -> Card {
return Card::new(index);
}
pub fn get_alsa_cards() -> alsa::card::Iter {
return alsa::card::Iter::new();
/// Get all available alsa cards.
pub fn get_alsa_cards() -> alsa_lib::card::Iter {
return alsa_lib::card::Iter::new();
}
/// Get the first playable alsa card.
pub fn get_first_playable_alsa_card() -> Result<Card> {
for m_card in get_alsa_cards() {
match m_card {
@ -46,6 +47,7 @@ pub fn get_first_playable_alsa_card() -> Result<Card> {
}
/// Get the names of all playable alsa cards.
pub fn get_playable_alsa_card_names() -> Vec<String> {
let mut vec = vec![];
for m_card in get_alsa_cards() {
@ -66,6 +68,7 @@ pub fn get_playable_alsa_card_names() -> Vec<String> {
}
/// Get an alsa card by the given name.
pub fn get_alsa_card_by_name(name: String) -> Result<Card> {
for r_card in get_alsa_cards() {
let card = r_card?;
@ -78,6 +81,7 @@ pub fn get_alsa_card_by_name(name: String) -> Result<Card> {
}
/// Check whether the given alsa card as a playable `Selem`.
pub fn alsa_card_has_playable_selem(card: &Card) -> bool {
let mixer = try_wr!(get_mixer(&card), false);
for selem in get_playable_selems(&mixer) {
@ -89,11 +93,13 @@ pub fn alsa_card_has_playable_selem(card: &Card) -> bool {
}
/// Get the `Mixer` for the given alsa card.
pub fn get_mixer(card: &Card) -> Result<Mixer> {
return Mixer::new(&format!("hw:{}", card.get_index()), false).from_err();
return Ok(Mixer::new(&format!("hw:{}", card.get_index()), false)?);
}
/// Get the `Selem` from the given `Elem`.
pub fn get_selem(elem: Elem) -> Selem {
/* in the ALSA API, there are currently only simple elements,
* so this unwrap() should be safe.
@ -102,6 +108,7 @@ pub fn get_selem(elem: Elem) -> Selem {
}
/// Get all playable `Selem`s.
pub fn get_playable_selems(mixer: &Mixer) -> Vec<Selem> {
let mut v = vec![];
for s in mixer.iter().map(get_selem).filter(selem_is_playable) {
@ -111,6 +118,7 @@ pub fn get_playable_selems(mixer: &Mixer) -> Vec<Selem> {
}
/// Get the first playable `Selem`.
pub fn get_first_playable_selem(mixer: &Mixer) -> Result<Selem> {
for s in mixer.iter().map(get_selem).filter(selem_is_playable) {
return Ok(s);
@ -120,6 +128,7 @@ pub fn get_first_playable_selem(mixer: &Mixer) -> Result<Selem> {
}
/// Get the names from all playable `Selem`s.
pub fn get_playable_selem_names(mixer: &Mixer) -> Vec<String> {
let mut vec = vec![];
for selem in get_playable_selems(mixer) {
@ -134,13 +143,13 @@ pub fn get_playable_selem_names(mixer: &Mixer) -> Vec<String> {
}
pub fn get_playable_selem_by_name(mixer: &Mixer,
name: String)
-> Result<Selem> {
/// Get a playable `Selem` by the given name.
pub fn get_playable_selem_by_name(
mixer: &Mixer,
name: String,
) -> Result<Selem> {
for selem in get_playable_selems(mixer) {
let n = selem.get_id()
.get_name()
.map(|y| String::from(y))?;
let n = selem.get_id().get_name().map(|y| String::from(y))?;
if n == name {
return Ok(selem);
@ -150,6 +159,7 @@ pub fn get_playable_selem_by_name(mixer: &Mixer,
}
/// Check whether the given `Selem` is playable.
pub fn selem_is_playable(selem: &Selem) -> bool {
return selem.has_playback_volume();
}

113
src/support/audio.rs Normal file
View File

@ -0,0 +1,113 @@
#![allow(missing_docs)] // enum
//! Helper functions of the audio subsystem.
//!
//! These functions are not directly connected to the `Audio` struct,
//! but are important helpers.
use audio::frontend::*;
use errors::*;
use prefs::*;
use support::alsa::*;
#[derive(Clone, Copy, Debug)]
/// The direction of a volume change.
pub enum VolDir {
Up,
Down,
Unknown,
}
/// Convert a volume change to the `VolDir` type.
/// ## `old`
/// The old volume value.
/// ## `new`
/// The new volume value.
///
/// # Returns
///
/// The direction of the volume change as `Voldir`.
pub fn vol_change_to_voldir(old: f64, new: f64) -> VolDir {
if old < new {
return VolDir::Up;
} else if old > new {
return VolDir::Down;
} else {
return VolDir::Unknown;
}
}
/// Kinda mimics `lrint` from libm. If the direction of the volume change
/// is `Up` then calls `ceil()`, if it's `Down`, then calls `floor()`, otherwise
/// returns the value unchanged.
pub fn lrint(v: f64, dir: VolDir) -> f64 {
match dir {
VolDir::Up => v.ceil(),
VolDir::Down => v.floor(),
_ => v,
}
}
/// Reload the audio system.
pub fn audio_reload<T>(audio: &T, prefs: &Prefs, user: AudioUser) -> Result<()>
where
T: AudioFrontend,
{
let card = &prefs.device_prefs.card;
let channel = &prefs.device_prefs.channel;
// TODO: is this clone safe?
return audio.switch_card(Some(card.clone()), Some(channel.clone()), user);
}
/// Converts the actual volume of the audio configuration, which depends
/// on the volume range, to a scale of 0-100, reprenting the percentage
/// of the volume level.
pub fn vol_to_percent(vol: i64, range: (i64, i64)) -> Result<f64> {
let (min, max) = range;
ensure!(
min < max,
"Invalid playback volume range [{} - {}]",
min,
max
);
let perc = ((vol - min) as f64) / ((max - min) as f64) * 100.0;
return Ok(perc);
}
/// Converts the percentage of the volume level (0-100) back to the actual
/// low-level representation of the volume, which depends on the volume
/// range.
pub fn percent_to_vol(vol: f64, range: (i64, i64), dir: VolDir) -> Result<i64> {
let (min, max) = range;
ensure!(
min < max,
"Invalid playback volume range [{} - {}]",
min,
max
);
let _v = lrint(vol / 100.0 * ((max - min) as f64), dir) + (min as f64);
return Ok(_v as i64);
}
/// Get all playable card names.
pub fn get_playable_card_names() -> Vec<String> {
return get_playable_alsa_card_names();
}
/// Get all playable channel names.
pub fn get_playable_chan_names(card_name: String) -> Vec<String> {
let card = try_r!(get_alsa_card_by_name(card_name), Vec::default());
let mixer = try_r!(get_mixer(&card), Vec::default());
return get_playable_selem_names(&mixer);
}

31
src/support/cmd.rs Normal file
View File

@ -0,0 +1,31 @@
//! Helper functions for invoking system commands.
use errors::*;
use glib;
use prefs::Prefs;
use std::error::Error;
use std;
/// Execute an available volume control command asynchronously, starting with
/// the preferences and using some fallback values. If none of these
/// are valid executables in `$PATH`, then return `Err(err)`.
pub fn execute_vol_control_command(prefs: &Prefs) -> Result<()> {
let m_cmd = prefs.get_avail_vol_control_cmd();
match m_cmd {
Some(ref cmd) => execute_command(cmd.as_str()),
None => bail!("No command found"),
}
}
/// Try to execute the given command asynchronously via gtk.
pub fn execute_command(cmd: &str) -> Result<()> {
return Ok(glib::spawn_command_line_async(cmd)
.map_err(|e| {
std::io::Error::new(std::io::ErrorKind::Other, e.description())
})?);
}

82
src/support/gdk_x11.rs Normal file
View File

@ -0,0 +1,82 @@
//! Glue code between gdk and x11, allowing some `gdk_x11_*` functions.
//!
//! This is not a complete binding, but just provides what we need in a
//! reasonable way.
use gdk;
use gdk_sys::GdkDisplay;
use glib::translate::*;
use x11::xlib::{Display, Window};
// https://developer.gnome.org/gdk3/stable/gdk3-X-Window-System-Interaction.html
mod ffi {
use gdk_sys::{GdkDisplay, GdkWindow};
use x11::xlib::{Display, Window};
extern "C" {
pub fn gdk_x11_get_default_xdisplay() -> *mut Display;
pub fn gdk_x11_get_default_root_xwindow() -> Window;
pub fn gdk_x11_window_foreign_new_for_display(
display: *mut GdkDisplay,
window: Window,
) -> *mut GdkWindow;
}
}
/// Gets the default GTK+ display.
///
/// # Returns
///
/// the Xlib Display* for the display specified in the `--display`
/// command line option or the `DISPLAY` environment variable.
pub fn gdk_x11_get_default_xdisplay() -> *mut Display {
unsafe {
return ffi::gdk_x11_get_default_xdisplay();
}
}
/// Gets the root window of the default screen (see `gdk_x11_get_default_screen()`).
///
/// # Returns
///
/// an Xlib Window.
pub fn gdk_x11_get_default_root_xwindow() -> Window {
unsafe {
return ffi::gdk_x11_get_default_root_xwindow();
}
}
/// Wraps a native window in a GdkWindow. The function will try to look up the
/// window using `gdk_x11_window_lookup_for_display()` first. If it does not find
/// it there, it will create a new window.
///
/// This may fail if the window has been destroyed. If the window was already
/// known to GDK, a new reference to the existing GdkWindow is returned.
/// ## `display`
/// the GdkDisplay where the window handle comes from.
/// ## ` window`
/// an Xlib Window
///
/// # Returns
///
/// a GdkWindow wrapper for the native window, or `None` if the window has been
/// destroyed. The wrapper will be newly created, if one doesn’t exist already.
pub fn gdk_x11_window_foreign_new_for_display(
gdk_display: &mut gdk::Display,
xwindow: Window,
) -> Option<gdk::Window> {
unsafe {
let display: *mut GdkDisplay =
mut_override(gdk_display.to_glib_none().0);
return from_glib_full(ffi::gdk_x11_window_foreign_new_for_display(
display,
xwindow,
));
}
}

2
src/glade_helpers.rs → src/support/glade.rs
View File

@ -1,3 +1,5 @@
#![allow(missing_docs)]
#[macro_export]
macro_rules! create_builder_item {
($sname:ident, $($element: ident: $ty: ty),+) => {

13
src/support/mod.rs Normal file
View File

@ -0,0 +1,13 @@
//! Support subsystem, with no specific logical coherence.
//!
//! This module provides helper/support functions of various types that
//! don't logically fit elsewhere.
pub mod alsa;
pub mod audio;
pub mod cmd;
pub mod gdk_x11;
#[macro_use]
pub mod glade;
#[macro_use]
pub mod ui;

42
src/support_ui.rs → src/support/ui.rs
View File

@ -1,38 +1,31 @@
//! Helper functions for the UI, mostly pixbuf functions.
use errors::*;
use gdk_pixbuf;
use gdk_pixbuf_sys;
use glib::translate::FromGlibPtrFull;
use glib::translate::ToGlibPtr;
use gtk::prelude::*;
use gtk;
use std::path::*;
pub fn copy_pixbuf(pixbuf: &gdk_pixbuf::Pixbuf) -> gdk_pixbuf::Pixbuf {
let new_pixbuf = unsafe {
let gdk_pixbuf = pixbuf.to_glib_full();
let copy = gdk_pixbuf_sys::gdk_pixbuf_copy(gdk_pixbuf);
FromGlibPtrFull::from_glib_full(copy)
};
return new_pixbuf;
}
pub fn pixbuf_new_from_theme(icon_name: &str,
/// Get a pixbuf by name from the given theme with the requested size.
/// Note that the size is not enforced, but rather a hint.
pub fn pixbuf_new_from_theme(
icon_name: &str,
size: i32,
theme: &gtk::IconTheme)
-> Result<gdk_pixbuf::Pixbuf> {
theme: &gtk::IconTheme,
) -> Result<gdk_pixbuf::Pixbuf> {
let icon_info =
theme.lookup_icon(icon_name, size, gtk::IconLookupFlags::empty())
let icon_info = theme
.lookup_icon(icon_name, size, gtk::IconLookupFlags::empty())
.ok_or(format!("Couldn't find icon {}", icon_name))?;
debug!("Loading stock icon {} from {:?}",
debug!(
"Loading stock icon {} from {:?}",
icon_name,
icon_info.get_filename().unwrap_or(PathBuf::new()));
icon_info.get_filename().unwrap_or(PathBuf::new())
);
// TODO: propagate error
let pixbuf = icon_info.load_icon().unwrap();
@ -42,7 +35,9 @@ pub fn pixbuf_new_from_theme(icon_name: &str,
#[macro_export]
macro_rules! pixbuf_new_from_file {
/// Create a pixbuf from the given PNG file. Includes the file as bytes
/// in the binary and decodes it.
macro_rules! pixbuf_new_from_png {
($name:expr) => {
{
use gdk_pixbuf;
@ -73,4 +68,3 @@ macro_rules! pixbuf_new_from_file {
}
}
}

64
src/support_audio.rs
View File

@ -1,64 +0,0 @@
use audio::{Audio, AudioUser};
use errors::*;
use prefs::*;
#[derive(Clone, Copy, Debug)]
pub enum VolDir {
Up,
Down,
Unknown,
}
pub fn vol_change_to_voldir(old: f64, new: f64) -> VolDir {
if old < new {
return VolDir::Up;
} else if old > new {
return VolDir::Down;
} else {
return VolDir::Unknown;
}
}
pub fn lrint(v: f64, dir: VolDir) -> f64 {
match dir {
VolDir::Up => v.ceil(),
VolDir::Down => v.floor(),
_ => v,
}
}
pub fn audio_reload(audio: &Audio,
prefs: &Prefs,
user: AudioUser)
-> Result<()> {
let card = &prefs.device_prefs.card;
let channel = &prefs.device_prefs.channel;
// TODO: is this clone safe?
return audio.switch_acard(Some(card.clone()), Some(channel.clone()), user);
}
pub fn vol_to_percent(vol: i64, range: (i64, i64)) -> Result<f64> {
let (min, max) = range;
ensure!(min < max,
"Invalid playback volume range [{} - {}]",
min,
max);
let perc = ((vol - min) as f64) / ((max - min) as f64) * 100.0;
return Ok(perc);
}
pub fn percent_to_vol(vol: f64, range: (i64, i64), dir: VolDir) -> Result<i64> {
let (min, max) = range;
ensure!(min < max,
"Invalid playback volume range [{} - {}]",
min,
max);
let _v = lrint(vol / 100.0 * ((max - min) as f64), dir) + (min as f64);
return Ok(_v as i64);
}

26
src/support_cmd.rs
View File

@ -1,26 +0,0 @@
use errors::*;
use glib;
use prefs::Prefs;
use std::error::Error;
use std;
pub fn execute_vol_control_command(prefs: &Prefs) -> Result<()> {
let m_cmd = prefs.get_avail_vol_control_cmd();
match m_cmd {
Some(ref cmd) => execute_command(cmd.as_str()),
None => bail!("No command found"),
}
}
pub fn execute_command(cmd: &str) -> Result<()> {
return glib::spawn_command_line_async(cmd)
.map_err(|e| {
std::io::Error::new(std::io::ErrorKind::Other,
e.description())
})
.from_err();
}

137
src/ui/entry.rs Normal file
View File

@ -0,0 +1,137 @@
//! Global GUI state.
use app_state::*;
use audio::frontend::*;
use gtk::DialogExt;
use gtk::GtkWindowExt;
use gtk::MessageDialogExt;
use gtk::WidgetExt;
use gtk;
use gtk_sys::GTK_RESPONSE_YES;
use prefs::*;
use std::cell::RefCell;
use std::rc::Rc;
use support::audio::*;
use ui::popup_menu::*;
use ui::popup_window::*;
use ui::prefs_dialog::*;
use ui::tray_icon::*;
#[cfg(feature = "notify")]
use notif::*;
/// The GUI struct mostly describing the main widgets (mostly wrapped)
/// the user interacts with.
pub struct Gui {
_cant_construct: (),
/// The tray icon.
pub tray_icon: TrayIcon,
/// The popup window.
pub popup_window: PopupWindow,
/// The popup menu.
pub popup_menu: PopupMenu,
/* prefs_dialog is dynamically created and destroyed */
/// The preferences dialog.
pub prefs_dialog: RefCell<Option<PrefsDialog>>,
}
impl Gui {
/// Constructor. The prefs dialog is initialized as `None`.
pub fn new(
builder_popup_window: gtk::Builder,
builder_popup_menu: gtk::Builder,
prefs: &Prefs,
) -> Gui {
return Gui {
_cant_construct: (),
tray_icon: TrayIcon::new(prefs).unwrap(),
popup_window: PopupWindow::new(builder_popup_window),
popup_menu: PopupMenu::new(builder_popup_menu),
prefs_dialog: RefCell::new(None),
};
}
}
/// Initialize the GUI system.
pub fn init<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
{
/* "global" audio signal handler */
let apps = appstate.clone();
appstate.audio.connect_handler(
Box::new(move |s, u| match (s, u) {
(AudioSignal::CardDisconnected, _) => {
try_w!(audio_reload(
apps.audio.as_ref(),
&apps.prefs.borrow(),
AudioUser::Unknown,
));
}
(AudioSignal::CardError, _) => {
if run_audio_error_dialog(
&apps.gui.popup_menu.menu_window,
) == (GTK_RESPONSE_YES as i32)
{
try_w!(audio_reload(
apps.audio.as_ref(),
&apps.prefs.borrow(),
AudioUser::Unknown,
));
}
}
_ => (),
}),
);
}
init_tray_icon(appstate.clone());
init_popup_window(appstate.clone());
init_popup_menu(appstate.clone());
init_prefs_callback(appstate.clone());
#[cfg(feature = "notify")] init_notify(appstate.clone());
}
/// Used to run a dialog when an audio error occured, suggesting the user
/// may reload the audio system either manually or by confirming the dialog
/// via the confirmation button.
///
/// # Returns
///
/// `GTK_RESPONSE_YES` if the user wants to reload the audio system,
/// `GTK_RESPONSE_NO` otherwise.
fn run_audio_error_dialog(parent: &gtk::Window) -> i32 {
error!(
"Connection with audio failed, you probably need to restart pnmixer."
);
let dialog = gtk::MessageDialog::new(
Some(parent),
gtk::DialogFlags::DESTROY_WITH_PARENT,
gtk::MessageType::Error,
gtk::ButtonsType::YesNo,
"Warning: Connection to sound system failed.",
);
dialog.set_property_secondary_text(Some(
"Do you want to re-initialize the audio connection ?
If you do not, you will either need to restart PNMixer
or select the 'Reload Audio' option in the right-click
menu in order for PNMixer to function.",
));
dialog.set_title("PNMixer-rs Error");
let resp = dialog.run();
dialog.destroy();
return resp;
}

143
src/ui/hotkey_dialog.rs Normal file
View File

@ -0,0 +1,143 @@
//! The ui hotkey preferences dialog.
//!
//! Usually run from the preferences window.
use errors::*;
use gdk::DeviceExt;
use gdk;
use gdk_sys;
use glib::translate::*;
use gtk::prelude::*;
use gtk;
use libc::c_uint;
use std;
/// Hotkey dialog struct holding the relevant gtk widgets.
pub struct HotkeyDialog {
hotkey_dialog: gtk::Dialog,
// instruction_label: gtk::Label, // not needed
key_pressed_label: gtk::Label,
}
impl HotkeyDialog {
/// Creates a new hotkey dialog.
pub fn new<P>(parent: &P, hotkey: String) -> HotkeyDialog
where
P: IsA<gtk::Window>,
{
let builder = gtk::Builder::new_from_string(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/data/ui/hotkey-dialog.glade"
)));
let hotkey_dialog: gtk::Dialog =
builder.get_object("hotkey_dialog").unwrap();
let instruction_label: gtk::Label =
builder.get_object("instruction_label").unwrap();
let key_pressed_label: gtk::Label =
builder.get_object("key_pressed_label").unwrap();
hotkey_dialog.set_title(format!("Set {} HotKey", hotkey).as_str());
instruction_label.set_markup(
format!("Press new HotKey for <b>{}</b>", hotkey)
.as_str(),
);
hotkey_dialog.set_transient_for(parent);
{
let key_pressed_label = key_pressed_label.clone();
hotkey_dialog.connect_key_press_event(move |_, e| {
let mut state = e.get_state();
unsafe {
let mut keyval: c_uint = 0;
let mut consumed: gdk_sys::GdkModifierType =
gdk_sys::GdkModifierType::empty();
gdk_sys::gdk_keymap_translate_keyboard_state(
gdk_sys::gdk_keymap_get_default(),
e.get_hardware_keycode() as u32,
state.to_glib(),
e.get_group() as i32,
&mut keyval as *mut c_uint,
std::ptr::null_mut(),
std::ptr::null_mut(),
&mut consumed as *mut gdk_sys::GdkModifierType,
);
let consumed: gdk::ModifierType = from_glib(!consumed);
state = state & consumed;
state = state & gtk::accelerator_get_default_mod_mask();
let key_text = gtk::accelerator_name(keyval, state);
key_pressed_label.set_text(
key_text
.unwrap_or(String::from("(None)"))
.as_str(),
);
};
return Inhibit(false);
});
}
hotkey_dialog.connect_key_release_event(move |w, _| {
w.response(gtk::ResponseType::Ok.into());
return Inhibit(false);
});
return HotkeyDialog {
hotkey_dialog,
key_pressed_label,
};
}
/// Runs the hotkey dialog and returns a String representing the hotkey
/// that has been pressed.
pub fn run(&self) -> Result<String> {
self.hotkey_dialog.show_now();
let device = gtk::get_current_event_device().ok_or(
"Could not get current device",
)?;
let window = self.hotkey_dialog.get_window().ok_or(
"Could not get window",
)?;
let m_grab_status = device.grab(
&window,
gdk::GrabOwnership::Application,
true,
gdk::EventMask::KEY_PRESS_MASK,
None,
gdk_sys::GDK_CURRENT_TIME as u32,
);
if m_grab_status != gdk::GrabStatus::Success {
bail!("Could not grab the keyboard");
}
let resp = self.hotkey_dialog.run();
device.ungrab(gdk_sys::GDK_CURRENT_TIME as u32);
if resp != gtk::ResponseType::Ok.into() {
bail!(ErrorKind::GtkResponseCancel(
String::from("not assigning hotkey"),
));
}
return Ok(self.key_pressed_label.get_text().ok_or(
"Could not get text",
)?);
}
}
impl Drop for HotkeyDialog {
fn drop(&mut self) {
self.hotkey_dialog.destroy();
}
}

8
src/ui/mod.rs Normal file
View File

@ -0,0 +1,8 @@
//! The UI subsystem.
pub mod entry;
pub mod hotkey_dialog;
pub mod popup_menu;
pub mod popup_window;
pub mod prefs_dialog;
pub mod tray_icon;

91
src/ui_popup_menu.rs → src/ui/popup_menu.rs
View File

@ -1,18 +1,32 @@
#![allow(missing_docs)] // glade_helpers
//! The popup menu subsystem when the user right-clicks on the tray icon.
//!
//! Shows the menu with the following entries:
//!
//! * Mute
//! * Volume Control
//! * Preferences
//! * Reload Sound
//! * About
//! * Quit
use app_state::*;
use audio::{AudioUser, AudioSignal};
use audio::frontend::*;
use gtk::prelude::*;
use gtk;
use std::rc::Rc;
use support_audio::*;
use support_cmd::*;
use ui_prefs_dialog::*;
use support::audio::*;
use support::cmd::*;
use ui::prefs_dialog::*;
const VERSION: &'static str = env!("CARGO_PKG_VERSION");
create_builder_item!(PopupMenu,
create_builder_item!(
PopupMenu,
menu_window: gtk::Window,
menubar: gtk::MenuBar,
menu: gtk::Menu,
@ -22,20 +36,22 @@ create_builder_item!(PopupMenu,
mute_check: gtk::CheckButton,
prefs_item: gtk::MenuItem,
quit_item: gtk::MenuItem,
reload_item: gtk::MenuItem);
reload_item: gtk::MenuItem
);
pub fn init_popup_menu(appstate: Rc<AppS>) {
/// Initialize the popup menu subsystem, registering all callbacks.
pub fn init_popup_menu<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
/* audio.connect_handler */
{
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
/* skip if window is hidden */
if !apps.gui
.popup_menu
.menu
.get_visible() {
if !apps.gui.popup_menu.menu.get_visible() {
return;
}
match (s, u) {
@ -48,10 +64,9 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
/* popup_menu.menu.connect_show */
{
let apps = appstate.clone();
appstate.gui
.popup_menu
.menu
.connect_show(move |_| set_mute_check(&apps));
appstate.gui.popup_menu.menu.connect_show(
move |_| set_mute_check(&apps),
);
}
@ -60,7 +75,10 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
let apps = appstate.clone();
let mixer_item = &appstate.gui.popup_menu.mixer_item;
mixer_item.connect_activate(move |_| {
try_w!(execute_vol_control_command(&apps.prefs.borrow()));
let _ = result_warn!(
execute_vol_control_command(&apps.prefs.borrow()),
Some(&apps.gui.popup_menu.menu_window)
);
});
}
@ -68,10 +86,8 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
{
let apps = appstate.clone();
let mute_item = &appstate.gui.popup_menu.mute_item;
mute_item.connect_activate(move |_| {
if apps.audio.has_mute() {
mute_item.connect_activate(move |_| if apps.audio.has_mute() {
try_w!(apps.audio.toggle_mute(AudioUser::Popup));
}
});
}
@ -79,18 +95,18 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
{
let apps = appstate.clone();
let about_item = &appstate.gui.popup_menu.about_item;
about_item.connect_activate(move |_| {
on_about_item_activate(&apps);
});
about_item.connect_activate(
move |_| { on_about_item_activate(&apps); },
);
}
/* prefs_item.connect_activate_link */
{
let apps = appstate.clone();
let prefs_item = &appstate.gui.popup_menu.prefs_item;
prefs_item.connect_activate(move |_| {
on_prefs_item_activate(&apps);
});
prefs_item.connect_activate(
move |_| { on_prefs_item_activate(&apps); },
);
}
/* reload_item.connect_activate_link */
@ -98,9 +114,11 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
let apps = appstate.clone();
let reload_item = &appstate.gui.popup_menu.reload_item;
reload_item.connect_activate(move |_| {
try_w!(audio_reload(&apps.audio,
try_w!(audio_reload(
apps.audio.as_ref(),
&apps.prefs.borrow(),
AudioUser::Popup))
AudioUser::Popup,
))
});
}
@ -113,7 +131,11 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
}
fn on_about_item_activate(appstate: &AppS) {
/// When the about menu item is activated.
fn on_about_item_activate<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let popup_menu = &appstate.gui.popup_menu.menu_window;
let about_dialog = create_about_dialog();
about_dialog.set_skip_taskbar_hint(true);
@ -123,6 +145,7 @@ fn on_about_item_activate(appstate: &AppS) {
}
/// Create the About dialog from scratch.
fn create_about_dialog() -> gtk::AboutDialog {
let about_dialog: gtk::AboutDialog = gtk::AboutDialog::new();
@ -153,13 +176,21 @@ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.",
}
fn on_prefs_item_activate(appstate: &Rc<AppS>) {
/// When the Preferences item is activated.
fn on_prefs_item_activate<T>(appstate: &Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
/* TODO: only create if needed */
show_prefs_dialog(appstate);
}
fn set_mute_check(apps: &Rc<AppS>) {
/// When the Mute item is checked.
fn set_mute_check<T>(apps: &Rc<AppS<T>>)
where
T: AudioFrontend,
{
let mute_check = &apps.gui.popup_menu.mute_check;
let m_muted = apps.audio.get_mute();
match m_muted {

340
src/ui/popup_window.rs Normal file
View File

@ -0,0 +1,340 @@
//! The popup window subsystem when the user left-clicks on the tray icon.
//!
//! This shows the manipulatable volume slider with the current volume and
//! the mute checkbox.
use app_state::*;
use audio::frontend::*;
use errors::*;
use gdk::DeviceExt;
use gdk::{GrabOwnership, GrabStatus};
use gdk;
use gdk_sys::{GDK_KEY_Escape, GDK_CURRENT_TIME};
use glib::translate::*;
use glib;
use gtk::ToggleButtonExt;
use gtk::prelude::*;
use gtk;
use prefs::*;
use std::cell::Cell;
use std::rc::Rc;
use support::audio::*;
use support::cmd::*;
/// The main struct for the popup window, holding all relevant sub-widgets
/// and some mutable state.
pub struct PopupWindow {
_cant_construct: (),
/// The main window for the popup window widget.
pub popup_window: gtk::Window,
/// The volume scale adjustment.
pub vol_scale_adj: gtk::Adjustment,
/// The volume scale.
pub vol_scale: gtk::Scale,
/// The mute check button.
pub mute_check: gtk::CheckButton,
/// The button to start the external mixer.
pub mixer_button: gtk::Button,
/// Signal for mute_check.connect_toggled callback,
/// so we can block it temporarily.
toggle_signal: Cell<u64>,
/// Signal for vol_scale_adj.connect_value_changed callback,
/// so we can block it temporarily.
changed_signal: Cell<u64>,
}
impl PopupWindow {
/// Constructor.
pub fn new(builder: gtk::Builder) -> PopupWindow {
return PopupWindow {
_cant_construct: (),
popup_window: builder.get_object("popup_window").unwrap(),
vol_scale_adj: builder.get_object("vol_scale_adj").unwrap(),
vol_scale: builder.get_object("vol_scale").unwrap(),
mute_check: builder.get_object("mute_check").unwrap(),
mixer_button: builder.get_object("mixer_button").unwrap(),
toggle_signal: Cell::new(0),
changed_signal: Cell::new(0),
};
}
/// Update the popup window state, including the slider
/// and the mute checkbutton.
pub fn update<T>(&self, audio: &T) -> Result<()>
where
T: AudioFrontend,
{
let cur_vol = audio.get_vol()?;
set_slider(&self.vol_scale_adj, cur_vol);
self.update_mute_check(audio);
return Ok(());
}
/// Update the mute checkbutton.
pub fn update_mute_check<T>(&self, audio: &T)
where
T: AudioFrontend,
{
let m_muted = audio.get_mute();
glib::signal_handler_block(&self.mute_check,
&from_glib(self.toggle_signal.get()));
match m_muted {
Ok(val) => {
self.mute_check.set_sensitive(true);
self.mute_check.set_active(val);
self.mute_check.set_tooltip_text("");
}
Err(_) => {
/* can't figure out whether channel is muted, grey out */
self.mute_check.set_active(true);
self.mute_check.set_sensitive(false);
self.mute_check.set_tooltip_text(
"Soundcard has no mute switch",
);
}
}
glib::signal_handler_unblock(
&self.mute_check,
&from_glib(self.toggle_signal.get()),
);
}
/// Set the page increment fro the volume scale adjustment based on the
/// preferences.
fn set_vol_increment(&self, prefs: &Prefs) {
self.vol_scale_adj.set_page_increment(
prefs.behavior_prefs.vol_scroll_step,
);
self.vol_scale_adj.set_step_increment(
prefs.behavior_prefs.vol_fine_scroll_step,
);
}
}
/// Initialize the popup window subsystem.
pub fn init_popup_window<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
/* audio.connect_handler */
{
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
/* skip if window is hidden */
if !apps.gui.popup_window.popup_window.get_visible() {
return;
}
match (s, u) {
/* Update only mute check here
* If the user changes the volume through the popup window,
* we MUST NOT update the slider value, it's been done already.
* It means that, as long as the popup window is visible,
* the slider value reflects the value set by user,
* and not the real value reported by the audio system.
*/
(_, AudioUser::Popup) => {
apps.gui.popup_window.update_mute_check(
apps.audio.as_ref(),
);
}
/* external change, safe to update slider too */
(_, _) => {
try_w!(apps.gui.popup_window.update(apps.audio.as_ref()));
}
}
}));
}
/* mute_check.connect_toggled */
{
let _appstate = appstate.clone();
let mute_check = &appstate.clone().gui.popup_window.mute_check;
let toggle_signal = mute_check.connect_toggled(move |_| {
on_mute_check_toggled(&_appstate)
});
appstate.gui.popup_window.toggle_signal.set(toggle_signal.to_glib());
}
/* popup_window.connect_show */
{
let _appstate = appstate.clone();
let popup_window = &appstate.clone().gui.popup_window.popup_window;
popup_window.connect_show(move |_| on_popup_window_show(&_appstate));
}
/* vol_scale_adj.connect_value_changed */
{
let _appstate = appstate.clone();
let vol_scale_adj = &appstate.clone().gui.popup_window.vol_scale_adj;
let changed_signal = vol_scale_adj.connect_value_changed(move |_| {
on_vol_scale_value_changed(&_appstate)
});
appstate.gui.popup_window.changed_signal.set(changed_signal.to_glib());
}
/* popup_window.connect_event */
{
let popup_window = &appstate.clone().gui.popup_window.popup_window;
popup_window.connect_event(move |w, e| on_popup_window_event(w, e));
}
/* mixer_button.connect_clicked */
{
let apps = appstate.clone();
let mixer_button = &appstate.clone().gui.popup_window.mixer_button;
mixer_button.connect_clicked(move |_| {
apps.gui.popup_window.popup_window.hide();
let _ = result_warn!(
execute_vol_control_command(&apps.prefs.borrow()),
Some(&apps.gui.popup_menu.menu_window)
);
});
}
}
/// When the popup window is shown.
fn on_popup_window_show<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let popup_window = &appstate.gui.popup_window;
appstate.gui.popup_window.set_vol_increment(
&appstate.prefs.borrow(),
);
glib::signal_handler_block(
&popup_window.vol_scale_adj,
&from_glib(popup_window.changed_signal.get()),
);
try_w!(appstate.gui.popup_window.update(appstate.audio.as_ref()));
glib::signal_handler_unblock(
&popup_window.vol_scale_adj,
&from_glib(popup_window.changed_signal.get()),
);
popup_window.vol_scale.grab_focus();
try_w!(grab_devices(&appstate.gui.popup_window.popup_window));
}
/// On key or button press event on the popup window.
fn on_popup_window_event(w: &gtk::Window, e: &gdk::Event) -> gtk::Inhibit {
match gdk::Event::get_event_type(e) {
gdk::EventType::GrabBroken => w.hide(),
gdk::EventType::KeyPress => {
let key: gdk::EventKey = e.clone().downcast().unwrap();
if key.get_keyval() == (GDK_KEY_Escape as u32) {
w.hide();
}
}
gdk::EventType::ButtonPress => {
let device = try_wr!(
gtk::get_current_event_device().ok_or(
"No current event device!",
),
Inhibit(false)
);
let (window, _, _) =
gdk::DeviceExt::get_window_at_position(&device);
if window.is_none() {
w.hide();
}
}
_ => (),
}
return Inhibit(false);
}
/// When the volume scale slider is moved.
fn on_vol_scale_value_changed<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let audio = &appstate.audio;
let old_vol = try_w!(audio.get_vol());
let val = appstate.gui.popup_window.vol_scale.get_value();
let dir = vol_change_to_voldir(old_vol, val);
try_w!(audio.set_vol(
val,
AudioUser::Popup,
dir,
appstate.prefs.borrow().behavior_prefs.unmute_on_vol_change,
));
}
/// When the mute checkbutton is toggled.
fn on_mute_check_toggled<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let audio = &appstate.audio;
try_w!(audio.toggle_mute(AudioUser::Popup))
}
/// Set the volume slider to the given value.
pub fn set_slider(vol_scale_adj: &gtk::Adjustment, scale: f64) {
vol_scale_adj.set_value(scale);
}
/// Grab all devices, keyboard and mouse.
fn grab_devices(window: &gtk::Window) -> Result<()> {
let device = gtk::get_current_event_device().ok_or("No current device")?;
let gdk_window = window.get_window().ok_or("No window?!")?;
/* Grab the mouse */
let m_grab_status = device.grab(
&gdk_window,
GrabOwnership::None,
true,
gdk::EventMask::BUTTON_PRESS_MASK,
None,
GDK_CURRENT_TIME as u32,
);
if m_grab_status != GrabStatus::Success {
warn!(
"Could not grab {}",
device.get_name().unwrap_or(String::from("UNKNOWN DEVICE"))
);
}
/* Grab the keyboard */
let k_dev = device.get_associated_device().ok_or(
"Couldn't get associated device",
)?;
let k_grab_status = k_dev.grab(
&gdk_window,
GrabOwnership::None,
true,
gdk::EventMask::KEY_PRESS_MASK,
None,
GDK_CURRENT_TIME as u32,
);
if k_grab_status != GrabStatus::Success {
warn!(
"Could not grab {}",
k_dev.get_name().unwrap_or(String::from("UNKNOWN DEVICE"))
);
}
return Ok(());
}

725
src/ui/prefs_dialog.rs Normal file
View File

@ -0,0 +1,725 @@
//! The preferences window subsystem, when the user clicks the "Preferences"
//! menu item on the popup menu.
use app_state::*;
use audio::frontend::*;
use errors::*;
use gdk;
use gtk::ResponseType;
use gtk::prelude::*;
use gtk;
use prefs::*;
use std::cell::RefCell;
use std::rc::Rc;
use support::audio::*;
use ui::hotkey_dialog::HotkeyDialog;
/// The main preferences dialog, holding all the relevant subwidgets we
/// need to convert its state to preferences and back.
pub struct PrefsDialog {
_cant_construct: (),
prefs_dialog: gtk::Dialog,
notebook: gtk::Notebook,
/* DevicePrefs */
card_combo: gtk::ComboBoxText,
chan_combo: gtk::ComboBoxText,
/* ViewPrefs */
vol_meter_draw_check: gtk::CheckButton,
vol_meter_pos_spin: gtk::SpinButton,
vol_meter_color_button: gtk::ColorButton,
system_theme: gtk::CheckButton,
/* BehaviorPrefs */
unmute_on_vol_change: gtk::CheckButton,
vol_control_entry: gtk::Entry,
scroll_step_spin: gtk::SpinButton,
fine_scroll_step_spin: gtk::SpinButton,
middle_click_combo: gtk::ComboBoxText,
custom_entry: gtk::Entry,
/* NotifyPrefs */
#[cfg(feature = "notify")]
noti_enable_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_timeout_spin: gtk::SpinButton,
// pub noti_hotkey_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_mouse_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_popup_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_ext_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_hotkey_check: gtk::CheckButton,
/* HotkeyPrefs */
hotkeys_enable_check: gtk::CheckButton,
hotkeys_mute_label: gtk::Label,
hotkeys_up_label: gtk::Label,
hotkeys_down_label: gtk::Label,
/* Hotkey stuff (not prefs) */
hotkeys_mute_eventbox: gtk::EventBox,
hotkeys_up_eventbox: gtk::EventBox,
hotkeys_down_eventbox: gtk::EventBox,
hotkey_dialog: RefCell<Option<HotkeyDialog>>,
}
impl PrefsDialog {
fn new() -> PrefsDialog {
let builder = gtk::Builder::new_from_string(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/data/ui/prefs-dialog.glade"
)));
let prefs_dialog = PrefsDialog {
_cant_construct: (),
prefs_dialog: builder.get_object("prefs_dialog").unwrap(),
notebook: builder.get_object("notebook").unwrap(),
/* DevicePrefs */
card_combo: builder.get_object("card_combo").unwrap(),
chan_combo: builder.get_object("chan_combo").unwrap(),
/* ViewPrefs */
vol_meter_draw_check: builder
.get_object("vol_meter_draw_check")
.unwrap(),
vol_meter_pos_spin: builder
.get_object("vol_meter_pos_spin")
.unwrap(),
vol_meter_color_button: builder
.get_object("vol_meter_color_button")
.unwrap(),
system_theme: builder.get_object("system_theme").unwrap(),
/* BehaviorPrefs */
unmute_on_vol_change: builder
.get_object("unmute_on_vol_change")
.unwrap(),
vol_control_entry: builder.get_object("vol_control_entry").unwrap(),
scroll_step_spin: builder.get_object("scroll_step_spin").unwrap(),
fine_scroll_step_spin: builder
.get_object("fine_scroll_step_spin")
.unwrap(),
middle_click_combo: builder
.get_object("middle_click_combo")
.unwrap(),
custom_entry: builder.get_object("custom_entry").unwrap(),
/* NotifyPrefs */
#[cfg(feature = "notify")]
#[cfg(feature = "notify")]
#[cfg(feature = "notify")]
#[cfg(feature = "notify")]
noti_enable_check: builder.get_object("noti_enable_check").unwrap(),
#[cfg(feature = "notify")]
noti_timeout_spin: builder.get_object("noti_timeout_spin").unwrap(),
// noti_hotkey_check: builder.get_object("noti_hotkey_check").unwrap(),
#[cfg(feature = "notify")]
#[cfg(feature = "notify")]
#[cfg(feature = "notify")]
#[cfg(feature = "notify")]
noti_mouse_check: builder.get_object("noti_mouse_check").unwrap(),
#[cfg(feature = "notify")]
noti_popup_check: builder.get_object("noti_popup_check").unwrap(),
#[cfg(feature = "notify")]
noti_ext_check: builder.get_object("noti_ext_check").unwrap(),
#[cfg(feature = "notify")]
noti_hotkey_check: builder.get_object("noti_hotkey_check").unwrap(),
/* HotkeyPrefs */
hotkeys_enable_check: builder
.get_object("hotkeys_enable_check")
.unwrap(),
hotkeys_mute_label: builder
.get_object("hotkeys_mute_label")
.unwrap(),
hotkeys_up_label: builder.get_object("hotkeys_up_label").unwrap(),
hotkeys_down_label: builder
.get_object("hotkeys_down_label")
.unwrap(),
/* Hotkey stuff (not prefs) */
hotkeys_mute_eventbox: builder
.get_object("hotkeys_mute_eventbox")
.unwrap(),
hotkeys_up_eventbox: builder
.get_object("hotkeys_up_eventbox")
.unwrap(),
hotkeys_down_eventbox: builder
.get_object("hotkeys_down_eventbox")
.unwrap(),
hotkey_dialog: RefCell::new(None),
};
#[cfg(feature = "notify")]
let notify_tab: gtk::Box =
builder.get_object("noti_vbox_enabled").unwrap();
#[cfg(not(feature = "notify"))]
let notify_tab: gtk::Box =
builder.get_object("noti_vbox_disabled").unwrap();
prefs_dialog.notebook.append_page(
&notify_tab,
Some(&gtk::Label::new(Some("Notifications"))),
);
return prefs_dialog;
}
/// Import the given preferences into the preferences dialog state.
fn from_prefs(&self, prefs: &Prefs) {
/* DevicePrefs */
/* filled on show signal with audio info */
self.card_combo.remove_all();
self.chan_combo.remove_all();
/* ViewPrefs */
self.vol_meter_draw_check.set_active(
prefs.view_prefs.draw_vol_meter,
);
self.vol_meter_pos_spin.set_value(
prefs.view_prefs.vol_meter_offset as
f64,
);
let rgba = gdk::RGBA {
red: prefs.view_prefs.vol_meter_color.red,
green: prefs.view_prefs.vol_meter_color.green,
blue: prefs.view_prefs.vol_meter_color.blue,
alpha: 1.0,
};
self.vol_meter_color_button.set_rgba(&rgba);
self.system_theme.set_active(prefs.view_prefs.system_theme);
/* BehaviorPrefs */
self.unmute_on_vol_change.set_active(
prefs
.behavior_prefs
.unmute_on_vol_change,
);
self.vol_control_entry.set_text(
prefs
.behavior_prefs
.vol_control_cmd
.as_ref()
.unwrap_or(&String::from(""))
.as_str(),
);
self.scroll_step_spin.set_value(
prefs.behavior_prefs.vol_scroll_step,
);
self.fine_scroll_step_spin.set_value(
prefs
.behavior_prefs
.vol_fine_scroll_step,
);
// TODO: make sure these values always match, must be a better way
// also check to_prefs()
self.middle_click_combo.append_text("Toggle Mute");
self.middle_click_combo.append_text("Show Preferences");
self.middle_click_combo.append_text("Volume Control");
self.middle_click_combo.append_text(
"Custom Command (set below)",
);
self.middle_click_combo.set_active(
prefs
.behavior_prefs
.middle_click_action
.into(),
);
self.custom_entry.set_text(
prefs
.behavior_prefs
.custom_command
.as_ref()
.unwrap_or(&String::from(""))
.as_str(),
);
/* NotifyPrefs */
#[cfg(feature = "notify")]
{
self.noti_enable_check.set_active(
prefs
.notify_prefs
.enable_notifications,
);
self.noti_timeout_spin.set_value(
prefs.notify_prefs.notifcation_timeout as
f64,
);
self.noti_mouse_check.set_active(
prefs.notify_prefs.notify_mouse_scroll,
);
self.noti_popup_check.set_active(
prefs.notify_prefs.notify_popup,
);
self.noti_ext_check.set_active(
prefs.notify_prefs.notify_external,
);
self.noti_hotkey_check.set_active(
prefs.notify_prefs.notify_hotkeys,
);
}
/* hotkey prefs */
self.hotkeys_enable_check.set_active(
prefs.hotkey_prefs.enable_hotkeys,
);
self.hotkeys_mute_label.set_text(
prefs
.hotkey_prefs
.mute_unmute_key
.clone()
.unwrap_or(String::from("(None)"))
.as_str(),
);
self.hotkeys_up_label.set_text(
prefs
.hotkey_prefs
.vol_up_key
.clone()
.unwrap_or(String::from("(None)"))
.as_str(),
);
self.hotkeys_down_label.set_text(
prefs
.hotkey_prefs
.vol_down_key
.clone()
.unwrap_or(String::from("(None)"))
.as_str(),
);
}
/// Export the dialog state to the `Prefs` struct, which can be used
/// to write them to the config file.
fn to_prefs(&self) -> Prefs {
let card = self.card_combo.get_active_text();
let channel = self.chan_combo.get_active_text();
if card.is_none() || channel.is_none() {
return Prefs::default();
}
let device_prefs = DevicePrefs {
card: self.card_combo.get_active_text().unwrap(),
channel: self.chan_combo.get_active_text().unwrap(),
};
let vol_meter_color = VolColor {
red: (self.vol_meter_color_button.get_rgba().red),
green: (self.vol_meter_color_button.get_rgba().green),
blue: (self.vol_meter_color_button.get_rgba().blue),
};
let view_prefs = ViewPrefs {
draw_vol_meter: self.vol_meter_draw_check.get_active(),
vol_meter_offset: self.vol_meter_pos_spin.get_value_as_int(),
system_theme: self.system_theme.get_active(),
vol_meter_color,
};
let vol_control_cmd = self.vol_control_entry.get_text().and_then(|x| {
if x.is_empty() { None } else { Some(x) }
});
let custom_command =
self.custom_entry.get_text().and_then(|x| if x.is_empty() {
None
} else {
Some(x)
});
let behavior_prefs = BehaviorPrefs {
unmute_on_vol_change: self.unmute_on_vol_change.get_active(),
vol_control_cmd,
vol_scroll_step: self.scroll_step_spin.get_value(),
vol_fine_scroll_step: self.fine_scroll_step_spin.get_value(),
middle_click_action: self.middle_click_combo.get_active().into(),
custom_command,
};
#[cfg(feature = "notify")]
let notify_prefs = NotifyPrefs {
enable_notifications: self.noti_enable_check.get_active(),
notifcation_timeout: self.noti_timeout_spin.get_value_as_int() as
i64,
notify_mouse_scroll: self.noti_mouse_check.get_active(),
notify_popup: self.noti_popup_check.get_active(),
notify_external: self.noti_ext_check.get_active(),
notify_hotkeys: self.noti_hotkey_check.get_active(),
};
let hotkey_prefs =
HotkeyPrefs {
enable_hotkeys: self.hotkeys_enable_check.get_active(),
mute_unmute_key: self.hotkeys_mute_label.get_text().and_then(
|s| {
if s == "(None)" { None } else { Some(s) }
},
),
vol_up_key: self.hotkeys_up_label.get_text().and_then(
|s| if s ==
"(None)"
{
None
} else {
Some(s)
},
),
vol_down_key: self.hotkeys_down_label.get_text().and_then(
|s| if s ==
"(None)"
{
None
} else {
Some(s)
},
),
};
return Prefs {
device_prefs,
view_prefs,
behavior_prefs,
#[cfg(feature = "notify")]
notify_prefs,
hotkey_prefs,
};
}
}
/// Show the preferences dialog. This is created and destroyed dynamically
/// and not persistent across the application lifetime.
pub fn show_prefs_dialog<T>(appstate: &Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
if appstate.gui.prefs_dialog.borrow().is_some() {
return;
}
*appstate.gui.prefs_dialog.borrow_mut() = Some(PrefsDialog::new());
init_prefs_dialog(&appstate);
{
let m_pd = appstate.gui.prefs_dialog.borrow();
let prefs_dialog = &m_pd.as_ref().unwrap();
let prefs_dialog_w = &prefs_dialog.prefs_dialog;
prefs_dialog.from_prefs(&appstate.prefs.borrow());
prefs_dialog_w.set_transient_for(&appstate.gui.popup_menu.menu_window);
prefs_dialog_w.present();
}
}
/// Initialize the internal prefs dialog handler that connects to the audio
/// system.
pub fn init_prefs_callback<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
/* skip if prefs window is not present */
if apps.gui.prefs_dialog.borrow().is_none() {
return;
}
match (s, u) {
(AudioSignal::CardInitialized, _) => (),
(AudioSignal::CardCleanedUp, _) => {
fill_card_combo(&apps);
fill_chan_combo(&apps, None);
}
_ => (),
}
}));
}
/// Initialize the preferences dialog gtk callbacks.
fn init_prefs_dialog<T>(appstate: &Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
/* prefs_dialog.connect_show */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.prefs_dialog.connect_show(move |_| {
fill_card_combo(&apps);
fill_chan_combo(&apps, None);
});
}
/* card_combo.connect_changed */
{
let apps = appstate.clone();
let m_cc = appstate.gui.prefs_dialog.borrow();
let card_combo = &m_cc.as_ref().unwrap().card_combo;
card_combo.connect_changed(move |_| {
let m_cc = apps.gui.prefs_dialog.borrow();
let card_combo = &m_cc.as_ref().unwrap().card_combo;
let card_name = card_combo.get_active_text().unwrap();
fill_chan_combo(&apps, Some(card_name));
return;
});
}
/* prefs_dialog.connect_response */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.prefs_dialog.connect_response(move |_, response_id| {
if response_id == ResponseType::Ok.into() ||
response_id == ResponseType::Apply.into()
{
let mut prefs = apps.prefs.borrow_mut();
let prefs_dialog = apps.gui.prefs_dialog.borrow();
*prefs = prefs_dialog.as_ref().unwrap().to_prefs();
}
if response_id != ResponseType::Apply.into() {
let mut prefs_dialog = apps.gui.prefs_dialog.borrow_mut();
prefs_dialog.as_ref().unwrap().prefs_dialog.destroy();
*prefs_dialog = None;
}
if response_id == ResponseType::Ok.into() ||
response_id == ResponseType::Apply.into()
{
try_w!(apps.update_popup_window());
try_w!(apps.update_tray_icon());
let _ = result_warn!(
apps.update_hotkeys(),
Some(&apps.gui.popup_menu.menu_window)
);
apps.update_notify();
try_w!(apps.update_audio(AudioUser::PrefsWindow));
let _ = result_warn!(
apps.update_config(),
Some(&apps.gui.popup_menu.menu_window)
);
}
});
}
/* prefs_dialog.hotkeys_mute_eventbox */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.hotkeys_mute_eventbox.connect_button_press_event(
move |w, e| {
return Inhibit(
on_hotkey_event_box_button_press_event(&apps, &w, e),
);
},
);
}
/* prefs_dialog.hotkeys_up_eventbox */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.hotkeys_up_eventbox.connect_button_press_event(
move |w, e| {
return Inhibit(
on_hotkey_event_box_button_press_event(&apps, &w, e),
);
},
);
}
/* prefs_dialog.hotkeys_down_eventbox */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.hotkeys_down_eventbox.connect_button_press_event(
move |w, e| {
return Inhibit(
on_hotkey_event_box_button_press_event(&apps, &w, e),
);
},
);
}
}
/// Fill the card combo box in the Devices tab.
fn fill_card_combo<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let m_cc = appstate.gui.prefs_dialog.borrow();
let card_combo = &m_cc.as_ref().unwrap().card_combo;
card_combo.remove_all();
let audio = &appstate.audio;
/* set card combo */
let cur_card_name =
try_w!(audio.card_name(), "Can't get current card name!");
let available_card_names = get_playable_card_names();
/* set_active_id doesn't work, so save the index */
let mut c_index: i32 = -1;
for i in 0..available_card_names.len() {
let name = available_card_names.get(i).unwrap();
if *name == cur_card_name {
c_index = i as i32;
}
card_combo.append_text(&name);
}
// TODO, block signal?
card_combo.set_active(c_index);
}
/// Fill the channel combo box in the Devices tab.
fn fill_chan_combo<T>(appstate: &AppS<T>, cardname: Option<String>)
where
T: AudioFrontend,
{
let m_cc = appstate.gui.prefs_dialog.borrow();
let chan_combo = &m_cc.as_ref().unwrap().chan_combo;
chan_combo.remove_all();
let audio = &appstate.audio;
let available_chan_names = match cardname {
Some(name) => get_playable_chan_names(name),
None => audio.playable_chan_names(),
};
/* set chan combo */
let cur_chan_name = try_w!(audio.chan_name());
/* set_active_id doesn't work, so save the index */
let mut c_index: i32 = -1;
for i in 0..available_chan_names.len() {
let name = available_chan_names.get(i).unwrap();
if *name == cur_chan_name {
c_index = i as i32;
}
chan_combo.append_text(&name);
}
/* TODO, block signal?`*/
chan_combo.set_active(c_index);
}
fn on_hotkey_event_box_button_press_event<T>(
appstate: &AppS<T>,
widget: &gtk::EventBox,
event: &gdk::EventButton,
) -> bool
where
T: AudioFrontend,
{
let borrow = appstate.gui.prefs_dialog.borrow();
let prefs_dialog = &borrow.as_ref().unwrap();
/* we want a left-click */
if event.get_button() != 1 {
return false;
}
/* we want it to be double-click */
if event.get_event_type() != gdk::EventType::DoubleButtonPress {
return false;
}
let (hotkey_label, hotkey) = {
if *widget == prefs_dialog.hotkeys_mute_eventbox {
(
prefs_dialog.hotkeys_mute_label.clone(),
String::from("Mute/Unmute"),
)
} else if *widget == prefs_dialog.hotkeys_up_eventbox {
(
prefs_dialog.hotkeys_up_label.clone(),
String::from("Volume Up"),
)
} else if *widget == prefs_dialog.hotkeys_down_eventbox {
(
prefs_dialog.hotkeys_down_label.clone(),
String::from("Volume Down"),
)
} else {
warn!("Unknown hotkey eventbox");
return false;
}
};
/* Ensure there's no dialog already running */
if prefs_dialog.hotkey_dialog.borrow().is_some() {
return false;
}
/* Unbind hotkeys */
appstate.hotkeys.borrow().unbind();
/* Run the hotkey dialog */
let hotkey_dialog = &prefs_dialog.hotkey_dialog;
*hotkey_dialog.borrow_mut() =
Some(HotkeyDialog::new(&prefs_dialog.prefs_dialog, hotkey));
let key_pressed = hotkey_dialog.borrow().as_ref().unwrap().run();
*hotkey_dialog.borrow_mut() = None;
/* Bind hotkeys */
appstate.hotkeys.borrow().bind();
/* Check the response */
match key_pressed {
Ok(k) => {
println!("k: {}", k);
if k.eq_ignore_ascii_case("<Primary>c") {
hotkey_label.set_text("(None)");
} else {
hotkey_label.set_text(k.as_str());
}
}
Err(Error(ErrorKind::GtkResponseCancel(msg), _)) => {
info!("{}", ErrorKind::GtkResponseCancel(msg));
return false;
}
Err(e) => {
// Could not grab hotkey, most likely
error_dialog!(
e.description(),
Some(&appstate.gui.popup_menu.menu_window)
);
warn!("{}", e);
return false;
}
}
return false;
}

278
src/ui_tray_icon.rs → src/ui/tray_icon.rs
View File

@ -1,5 +1,11 @@
//! The tray icon subsystem.
//!
//! This manages the tray icon Pixbuf as well as the callbacks on left and
//! right-click.
use app_state::*;
use audio::*;
use audio::frontend::*;
use errors::*;
use gdk;
use gdk_pixbuf;
@ -10,25 +16,34 @@ use prefs::{Prefs, MiddleClickAction};
use std::cell::Cell;
use std::cell::RefCell;
use std::rc::Rc;
use support_cmd::*;
use support_ui::*;
use ui_prefs_dialog::show_prefs_dialog;
use support::cmd::*;
use support::ui::*;
use ui::prefs_dialog::show_prefs_dialog;
const ICON_MIN_SIZE: i32 = 16;
/// The tray icon struct, describing the complete visual state.
pub struct TrayIcon {
_cant_construct: (),
/// The volume meter to draw on the actual Pixbuf, if requested.
pub volmeter: RefCell<Option<VolMeter>>,
/// The actual Pixbuf tray icon.
pub audio_pix: RefCell<AudioPix>,
/// The gtk `StatusIcon` widget, used to register callbacks.
pub status_icon: gtk::StatusIcon,
/// The current icon size.
pub icon_size: Cell<i32>,
}
impl TrayIcon {
/// Constructor. `audio_pix` is initialized as empty GdkPixbuf, to save
/// one iteration of png decoding (`update_all()` is triggered immediately
/// on startup through `tray_icon.connect_size_changed` usually,
/// otherwise we have to trigger it manually).
pub fn new(prefs: &Prefs) -> Result<TrayIcon> {
let draw_vol_meter = prefs.view_prefs.draw_vol_meter;
@ -57,7 +72,13 @@ impl TrayIcon {
}
fn update_vol_meter(&self, cur_vol: f64, vol_level: VolLevel) -> Result<()> {
/// Update the volume meter Pixbuf, which is drawn on top of the
/// actual Pixbuf.
fn update_vol_meter(
&self,
cur_vol: f64,
vol_level: VolLevel,
) -> Result<()> {
let audio_pix = self.audio_pix.borrow();
let pixbuf = audio_pix.select_pix(vol_level);
@ -75,16 +96,17 @@ impl TrayIcon {
}
fn update_tooltip(&self, audio: &Audio) {
let cardname = audio.acard
.borrow()
.card_name()
.unwrap_or(String::from("Unknown card"));
let channame = audio.acard
.borrow()
.chan_name()
.unwrap_or(String::from("unknown channel"));
let vol = audio.vol()
/// Update the tooltip of the tray icon.
fn update_tooltip<T>(&self, audio: &T)
where
T: AudioFrontend,
{
let cardname =
audio.card_name().unwrap_or(String::from("Unknown card"));
let channame =
audio.chan_name().unwrap_or(String::from("unknown channel"));
let vol = audio
.get_vol()
.map(|s| format!("{}", s.round()))
.unwrap_or(String::from("unknown volume"));
let mute_info = {
@ -96,20 +118,28 @@ impl TrayIcon {
""
}
};
self.status_icon.set_tooltip_text(format!("{} ({})\nVolume: {}{}",
self.status_icon.set_tooltip_text(
format!(
"{} ({})\nVolume: {}{}",
cardname,
channame,
vol,
mute_info)
.as_str());
mute_info
).as_str(),
);
}
pub fn update_all(&self,
/// Update the whole tray icon state.
pub fn update_all<T>(
&self,
prefs: &Prefs,
audio: &Audio,
m_size: Option<i32>)
-> Result<()> {
audio: &T,
m_size: Option<i32>,
) -> Result<()>
where
T: AudioFrontend,
{
match m_size {
Some(s) => {
if s < ICON_MIN_SIZE {
@ -131,13 +161,15 @@ impl TrayIcon {
*self.volmeter.borrow_mut() = Some(volmeter);
}
self.update_tooltip(&audio);
return self.update_vol_meter(audio.vol()?, audio.vol_level());
self.update_tooltip(audio);
return self.update_vol_meter(audio.get_vol()?, audio.vol_level());
}
}
/// The volume meter, describes by its colors, offset and width/row
/// properties.
pub struct VolMeter {
red: u8,
green: u8,
@ -151,11 +183,11 @@ pub struct VolMeter {
impl VolMeter {
/// Constructor. `width` and `row` are initialized with default values.
fn new(prefs: &Prefs) -> VolMeter {
return VolMeter {
red: (prefs.view_prefs.vol_meter_color.red * 255.0) as u8,
green: (prefs.view_prefs.vol_meter_color.green * 255.0) as
u8,
green: (prefs.view_prefs.vol_meter_color.green * 255.0) as u8,
blue: (prefs.view_prefs.vol_meter_color.blue * 255.0) as u8,
x_offset_pct: prefs.view_prefs.vol_meter_offset as i64,
y_offset_pct: 10,
@ -166,36 +198,49 @@ impl VolMeter {
}
// TODO: cache input pixbuf?
fn meter_draw(&self,
/// Draw the volume meter on top of the actual tray icon Pixbuf.
fn meter_draw(
&self,
volume: i64,
pixbuf: &gdk_pixbuf::Pixbuf)
-> Result<gdk_pixbuf::Pixbuf> {
pixbuf: &gdk_pixbuf::Pixbuf,
) -> Result<gdk_pixbuf::Pixbuf> {
ensure!(pixbuf.get_colorspace() == gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
"Invalid colorspace in pixbuf");
ensure!(pixbuf.get_bits_per_sample() == 8,
"Invalid bits per sample in pixbuf");
ensure!(
pixbuf.get_colorspace() == gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
"Invalid colorspace in pixbuf"
);
ensure!(
pixbuf.get_bits_per_sample() == 8,
"Invalid bits per sample in pixbuf"
);
ensure!(pixbuf.get_has_alpha(), "No alpha channel in pixbuf");
ensure!(pixbuf.get_n_channels() == 4,
"Invalid number of channels in pixbuf");
ensure!(
pixbuf.get_n_channels() == 4,
"Invalid number of channels in pixbuf"
);
let i_width = pixbuf.get_width() as i64;
let i_height = pixbuf.get_height() as i64;
let new_pixbuf = copy_pixbuf(pixbuf);
let new_pixbuf = pixbuf.copy();
let vm_width = i_width / 6;
let x = (self.x_offset_pct as f64 *
((i_width - vm_width) as f64 / 100.0)) as i64;
ensure!(x >= 0 && (x + vm_width) <= i_width,
((i_width - vm_width) as f64 / 100.0)) as
i64;
ensure!(
x >= 0 && (x + vm_width) <= i_width,
"x coordinate invalid: {}",
x);
x
);
let y = (self.y_offset_pct as f64 * (i_height as f64 / 100.0)) as i64;
let vm_height =
((i_height - (y * 2)) as f64 * (volume as f64 / 100.0)) as i64;
ensure!(y >= 0 && (y + vm_height) <= i_height,
ensure!(
y >= 0 && (y + vm_height) <= i_height,
"y coordinate invalid: {}",
y);
y
);
/* Let's check if the icon width changed, in which case we
* must reinit our internal row of pixels.
@ -231,8 +276,9 @@ impl VolMeter {
let p_index = ((row_offset * rowstride) + col_offset) as usize;
let row = self.row.borrow();
pixels[p_index..p_index + row.len()]
.copy_from_slice(row.as_ref());
pixels[p_index..p_index + row.len()].copy_from_slice(
row.as_ref(),
);
}
}
@ -246,6 +292,7 @@ impl VolMeter {
#[derive(Clone, Debug)]
/// The actual tray icon Pixbuf, which depends on the current volume level.
pub struct AudioPix {
muted: gdk_pixbuf::Pixbuf,
low: gdk_pixbuf::Pixbuf,
@ -277,6 +324,7 @@ impl Default for AudioPix {
impl AudioPix {
/// Constructor.
fn new(size: i32, prefs: &Prefs) -> Result<AudioPix> {
let system_theme = prefs.view_prefs.system_theme;
@ -324,11 +372,21 @@ impl AudioPix {
}
} else {
AudioPix {
muted: pixbuf_new_from_file!("../data/pixmaps/pnmixer-muted.png")?,
low: pixbuf_new_from_file!("../data/pixmaps/pnmixer-low.png")?,
medium: pixbuf_new_from_file!("../data/pixmaps/pnmixer-medium.png")?,
high: pixbuf_new_from_file!("../data/pixmaps/pnmixer-high.png")?,
off: pixbuf_new_from_file!("../data/pixmaps/pnmixer-off.png")?,
muted: pixbuf_new_from_png!(
"../../data/pixmaps/pnmixer-muted.png"
)?,
low: pixbuf_new_from_png!(
"../../data/pixmaps/pnmixer-low.png"
)?,
medium: pixbuf_new_from_png!(
"../../data/pixmaps/pnmixer-medium.png"
)?,
high: pixbuf_new_from_png!(
"../../data/pixmaps/pnmixer-high.png"
)?,
off: pixbuf_new_from_png!(
"../../data/pixmaps/pnmixer-off.png"
)?,
}
}
};
@ -336,6 +394,7 @@ impl AudioPix {
}
/// Select the try icon Pixbuf depending on the `VolLevel`.
fn select_pix(&self, vol_level: VolLevel) -> &gdk_pixbuf::Pixbuf {
match vol_level {
VolLevel::Muted => &self.muted,
@ -348,7 +407,11 @@ impl AudioPix {
}
pub fn init_tray_icon(appstate: Rc<AppS>) {
/// Initialize the tray icon subsystem.
pub fn init_tray_icon<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
let tray_icon = &appstate.gui.tray_icon;
tray_icon.status_icon.set_visible(true);
@ -356,23 +419,31 @@ pub fn init_tray_icon(appstate: Rc<AppS>) {
/* connect audio handler */
{
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| match (s, u) {
appstate.audio.connect_handler(
Box::new(move |s, u| match (s, u) {
(_, _) => {
apps.gui.tray_icon.update_tooltip(&apps.audio);
try_w!(apps.gui.tray_icon.update_vol_meter(try_w!(apps.audio.vol()),
apps.audio.vol_level()));
apps.gui.tray_icon.update_tooltip(apps.audio.as_ref());
try_w!(apps.gui.tray_icon.update_vol_meter(
try_w!(apps.audio.get_vol()),
apps.audio.vol_level(),
));
}
}));
}),
);
}
/* tray_icon.connect_size_changed */
{
let apps = appstate.clone();
tray_icon.status_icon.connect_size_changed(move |_, size| {
try_wr!(apps.gui.tray_icon.update_all(&apps.prefs.borrow_mut(),
&apps.audio,
Some(size)),
false);
try_wr!(
apps.gui.tray_icon.update_all(
&apps.prefs.borrow_mut(),
apps.audio.as_ref(),
Some(size),
),
false
);
return false;
});
}
@ -380,9 +451,9 @@ pub fn init_tray_icon(appstate: Rc<AppS>) {
/* tray_icon.connect_activate */
{
let apps = appstate.clone();
tray_icon.status_icon.connect_activate(move |_| {
on_tray_icon_activate(&apps)
});
tray_icon.status_icon.connect_activate(
move |_| on_tray_icon_activate(&apps),
);
}
/* tray_icon.connect_scroll_event */
@ -417,14 +488,21 @@ pub fn init_tray_icon(appstate: Rc<AppS>) {
));
default_theme.connect_changed(move |_| {
let tray_icon = &apps.gui.tray_icon;
let audio = &apps.audio;
try_e!(tray_icon.update_all(&apps.prefs.borrow_mut(), &audio, None));
try_e!(tray_icon.update_all(
&apps.prefs.borrow_mut(),
apps.audio.as_ref(),
None,
));
});
}
}
fn on_tray_icon_activate(appstate: &AppS) {
/// When the tray icon is activated.
fn on_tray_icon_activate<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let popup_window = &appstate.gui.popup_window.popup_window;
if popup_window.get_visible() {
@ -435,7 +513,11 @@ fn on_tray_icon_activate(appstate: &AppS) {
}
fn on_tray_icon_popup_menu(appstate: &AppS) {
/// When the popup menu is shown, hide the popup window, if any.
fn on_tray_icon_popup_menu<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
let popup_window = &appstate.gui.popup_window.popup_window;
let popup_menu = &appstate.gui.popup_menu.menu;
@ -444,27 +526,43 @@ fn on_tray_icon_popup_menu(appstate: &AppS) {
}
fn on_tray_icon_scroll_event(appstate: &AppS,
event: &gdk::EventScroll)
-> bool {
/// When the mouse scroll event happens while the mouse pointer is
/// on the tray icon.
fn on_tray_icon_scroll_event<T>(
appstate: &AppS<T>,
event: &gdk::EventScroll,
) -> bool
where
T: AudioFrontend,
{
let scroll_dir: gdk::ScrollDirection = event.get_direction();
match scroll_dir {
gdk::ScrollDirection::Up => {
try_wr!(appstate.audio.increase_vol(AudioUser::TrayIcon,
appstate.prefs
try_wr!(
appstate.audio.increase_vol(
AudioUser::TrayIcon,
appstate
.prefs
.borrow()
.behavior_prefs
.unmute_on_vol_change),
false);
.unmute_on_vol_change,
),
false
);
}
gdk::ScrollDirection::Down => {
try_wr!(appstate.audio.decrease_vol(AudioUser::TrayIcon,
appstate.prefs
try_wr!(
appstate.audio.decrease_vol(
AudioUser::TrayIcon,
appstate
.prefs
.borrow()
.behavior_prefs
.unmute_on_vol_change),
false);
.unmute_on_vol_change,
),
false
);
}
_ => (),
}
@ -473,9 +571,16 @@ fn on_tray_icon_scroll_event(appstate: &AppS,
}
fn on_tray_button_release_event(appstate: &Rc<AppS>,
event_button: &gdk::EventButton)
-> bool {
/// Basically when the tray icon is clicked (although we connect to the `release`
/// event). This decides whether it was a left, right or middle-click and
/// takes appropriate actions.
fn on_tray_button_release_event<T>(
appstate: &Rc<AppS<T>>,
event_button: &gdk::EventButton,
) -> bool
where
T: AudioFrontend + 'static,
{
let button = event_button.get_button();
if button != 2 {
@ -491,18 +596,25 @@ fn on_tray_button_release_event(appstate: &Rc<AppS>,
match middle_click_action {
&MiddleClickAction::ToggleMute => {
if audio.has_mute() {
try_wr!(audio.toggle_mute(AudioUser::Popup), false);
try_wr!(audio.toggle_mute(AudioUser::TrayIcon), false);
}
}
// TODO
&MiddleClickAction::ShowPreferences => show_prefs_dialog(&appstate),
&MiddleClickAction::VolumeControl => {
try_wr!(execute_vol_control_command(&appstate.prefs.borrow()),
false);
let _ = result_warn!(
execute_vol_control_command(&appstate.prefs.borrow()),
Some(&appstate.gui.popup_menu.menu_window)
);
}
&MiddleClickAction::CustomCommand => {
match custom_command {
&Some(ref cmd) => try_wr!(execute_command(cmd.as_str()), false),
&Some(ref cmd) => {
let _ = result_warn!(
execute_command(cmd.as_str()),
Some(&appstate.gui.popup_menu.menu_window)
);
}
&None => warn!("No custom command found"),
}
}

102
src/ui_entry.rs
View File

@ -1,102 +0,0 @@
use app_state::*;
use audio::{AudioUser, AudioSignal};
use gtk::DialogExt;
use gtk::MessageDialogExt;
use gtk::WidgetExt;
use gtk::WindowExt;
use gtk;
use gtk_sys::GTK_RESPONSE_YES;
use prefs::*;
use std::cell::RefCell;
use std::rc::Rc;
use support_audio::*;
use ui_popup_menu::*;
use ui_popup_window::*;
use ui_prefs_dialog::*;
use ui_tray_icon::*;
#[cfg(feature = "notify")]
use notif::*;
pub struct Gui {
_cant_construct: (),
pub tray_icon: TrayIcon,
pub popup_window: PopupWindow,
pub popup_menu: PopupMenu,
/* prefs_dialog is dynamically created and destroyed */
pub prefs_dialog: RefCell<Option<PrefsDialog>>,
}
impl Gui {
pub fn new(builder_popup_window: gtk::Builder,
builder_popup_menu: gtk::Builder,
prefs: &Prefs)
-> Gui {
return Gui {
_cant_construct: (),
tray_icon: TrayIcon::new(prefs).unwrap(),
popup_window: PopupWindow::new(builder_popup_window),
popup_menu: PopupMenu::new(builder_popup_menu),
prefs_dialog: RefCell::new(None),
};
}
}
pub fn init(appstate: Rc<AppS>) {
{
/* "global" audio signal handler */
let apps = appstate.clone();
appstate.audio.connect_handler(
Box::new(move |s, u| match (s, u) {
(AudioSignal::CardDisconnected, _) => {
try_w!(audio_reload(&apps.audio,
&apps.prefs.borrow(),
AudioUser::Unknown));
},
(AudioSignal::CardError, _) => {
if run_audio_error_dialog(&apps.gui.popup_menu.menu_window) == (GTK_RESPONSE_YES as i32) {
try_w!(audio_reload(&apps.audio,
&apps.prefs.borrow(),
AudioUser::Unknown));
}
},
_ => (),
}
));
}
init_tray_icon(appstate.clone());
init_popup_window(appstate.clone());
init_popup_menu(appstate.clone());
init_prefs_callback(appstate.clone());
#[cfg(feature = "notify")]
init_notify(appstate.clone());
}
fn run_audio_error_dialog(parent: &gtk::Window) -> i32 {
error!("Connection with audio failed, you probably need to restart pnmixer.");
let dialog = gtk::MessageDialog::new(Some(parent),
gtk::DIALOG_DESTROY_WITH_PARENT,
gtk::MessageType::Error,
gtk::ButtonsType::YesNo,
"Warning: Connection to sound system failed.");
dialog.set_property_secondary_text(Some("Do you want to re-initialize the audio connection ?
If you do not, you will either need to restart PNMixer
or select the 'Reload Audio' option in the right-click
menu in order for PNMixer to function."));
dialog.set_title("PNMixer-rs Error");
let resp = dialog.run();
dialog.destroy();
return resp;
}

300
src/ui_popup_window.rs
View File

@ -1,300 +0,0 @@
use app_state::*;
use audio::*;
use errors::*;
use gdk::DeviceExt;
use gdk::{GrabOwnership, GrabStatus, BUTTON_PRESS_MASK, KEY_PRESS_MASK};
use gdk;
use gdk_sys::{GDK_KEY_Escape, GDK_CURRENT_TIME};
use glib;
use gtk::ToggleButtonExt;
use gtk::prelude::*;
use gtk;
use prefs::*;
use std::cell::Cell;
use std::rc::Rc;
use support_audio::*;
use support_cmd::*;
pub struct PopupWindow {
_cant_construct: (),
pub popup_window: gtk::Window,
pub vol_scale_adj: gtk::Adjustment,
pub vol_scale: gtk::Scale,
pub mute_check: gtk::CheckButton,
pub mixer_button: gtk::Button,
pub toggle_signal: Cell<u64>,
pub changed_signal: Cell<u64>,
}
impl PopupWindow {
pub fn new(builder: gtk::Builder) -> PopupWindow {
return PopupWindow {
_cant_construct: (),
popup_window: builder.get_object("popup_window").unwrap(),
vol_scale_adj: builder.get_object("vol_scale_adj").unwrap(),
vol_scale: builder.get_object("vol_scale").unwrap(),
mute_check: builder.get_object("mute_check").unwrap(),
mixer_button: builder.get_object("mixer_button").unwrap(),
toggle_signal: Cell::new(0),
changed_signal: Cell::new(0),
};
}
pub fn update(&self, audio: &Audio) -> Result<()> {
let cur_vol = audio.vol()?;
set_slider(&self.vol_scale_adj, cur_vol);
self.update_mute_check(&audio);
return Ok(());
}
pub fn update_mute_check(&self, audio: &Audio) {
let m_muted = audio.get_mute();
glib::signal_handler_block(&self.mute_check, self.toggle_signal.get());
match m_muted {
Ok(val) => {
self.mute_check.set_sensitive(true);
self.mute_check.set_active(val);
self.mute_check.set_tooltip_text("");
}
Err(_) => {
/* can't figure out whether channel is muted, grey out */
self.mute_check.set_active(true);
self.mute_check.set_sensitive(false);
self.mute_check.set_tooltip_text(
"Soundcard has no mute switch",
);
}
}
glib::signal_handler_unblock(&self.mute_check,
self.toggle_signal.get());
}
fn set_vol_increment(&self, prefs: &Prefs) {
self.vol_scale_adj
.set_page_increment(prefs.behavior_prefs.vol_scroll_step);
self.vol_scale_adj
.set_step_increment(prefs.behavior_prefs.vol_fine_scroll_step);
}
}
pub fn init_popup_window(appstate: Rc<AppS>) {
/* audio.connect_handler */
{
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
/* skip if window is hidden */
if !apps.gui
.popup_window
.popup_window
.get_visible() {
return;
}
match (s, u) {
/* Update only mute check here
* If the user changes the volume through the popup window,
* we MUST NOT update the slider value, it's been done already.
* It means that, as long as the popup window is visible,
* the slider value reflects the value set by user,
* and not the real value reported by the audio system.
*/
(_, AudioUser::Popup) => {
apps.gui.popup_window.update_mute_check(&apps.audio);
}
/* external change, safe to update slider too */
(_, _) => {
try_w!(apps.gui.popup_window.update(&apps.audio));
}
}
}));
}
/* mute_check.connect_toggled */
{
let _appstate = appstate.clone();
let mute_check = &appstate.clone()
.gui
.popup_window
.mute_check;
let toggle_signal =
mute_check.connect_toggled(move |_| {
on_mute_check_toggled(&_appstate)
});
appstate.gui
.popup_window
.toggle_signal
.set(toggle_signal);
}
/* popup_window.connect_show */
{
let _appstate = appstate.clone();
let popup_window = &appstate.clone()
.gui
.popup_window
.popup_window;
popup_window.connect_show(move |_| on_popup_window_show(&_appstate));
}
/* vol_scale_adj.connect_value_changed */
{
let _appstate = appstate.clone();
let vol_scale_adj = &appstate.clone()
.gui
.popup_window
.vol_scale_adj;
let changed_signal = vol_scale_adj.connect_value_changed(
move |_| on_vol_scale_value_changed(&_appstate),
);
appstate.gui
.popup_window
.changed_signal
.set(changed_signal);
}
/* popup_window.connect_event */
{
let popup_window = &appstate.clone()
.gui
.popup_window
.popup_window;
popup_window.connect_event(move |w, e| on_popup_window_event(w, e));
}
/* mixer_button.connect_clicked */
{
let apps = appstate.clone();
let mixer_button = &appstate.clone()
.gui
.popup_window
.mixer_button;
mixer_button.connect_clicked(move |_| {
apps.gui
.popup_window
.popup_window
.hide();
try_w!(execute_vol_control_command(&apps.prefs.borrow()));
});
}
}
fn on_popup_window_show(appstate: &AppS) {
let popup_window = &appstate.gui.popup_window;
appstate.gui.popup_window.set_vol_increment(&appstate.prefs.borrow());
glib::signal_handler_block(&popup_window.vol_scale_adj,
popup_window.changed_signal.get());
try_w!(appstate.gui.popup_window.update(&appstate.audio));
glib::signal_handler_unblock(&popup_window.vol_scale_adj,
popup_window.changed_signal.get());
popup_window.vol_scale.grab_focus();
try_w!(grab_devices(&appstate.gui.popup_window.popup_window));
}
fn on_popup_window_event(w: &gtk::Window, e: &gdk::Event) -> gtk::Inhibit {
match gdk::Event::get_event_type(e) {
gdk::EventType::GrabBroken => w.hide(),
gdk::EventType::KeyPress => {
let key: gdk::EventKey = e.clone().downcast().unwrap();
if key.get_keyval() == (GDK_KEY_Escape as u32) {
w.hide();
}
}
gdk::EventType::ButtonPress => {
let device = try_wr!(
gtk::get_current_event_device().ok_or(
"No current event device!",
),
Inhibit(false)
);
let (window, _, _) =
gdk::DeviceExt::get_window_at_position(&device);
if window.is_none() {
w.hide();
}
}
_ => (),
}
return Inhibit(false);
}
fn on_vol_scale_value_changed(appstate: &AppS) {
let audio = &appstate.audio;
let old_vol = try_w!(audio.vol());
let val = appstate.gui
.popup_window
.vol_scale
.get_value();
let dir = vol_change_to_voldir(old_vol, val);
try_w!(audio.set_vol(val,
AudioUser::Popup,
dir,
appstate.prefs
.borrow()
.behavior_prefs
.unmute_on_vol_change));
}
fn on_mute_check_toggled(appstate: &AppS) {
let audio = &appstate.audio;
try_w!(audio.toggle_mute(AudioUser::Popup))
}
pub fn set_slider(vol_scale_adj: &gtk::Adjustment, scale: f64) {
vol_scale_adj.set_value(scale);
}
fn grab_devices(window: &gtk::Window) -> Result<()> {
let device = gtk::get_current_event_device().ok_or("No current device")?;
let gdk_window = window.get_window().ok_or("No window?!")?;
/* Grab the mouse */
let m_grab_status =
device.grab(&gdk_window,
GrabOwnership::None,
true,
BUTTON_PRESS_MASK,
None,
GDK_CURRENT_TIME as u32);
if m_grab_status != GrabStatus::Success {
warn!("Could not grab {}",
device.get_name().unwrap_or(String::from("UNKNOWN DEVICE")));
}
/* Grab the keyboard */
let k_dev = device.get_associated_device()
.ok_or("Couldn't get associated device")?;
let k_grab_status = k_dev.grab(&gdk_window,
GrabOwnership::None,
true,
KEY_PRESS_MASK,
None,
GDK_CURRENT_TIME as u32);
if k_grab_status != GrabStatus::Success {
warn!("Could not grab {}",
k_dev.get_name().unwrap_or(String::from("UNKNOWN DEVICE")));
}
return Ok(());
}

413
src/ui_prefs_dialog.rs
View File

@ -1,413 +0,0 @@
use app_state::*;
use audio::{AudioUser, AudioSignal};
use errors::*;
use gdk;
use gtk::ResponseType;
use gtk::prelude::*;
use gtk;
use prefs::*;
use std::rc::Rc;
use support_alsa::*;
pub struct PrefsDialog {
_cant_construct: (),
prefs_dialog: gtk::Dialog,
notebook: gtk::Notebook,
/* DevicePrefs */
card_combo: gtk::ComboBoxText,
chan_combo: gtk::ComboBoxText,
/* ViewPrefs */
vol_meter_draw_check: gtk::CheckButton,
vol_meter_pos_spin: gtk::SpinButton,
vol_meter_color_button: gtk::ColorButton,
system_theme: gtk::CheckButton,
/* BehaviorPrefs */
unmute_on_vol_change: gtk::CheckButton,
vol_control_entry: gtk::Entry,
scroll_step_spin: gtk::SpinButton,
fine_scroll_step_spin: gtk::SpinButton,
middle_click_combo: gtk::ComboBoxText,
custom_entry: gtk::Entry,
/* NotifyPrefs */
#[cfg(feature = "notify")]
noti_enable_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_timeout_spin: gtk::SpinButton,
// pub noti_hotkey_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_mouse_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_popup_check: gtk::CheckButton,
#[cfg(feature = "notify")]
noti_ext_check: gtk::CheckButton,
}
impl PrefsDialog {
fn new() -> PrefsDialog {
let builder =
gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
"/data/ui/prefs-dialog.glade")));
let prefs_dialog = PrefsDialog {
_cant_construct: (),
prefs_dialog: builder.get_object("prefs_dialog").unwrap(),
notebook: builder.get_object("notebook").unwrap(),
/* DevicePrefs */
card_combo: builder.get_object("card_combo").unwrap(),
chan_combo: builder.get_object("chan_combo").unwrap(),
/* ViewPrefs */
vol_meter_draw_check: builder.get_object("vol_meter_draw_check")
.unwrap(),
vol_meter_pos_spin: builder.get_object("vol_meter_pos_spin")
.unwrap(),
vol_meter_color_button: builder.get_object("vol_meter_color_button")
.unwrap(),
system_theme: builder.get_object("system_theme").unwrap(),
/* BehaviorPrefs */
unmute_on_vol_change: builder.get_object("unmute_on_vol_change")
.unwrap(),
vol_control_entry: builder.get_object("vol_control_entry").unwrap(),
scroll_step_spin: builder.get_object("scroll_step_spin").unwrap(),
fine_scroll_step_spin: builder.get_object("fine_scroll_step_spin")
.unwrap(),
middle_click_combo: builder.get_object("middle_click_combo")
.unwrap(),
custom_entry: builder.get_object("custom_entry").unwrap(),
/* NotifyPrefs */
#[cfg(feature = "notify")]
noti_enable_check: builder.get_object("noti_enable_check").unwrap(),
#[cfg(feature = "notify")]
noti_timeout_spin: builder.get_object("noti_timeout_spin").unwrap(),
// noti_hotkey_check: builder.get_object("noti_hotkey_check").unwrap(),
#[cfg(feature = "notify")]
noti_mouse_check: builder.get_object("noti_mouse_check").unwrap(),
#[cfg(feature = "notify")]
noti_popup_check: builder.get_object("noti_popup_check").unwrap(),
#[cfg(feature = "notify")]
noti_ext_check: builder.get_object("noti_ext_check").unwrap(),
};
#[cfg(feature = "notify")]
let notify_tab: gtk::Box = builder.get_object("noti_vbox_enabled")
.unwrap();
#[cfg(not(feature = "notify"))]
let notify_tab: gtk::Box = builder.get_object("noti_vbox_disabled")
.unwrap();
prefs_dialog.notebook.append_page(&notify_tab,
Some(&gtk::Label::new(Some("Notifications"))));
return prefs_dialog;
}
fn from_prefs(&self, prefs: &Prefs) {
/* DevicePrefs */
/* filled on show signal with audio info */
self.card_combo.remove_all();
self.chan_combo.remove_all();
/* ViewPrefs */
self.vol_meter_draw_check.set_active(prefs.view_prefs.draw_vol_meter);
self.vol_meter_pos_spin.set_value(prefs.view_prefs.vol_meter_offset as
f64);
let rgba = gdk::RGBA {
red: prefs.view_prefs.vol_meter_color.red,
green: prefs.view_prefs.vol_meter_color.green,
blue: prefs.view_prefs.vol_meter_color.blue,
alpha: 1.0,
};
self.vol_meter_color_button.set_rgba(&rgba);
self.system_theme.set_active(prefs.view_prefs.system_theme);
/* BehaviorPrefs */
self.unmute_on_vol_change
.set_active(prefs.behavior_prefs.unmute_on_vol_change);
self.vol_control_entry.set_text(prefs.behavior_prefs
.vol_control_cmd
.as_ref()
.unwrap_or(&String::from(""))
.as_str());
self.scroll_step_spin.set_value(prefs.behavior_prefs.vol_scroll_step);
self.fine_scroll_step_spin
.set_value(prefs.behavior_prefs.vol_fine_scroll_step);
// TODO: make sure these values always match, must be a better way
// also check to_prefs()
self.middle_click_combo.append_text("Toggle Mute");
self.middle_click_combo.append_text("Show Preferences");
self.middle_click_combo.append_text("Volume Control");
self.middle_click_combo.append_text("Custom Command (set below)");
self.middle_click_combo.set_active(prefs.behavior_prefs
.middle_click_action
.into());
self.custom_entry.set_text(prefs.behavior_prefs
.custom_command
.as_ref()
.unwrap_or(&String::from(""))
.as_str());
/* NotifyPrefs */
#[cfg(feature = "notify")]
{
self.noti_enable_check
.set_active(prefs.notify_prefs.enable_notifications);
self.noti_timeout_spin
.set_value(prefs.notify_prefs.notifcation_timeout as f64);
self.noti_mouse_check
.set_active(prefs.notify_prefs.notify_mouse_scroll);
self.noti_popup_check.set_active(prefs.notify_prefs.notify_popup);
self.noti_ext_check.set_active(prefs.notify_prefs.notify_external);
}
}
fn to_prefs(&self) -> Prefs {
let card = self.card_combo.get_active_text();
let channel = self.chan_combo.get_active_text();
if card.is_none() || channel.is_none() {
return Prefs::default();
}
let device_prefs = DevicePrefs {
card: self.card_combo.get_active_text().unwrap(),
channel: self.chan_combo.get_active_text().unwrap(),
};
let vol_meter_color = VolColor {
red: (self.vol_meter_color_button.get_rgba().red),
green: (self.vol_meter_color_button.get_rgba().green),
blue: (self.vol_meter_color_button.get_rgba().blue),
};
let view_prefs = ViewPrefs {
draw_vol_meter: self.vol_meter_draw_check.get_active(),
vol_meter_offset: self.vol_meter_pos_spin.get_value_as_int(),
system_theme: self.system_theme.get_active(),
vol_meter_color,
};
let vol_control_cmd =
self.vol_control_entry.get_text().and_then(|x| if x.is_empty() {
None
} else {
Some(x)
});
let custom_command =
self.custom_entry.get_text().and_then(|x| if x.is_empty() {
None
} else {
Some(x)
});
let behavior_prefs = BehaviorPrefs {
unmute_on_vol_change: self.unmute_on_vol_change.get_active(),
vol_control_cmd,
vol_scroll_step: self.scroll_step_spin.get_value(),
vol_fine_scroll_step: self.fine_scroll_step_spin.get_value(),
middle_click_action: self.middle_click_combo.get_active().into(),
custom_command,
};
#[cfg(feature = "notify")]
let notify_prefs = NotifyPrefs {
enable_notifications: self.noti_enable_check.get_active(),
notifcation_timeout: self.noti_timeout_spin.get_value_as_int() as
i64,
notify_mouse_scroll: self.noti_mouse_check.get_active(),
notify_popup: self.noti_popup_check.get_active(),
notify_external: self.noti_ext_check.get_active(),
};
return Prefs {
device_prefs,
view_prefs,
behavior_prefs,
#[cfg(feature = "notify")]
notify_prefs,
};
}
}
pub fn show_prefs_dialog(appstate: &Rc<AppS>) {
if appstate.gui
.prefs_dialog
.borrow()
.is_some() {
return;
}
*appstate.gui.prefs_dialog.borrow_mut() = Some(PrefsDialog::new());
init_prefs_dialog(&appstate);
{
let m_pd = appstate.gui.prefs_dialog.borrow();
let prefs_dialog = &m_pd.as_ref().unwrap();
let prefs_dialog_w = &prefs_dialog.prefs_dialog;
prefs_dialog.from_prefs(&appstate.prefs.borrow());
prefs_dialog_w.set_transient_for(&appstate.gui.popup_menu.menu_window);
prefs_dialog_w.present();
}
}
pub fn init_prefs_callback(appstate: Rc<AppS>) {
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
/* skip if prefs window is not present */
if apps.gui
.prefs_dialog
.borrow()
.is_none() {
return;
}
match (s, u) {
(AudioSignal::CardInitialized, _) => (),
(AudioSignal::CardCleanedUp, _) => {
fill_card_combo(&apps);
fill_chan_combo(&apps, None);
}
_ => (),
}
}));
}
fn init_prefs_dialog(appstate: &Rc<AppS>) {
/* prefs_dialog.connect_show */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.prefs_dialog.connect_show(move |_| {
fill_card_combo(&apps);
fill_chan_combo(&apps, None);
});
}
/* card_combo.connect_changed */
{
let apps = appstate.clone();
let m_cc = appstate.gui.prefs_dialog.borrow();
let card_combo = &m_cc.as_ref().unwrap().card_combo;
card_combo.connect_changed(move |_| {
let m_cc = apps.gui.prefs_dialog.borrow();
let card_combo = &m_cc.as_ref().unwrap().card_combo;
let card_name = card_combo.get_active_text().unwrap();
fill_chan_combo(&apps, Some(card_name));
return;
});
}
/* prefs_dialog.connect_response */
{
let apps = appstate.clone();
let m_pd = appstate.gui.prefs_dialog.borrow();
let pd = m_pd.as_ref().unwrap();
pd.prefs_dialog.connect_response(move |_, response_id| {
if response_id == ResponseType::Ok.into() ||
response_id == ResponseType::Apply.into() {
let mut prefs = apps.prefs.borrow_mut();
let prefs_dialog = apps.gui.prefs_dialog.borrow();
*prefs = prefs_dialog.as_ref().unwrap().to_prefs();
}
if response_id != ResponseType::Apply.into() {
let mut prefs_dialog = apps.gui.prefs_dialog.borrow_mut();
prefs_dialog.as_ref()
.unwrap()
.prefs_dialog
.destroy();
*prefs_dialog = None;
}
if response_id == ResponseType::Ok.into() ||
response_id == ResponseType::Apply.into() {
// TODO: update hotkeys
try_w!(apps.update_notify());
try_w!(apps.update_tray_icon());
try_w!(apps.update_popup_window());
try_w!(apps.update_audio(AudioUser::PrefsWindow));
try_w!(apps.update_config());
}
});
}
}
fn fill_card_combo(appstate: &AppS) {
let m_cc = appstate.gui.prefs_dialog.borrow();
let card_combo = &m_cc.as_ref().unwrap().card_combo;
card_combo.remove_all();
let acard = appstate.audio.acard.borrow();
/* set card combo */
let cur_card_name = try_w!(acard.card_name(),
"Can't get current card name!");
let available_card_names = get_playable_alsa_card_names();
/* set_active_id doesn't work, so save the index */
let mut c_index: i32 = -1;
for i in 0..available_card_names.len() {
let name = available_card_names.get(i).unwrap();
if *name == cur_card_name {
c_index = i as i32;
}
card_combo.append_text(&name);
}
// TODO, block signal?
card_combo.set_active(c_index);
}
fn fill_chan_combo(appstate: &AppS, cardname: Option<String>) {
let m_cc = appstate.gui.prefs_dialog.borrow();
let chan_combo = &m_cc.as_ref().unwrap().chan_combo;
chan_combo.remove_all();
let cur_acard = appstate.audio.acard.borrow();
let card = match cardname {
Some(name) => try_w!(get_alsa_card_by_name(name).from_err()),
None => cur_acard.as_ref().card,
};
/* set chan combo */
let cur_chan_name = try_w!(cur_acard.chan_name());
let mixer = try_w!(get_mixer(&card));
let available_chan_names = get_playable_selem_names(&mixer);
/* set_active_id doesn't work, so save the index */
let mut c_index: i32 = -1;
for i in 0..available_chan_names.len() {
let name = available_chan_names.get(i).unwrap();
if *name == cur_chan_name {
c_index = i as i32;
}
chan_combo.append_text(&name);
}
/* TODO, block signal?`*/
chan_combo.set_active(c_index);
}