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

Compare commits

merge into: hasufell:master
Branches Tags
hasufell:master
hasufell:audio-reload
hasufell:pulseaudio
hasufell:audio_trait
hasufell:gh-pages
hasufell:hotkeys
hasufell:travis
hasufell:doc
hasufell:dev
...
pull from: hasufell:dev
Branches Tags
hasufell:audio-reload
hasufell:master
hasufell:pulseaudio
hasufell:audio_trait
hasufell:gh-pages
hasufell:hotkeys
hasufell:travis
hasufell:doc
hasufell:dev

No commits in common. "master" and "dev" have entirely different histories.
master ... dev

44 changed files with 1879 additions and 3938 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

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

4
.gitmodules vendored Normal file
View File

@ -0,0 +1,4 @@
[submodule "3rdparty/libnotify"]
path = 3rdparty/libnotify
url = https://github.com/hasufell/rust-libnotify.git
branch = git-deps

41
.travis.yml
View File

@ -1,41 +0,0 @@
dist: trusty
sudo: false
language: rust
rust:
- nightly
- beta
- stable
addons:
apt:
packages:
- libasound2-dev
- libgdk-pixbuf2.0-dev
- libglib2.0-dev
- libgtk-3-dev
- libnotify-dev
- libx11-dev
- pkg-config
# for build.sh
- gperf
- libegl1-mesa-dev
- libfreetype6-dev
- libmount-dev
- libpng-dev
- libxml-parser-perl
- libxtst-dev
- xutils-dev
before_script:
- |
pip install 'travis-cargo<0.2' --user &&
export PATH=$HOME/.local/bin:$PATH
script:
- |
./.travis/build.sh
# travis-cargo test &&
# travis-cargo --only stable doc
# after_success:
# - travis-cargo --only stable doc-upload
env:
global:
- TRAVIS_CARGO_NIGHTLY_FEATURE=""
# - secure:

15
.travis/build.sh
View File

@ -1,15 +0,0 @@
#!/bin/sh
set -x
set -e
BUNDLE="gtk-3.18.1-2"
WD="$PWD"
cd "$HOME"
git clone https://github.com/gkoz/gtk-bootstrap.git
cd gtk-bootstrap
./bootstrap.sh "$WD/.travis/manifest.txt"
cd "$WD"
export PKG_CONFIG_PATH="$HOME/local/lib/pkgconfig"
travis-cargo build

13
.travis/manifest.txt
View File

@ -1,13 +0,0 @@
https://dbus.freedesktop.org/releases/dbus/dbus-1.11.14.tar.gz
https://launchpad.net/intltool/trunk/0.51.0/+download/intltool-0.51.0.tar.gz
https://github.com/anholt/libepoxy/releases/download/1.4.3/libepoxy-1.4.3.tar.xz
https://www.freedesktop.org/software/fontconfig/release/fontconfig-2.12.4.tar.gz
https://www.freedesktop.org/software/harfbuzz/release/harfbuzz-1.4.6.tar.bz2
https://download.gnome.org/sources/glib/2.53/glib-2.53.3.tar.xz
https://download.gnome.org/sources/atk/2.25/atk-2.25.2.tar.xz
https://download.gnome.org/sources/at-spi2-core/2.25/at-spi2-core-2.25.4.tar.xz
https://download.gnome.org/sources/at-spi2-atk/2.25/at-spi2-atk-2.25.3.tar.xz
https://www.cairographics.org/releases/cairo-1.14.10.tar.xz
https://download.gnome.org/sources/pango/1.40/pango-1.40.6.tar.xz
https://download.gnome.org/sources/gdk-pixbuf/2.36/gdk-pixbuf-2.36.6.tar.xz
https://download.gnome.org/sources/gtk+/3.22/gtk+-3.22.16.tar.xz

1
3rdparty/libnotify vendored Submodule

@ -0,0 +1 @@
Subproject commit 5b26d19aa92316a9555b0b22d2d7c3a2721a33dc

113
Cargo.toml
View File

@ -1,83 +1,50 @@
[package]
name = "pnmixer"
version = "0.1.0"
authors = ["Julian Ospald <hasufell@posteo.de>"]
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"
[dependencies]
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]
features = [
"v3_10",
"v3_12",
"v3_22",
]
version = "0.7.0"
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 = { path = "3rdparty/libnotify", optional = true }
[dependencies.gtk]
features = [
"v3_10",
"v3_12",
"v3_22",
]
version = "0.3.0"
git = "https://github.com/gtk-rs/gtk.git"
features = [ "v3_10", "v3_12", "v3_22" ]
[dependencies.gdk]
git = "https://github.com/gtk-rs/gdk.git"
features = [ "v3_10", "v3_12", "v3_22" ]
[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.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

35
README.md
View File

@ -1,16 +1,10 @@
[![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
==========
About
-----
Rewrite of [nicklan/pnmixer](https://github.com/nicklan/pnmixer) in
Rewrite of [nickaln/pnmixer](https://github.com/nicklan/pnmixer) in
[Rust](https://www.rust-lang.org).
This is meant as a drop-in replacement, but may diverge in feature set
@ -27,30 +21,3 @@ the cloned repository:
```sh
cargo install
```
Features/Differences
--------
Additonal features compared to [nicklan/pnmixer](https://github.com/nicklan/pnmixer):
* decide whether to unmute or not on explicit volume change
* updates tray icon on icon theme change
Removed features:
* normalize volume
* slider orientation of volume popup
* settings for displaying text volume on volume popup
* gtk+:2 support
Differences:
* volume slider is shown even when volume is muted
TODO
----
- [x] [hotkey support](https://github.com/hasufell/pnmixer-rust/issues/5)
- [ ] [translation](https://github.com/hasufell/pnmixer-rust/issues/4)
- [X] [documentation](https://github.com/hasufell/pnmixer-rust/issues/3)
- [ ] [PulseAudio support](https://github.com/hasufell/pnmixer-rust/issues/11)

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

@ -666,46 +666,6 @@
<property name="margin_top">5</property>
<property name="margin_bottom">5</property>
<property name="orientation">vertical</property>
<child>
<object class="GtkFrame">
<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="GtkGrid">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkCheckButton" id="unmute_on_vol_change">
<property name="label" translatable="yes">Unmute on volume change</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="receives_default">False</property>
<property name="draw_indicator">True</property>
</object>
<packing>
<property name="left_attach">0</property>
<property name="top_attach">0</property>
</packing>
</child>
</object>
</child>
<child type="label">
<object class="GtkLabel" id="label_g_settings">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">&lt;b&gt;General Settings&lt;/b&gt;</property>
<property name="use_markup">True</property>
</object>
</child>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkFrame" id="frame4">
<property name="visible">True</property>
@ -736,7 +696,7 @@
<property name="expand">False</property>
<property name="fill">False</property>
<property name="padding">5</property>
<property name="position">1</property>
<property name="position">0</property>
</packing>
</child>
<child>
@ -826,7 +786,7 @@
<property name="expand">False</property>
<property name="fill">False</property>
<property name="padding">5</property>
<property name="position">2</property>
<property name="position">1</property>
</packing>
</child>
<child>
@ -906,7 +866,7 @@
<property name="expand">False</property>
<property name="fill">False</property>
<property name="padding">5</property>
<property name="position">3</property>
<property name="position">2</property>
</packing>
</child>
</object>

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

@ -1,13 +1,7 @@
//! Alsa audio subsystem.
//!
//! This mod mainly defines the `AlsaCard` struct, which is the only data
//! structure interacting directly with the alsa library.
//! No other struct should directly interact with the alsa bindings.
use alsa_lib::card::Card;
use alsa_lib::mixer::{Mixer, Selem, SelemId};
use alsa_lib::poll::PollDescriptors;
use alsa::card::Card;
use alsa::mixer::SelemChannelId::*;
use alsa::mixer::{Mixer, Selem, SelemId};
use alsa::poll::PollDescriptors;
use alsa_sys;
use errors::*;
use glib_sys;
@ -19,62 +13,33 @@ 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 {
/// 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>> {
pub fn new(card_name: Option<String>,
elem_name: Option<String>,
cb: Rc<Fn(AlsaEvent)>)
-> Result<Box<AlsaCard>> {
let card = {
match card_name {
Some(name) => {
@ -83,9 +48,7 @@ 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 {
@ -93,10 +56,8 @@ 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()?
}
}
@ -108,10 +69,9 @@ 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(_) => {
@ -124,35 +84,84 @@ impl AlsaCard {
let vec_pollfd = PollDescriptors::get(&mixer)?;
let acard = Box::new(AlsaCard {
_cannot_construct: (),
card,
mixer,
selem_id,
watch_ids: Cell::new(vec![]),
cb,
});
_cannot_construct: (),
card: card,
mixer: mixer,
selem_id: selem_id,
watch_ids: Cell::new(vec![]),
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);
}
/// Get the `Selem`, looked up by the `SelemId`.
pub fn selem(&self) -> Selem {
let selem_id = &self.selem_id;
let selem = self.mixer.find_selem(selem_id);
return selem.unwrap();
pub fn card_name(&self) -> Result<String> {
return self.card.get_name().from_err();
}
/// 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> {
pub fn chan_name(&self) -> Result<String> {
let n = self.selem_id
.get_name()
.map(|y| String::from(y))?;
return Ok(n);
}
pub fn selem(&self) -> Selem {
return self.mixer.find_selem(&self.selem_id).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> {
let mut watch_ids: Vec<c_uint> = vec![];
let acard_ptr =
unsafe { mem::transmute::<&AlsaCard, glib_sys::gpointer>(acard) };
@ -176,7 +185,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 {
@ -188,7 +197,19 @@ impl AlsaCard {
impl Drop for AlsaCard {
/// Destructs the watch IDs corresponding to the current poll descriptors.
// 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>
fn drop(&mut self) {
debug!("Destructing watch_ids: {:?}", self.watch_ids.get_mut());
AlsaCard::unwatch_poll_descriptors(&self.watch_ids.get_mut());
@ -196,12 +217,10 @@ impl Drop for AlsaCard {
}
/// 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 {
extern "C" fn watch_cb(chan: *mut glib_sys::GIOChannel,
cond: glib_sys::GIOCondition,
data: glib_sys::gpointer)
-> glib_sys::gboolean {
let acard =
unsafe { mem::transmute::<glib_sys::gpointer, &AlsaCard>(data) };
@ -221,18 +240,18 @@ extern "C" fn watch_cb(
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,
buf.as_mut_ptr() as *mut u8,
256,
&mut sread as *mut size_t,
ptr::null_mut(),
)
};
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())
};
match stat {
glib_sys::G_IO_STATUS_AGAIN => {
debug!("G_IO_STATUS_AGAIN");
continue;
}
glib_sys::G_IO_STATUS_NORMAL => {
@ -244,9 +263,7 @@ extern "C" fn watch_cb(
error!("GIO error has occurred");
cb(AlsaEvent::AlsaCardError);
}
_ => {
error!("Internal error: unknown status!");
},
_ => warn!("Unknown status from g_io_channel_read_chars()"),
}
return true as glib_sys::gboolean;
}

144
src/app_state.rs
View File

@ -1,16 +1,10 @@
//! Global application state.
use audio::alsa::backend::*;
use audio::frontend::*;
use audio::{Audio, AudioUser};
use errors::*;
use gtk;
use hotkeys::Hotkeys;
use prefs::*;
use std::cell::RefCell;
use std::rc::Rc;
use support::audio::*;
use ui::entry::Gui;
use support_audio::*;
use ui_entry::Gui;
#[cfg(feature = "notify")]
use notif::*;
@ -18,131 +12,81 @@ use notif::*;
// TODO: destructors
/// The global application state struct.
pub struct AppS<T>
where
T: AudioFrontend,
{
pub struct AppS {
_cant_construct: (),
/// Mostly static GUI state.
pub gui: Gui,
/// Audio state.
pub audio: Rc<T>,
/// Preferences state.
pub audio: Audio,
pub prefs: RefCell<Prefs>,
#[cfg(feature = "notify")]
/// 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.
pub notif: Notif,
}
/// 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 {
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"
)));
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"
)));
// TODO: better error handling
#[cfg(feature = "notify")]
let notif = result_warn!(Notif::new(&prefs.borrow()), None).ok();
let hotkeys =
unwrap_error!(
wresult_warn!(Hotkeys::new(&prefs.borrow(), audio.clone()), None),
None
);
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());
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();
return AppS {
_cant_construct: (),
gui,
audio,
prefs,
#[cfg(feature = "notify")]
notif,
hotkeys: RefCell::new(hotkeys),
};
_cant_construct: (),
gui,
audio: Audio::new(Some(card_name), Some(chan_name)).unwrap(),
prefs,
#[cfg(feature = "notify")]
notif,
};
}
/* 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.as_ref(),
None,
);
return self.gui.tray_icon.update_all(&self.prefs.borrow(),
&self.audio,
None);
}
/// Update the Popup Window state.
pub fn update_popup_window(&self) -> Result<()> {
debug!("Update PopupWindow!");
return self.gui.popup_window.update(self.audio.as_ref());
return self.gui.popup_window.update(&self.audio);
}
#[cfg(feature = "notify")]
/// 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")
}
}
pub fn update_notify(&self) -> Result<()> {
return self.notif.reload(&self.prefs.borrow());
}
#[cfg(not(feature = "notify"))]
/// 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.as_ref(), &self.prefs.borrow(), user);
pub fn update_notify(&self) -> Result<()> {
return Ok(());
}
pub fn update_audio(&self, user: AudioUser) -> Result<()> {
return audio_reload(&self.audio, &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);
}
}

345
src/audio.rs Normal file
View File

@ -0,0 +1,345 @@
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) -> 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 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) -> 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);
}
pub fn decrease_vol(&self, user: AudioUser) -> 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);
}
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
View File

@ -1,356 +0,0 @@
#![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,
);
}
}
}

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

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

167
src/audio/frontend.rs
View File

@ -1,167 +0,0 @@
#![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
View File

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

78
src/bin.rs
View File

@ -1,78 +0,0 @@
#![feature(alloc_system)]
extern crate alloc_system;
extern crate getopts;
extern crate pnmixerlib;
use pnmixerlib::*;
use app_state::*;
use getopts::Options;
use std::rc::Rc;
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
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");
let matches = match opts.parse(&args[1..]) {
Ok(m) => { m }
Err(f) => { panic!(f.to_string()) }
};
if matches.opt_present("h") {
print_usage(opts);
return;
}
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();
// TODO: clean deallocation?
}
fn print_usage(opts: Options) {
let brief = format!("Usage: pnmixer-rs [options]");
print!("{}", opts.usage(&brief));
}

163
src/errors.rs
View File

@ -1,8 +1,5 @@
#![allow(missing_docs)]
use alsa_lib;
use alsa;
use glib;
use png;
use std::convert::From;
use std;
use toml;
@ -11,18 +8,9 @@ use toml;
error_chain! {
foreign_links {
Alsa(alsa_lib::Error);
Alsa(alsa::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)
}
}
}
@ -30,8 +18,6 @@ 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, ())
@ -46,8 +32,6 @@ 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,
@ -76,8 +60,6 @@ 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,
@ -88,18 +70,31 @@ 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) => (match $expr {
($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 {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => {
error!("{:?}", err);
::std::process::exit(1);
},
});
($expr:expr, $fmt:expr) => (match $expr {
($expr:expr, $ret:expr, $fmt:expr) => (match $expr {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => {
error!("Original error: {:?}", err);
@ -107,7 +102,7 @@ macro_rules! try_e {
std::process::exit(1);
},
});
($expr:expr, $fmt:expr, $($arg:tt)+) => (match $expr {
($expr:expr, $ret:expr, $fmt:expr, $($arg:tt)+) => (match $expr {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => {
error!("Original error: {:?}", err);
@ -116,121 +111,3 @@ macro_rules! try_e {
},
})
}
#[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);
},
});
}

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

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

189
src/hotkey.rs
View File

@ -1,189 +0,0 @@
//! 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
View File

@ -1,301 +0,0 @@
//! 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;
}

87
src/lib.rs
View File

@ -1,87 +0,0 @@
//! 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]
extern crate log;
#[macro_use]
extern crate error_chain;
#[macro_use]
extern crate serde_derive;
extern crate toml;
extern crate serde;
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;
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;
pub mod app_state;
pub mod audio;
pub mod hotkey;
pub mod hotkeys;
pub mod prefs;
#[macro_use]
pub mod support;
#[macro_use]
pub mod ui;
#[cfg(feature = "notify")]
pub mod notif;

90
src/main.rs Normal file
View File

@ -0,0 +1,90 @@
#![feature(alloc_system)]
extern crate alloc_system;
extern crate flexi_logger;
#[macro_use]
extern crate log;
#[macro_use]
extern crate error_chain;
#[macro_use]
extern crate serde_derive;
extern crate toml;
extern crate serde;
extern crate alsa;
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;
extern crate gtk;
extern crate gtk_sys;
extern crate libc;
extern crate which;
extern crate xdg;
#[cfg(feature = "notify")]
extern crate libnotify;
use std::rc::Rc;
#[macro_use]
mod errors;
#[macro_use]
mod glade_helpers;
mod alsa_card;
mod app_state;
mod audio;
mod prefs;
mod support_alsa;
mod support_audio;
mod support_cmd;
mod support_ui;
mod ui_entry;
mod ui_popup_menu;
mod ui_popup_window;
mod ui_prefs_dialog;
mod ui_tray_icon;
#[cfg(feature = "notify")]
mod notif;
use app_state::*;
#[cfg(feature = "notify")]
use libnotify::*;
fn main() {
gtk::init().unwrap();
// TODO: error handling
#[cfg(feature = "notify")]
init("PNMixer-rs").unwrap();
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 apps = Rc::new(AppS::new());
ui_entry::init(apps);
gtk::main();
#[cfg(feature = "notify")]
uninit();
}

131
src/notif.rs
View File

@ -1,27 +1,37 @@
//! The notification subsystem.
//!
//! This subsystem utilizes libnotify to send notifications as popups
//! to the desktop.
use app_state::*;
use audio::frontend::*;
use audio::*;
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::*;
// TODO: more notifications, such as on alsa error
/// 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>,
from_hotkeys: Cell<bool>,
// TODO: from hotkey
from_external: Cell<bool>,
volume_notif: libnotify::Notification,
@ -29,59 +39,44 @@ 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);
}
/// Reload the notification instance from the current
/// preferences.
pub fn reload(&self, prefs: &Prefs) {
pub fn reload(&self, prefs: &Prefs) -> Result<()> {
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()),
);
self.text_notif
.set_hint("x-canonical-private-synchronous", Some("".to_variant()));
return Ok(());
}
/// 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()?;
pub fn show_volume_notif(&self, audio: &Audio) -> Result<()> {
let vol = audio.vol()?;
let vol_level = audio.vol_level();
let icon = {
@ -98,80 +93,68 @@ impl Notif {
match vol_level {
VolLevel::Muted => String::from("Volume muted"),
_ => {
format!(
"{} ({})\nVolume: {}",
audio.card_name()?,
audio.chan_name()?,
vol as i32
)
format!("{} ({})\nVolume: {}",
audio.acard
.borrow()
.card_name()?,
audio.acard
.borrow()
.chan_name()?,
vol)
}
}
};
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()?;
// 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();
return Ok(());
}
/// Shows a text notification, e.g. for warnings or errors.
pub fn show_text_notif(&self, summary: &str, body: &str) -> Result<()> {
self.text_notif.update(summary, Some(body), None)?;
self.text_notif.show()?;
// TODO: error handling
self.text_notif.update(summary, Some(body), None).unwrap();
// TODO: error handling
self.text_notif.show().unwrap();
return Ok(());
}
}
impl Drop for Notif {
fn drop(&mut self) {
libnotify::uninit();
}
}
/// Initialize the notification subsystem.
pub fn init_notify<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
pub fn init_notify(appstate: Rc<AppS>) {
debug!("Blah");
{
/* connect handler */
let apps = appstate.clone();
appstate.audio.connect_handler(Box::new(move |s, u| {
let notif = &apps.notif;
if notif.is_none() || !notif.as_ref().unwrap().enabled.get() {
if !notif.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_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...")),
notif.from_external.get())) {
// TODO
(AudioSignal::CardDisconnected, _, _) => (),
(AudioSignal::CardError, _, _) => (),
(AudioSignal::ValuesChanged,
AudioUser::TrayIcon,
(_, true, _, _)) => try_w!(notif.show_volume_notif(apps.audio.as_ref())),
(_, true, _)) => try_w!(notif.show_volume_notif(&apps.audio)),
(AudioSignal::ValuesChanged,
AudioUser::Popup,
(true, _, _, _)) => try_w!(notif.show_volume_notif(apps.audio.as_ref())),
(true, _, _)) => try_w!(notif.show_volume_notif(&apps.audio)),
(AudioSignal::ValuesChanged,
AudioUser::Unknown,
(_, _, 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())),
(_, _, true)) => try_w!(notif.show_volume_notif(&apps.audio)),
_ => (),
}
}));

129
src/prefs.rs
View File

@ -1,12 +1,3 @@
#![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;
@ -27,7 +18,6 @@ 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,
@ -70,49 +60,46 @@ impl From<MiddleClickAction> for i32 {
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// Device preferences tab.
pub struct DevicePrefs {
pub card: String,
pub channel: String,
pub channel: String,
// TODO: normalize volume?
}
impl Default for DevicePrefs {
fn default() -> DevicePrefs {
return DevicePrefs {
card: String::from("(default)"),
channel: String::from("Master"),
};
card: String::from("(default)"),
channel: String::from("Master"),
};
}
}
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// View preferences tab.
pub struct ViewPrefs {
pub draw_vol_meter: bool,
pub vol_meter_offset: i32,
pub system_theme: bool,
pub vol_meter_color: VolColor,
pub vol_meter_color: VolColor,
// TODO: Display text folume/text volume pos?
}
impl Default for ViewPrefs {
fn default() -> ViewPrefs {
return ViewPrefs {
draw_vol_meter: true,
vol_meter_offset: 10,
system_theme: true,
vol_meter_color: VolColor::default(),
};
draw_vol_meter: true,
vol_meter_offset: 10,
system_theme: true,
vol_meter_color: VolColor::default(),
};
}
}
#[derive(Deserialize, Debug, Serialize)]
#[serde(default)]
/// Volume color setting in the view preferences tab.
pub struct VolColor {
pub red: f64,
pub green: f64,
@ -122,36 +109,33 @@ pub struct VolColor {
impl Default for VolColor {
fn default() -> VolColor {
return VolColor {
red: 0.960784313725,
green: 0.705882352941,
blue: 0.0,
};
red: 0.960784313725,
green: 0.705882352941,
blue: 0.0,
};
}
}
#[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>,
pub custom_command: Option<String>, // TODO: fine scroll step?
}
impl Default for BehaviorPrefs {
fn default() -> BehaviorPrefs {
return BehaviorPrefs {
unmute_on_vol_change: true,
vol_control_cmd: None,
vol_scroll_step: 5.0,
vol_fine_scroll_step: 1.0,
middle_click_action: MiddleClickAction::default(),
custom_command: None,
};
vol_control_cmd: None,
vol_scroll_step: 5.0,
vol_fine_scroll_step: 1.0,
middle_click_action: MiddleClickAction::default(),
custom_command: None,
};
}
}
@ -159,52 +143,38 @@ 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,
pub notify_hotkeys: bool,
pub notify_external: bool,
// TODO: notify_hotkeys?
}
#[cfg(feature = "notify")]
impl Default for NotifyPrefs {
fn default() -> NotifyPrefs {
return NotifyPrefs {
enable_notifications: true,
notifcation_timeout: 1500,
notify_mouse_scroll: true,
notify_popup: true,
notify_external: true,
notify_hotkeys: true,
};
enable_notifications: true,
notifcation_timeout: 1500,
notify_mouse_scroll: true,
notify_popup: true,
notify_external: 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,
pub hotkey_prefs: HotkeyPrefs,
pub notify_prefs: NotifyPrefs,
// TODO: HotKeys?
}
impl Prefs {
@ -235,8 +205,6 @@ impl Prefs {
}
// TODO: unused
/// Reload the current preferences from the config file.
pub fn reload_config(&mut self) -> Result<()> {
debug!("Reloading config...");
@ -247,43 +215,24 @@ 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")
.chain_err(|| {
format!(
"Could not create config directory at {:?}",
get_xdg_dirs().get_config_home()
)
})?;
let config_path = get_xdg_dirs().place_config_file("pnmixer.toml")
.from_err()?;
debug!("Storing config in {:?}", config_path);
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)
})?;
let mut f = File::create(config_path)?;
f.write_all(self.to_str().as_bytes())?;
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()),
@ -301,17 +250,15 @@ 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();
}

113
src/support/audio.rs
View File

@ -1,113 +0,0 @@
#![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
View File

@ -1,31 +0,0 @@
//! 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
View File

@ -1,82 +0,0 @@
//! 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,
));
}
}

13
src/support/mod.rs
View File

@ -1,13 +0,0 @@
//! 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;

70
src/support/ui.rs
View File

@ -1,70 +0,0 @@
//! Helper functions for the UI, mostly pixbuf functions.
use errors::*;
use gdk_pixbuf;
use gtk::prelude::*;
use gtk;
use std::path::*;
/// 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> {
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 {:?}",
icon_name,
icon_info.get_filename().unwrap_or(PathBuf::new())
);
// TODO: propagate error
let pixbuf = icon_info.load_icon().unwrap();
return Ok(pixbuf);
}
#[macro_export]
/// 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;
use png;
let bytes = include_bytes!($name);
let pixbuf_new_from_bytes = |bytes| -> Result<gdk_pixbuf::Pixbuf> {
let decoder = png::Decoder::new(bytes);
let (info, mut reader) = decoder.read_info()?;
let mut buf = vec![0; info.buffer_size()];
reader.next_frame(&mut buf).unwrap();
ensure!(info.color_type == png::ColorType::RGB ||
info.color_type == png::ColorType::RGBA,
"Only RGB is supported for GDKPixbuf");
debug!("Loading icon from {}", $name);
return Ok(gdk_pixbuf::Pixbuf::new_from_vec(buf,
gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
true,
info.bit_depth as i32,
info.width as i32,
info.height as i32,
info.line_size as i32));
};
pixbuf_new_from_bytes(bytes as &[u8])
}
}
}

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

@ -1,36 +1,28 @@
//! Alsa audio helper functions.
//!
//! This mod wraps around a few low-level alsa functions and abstracts
//! out the details we don't care about.
use alsa_lib::card::Card;
use alsa_lib::mixer::{Mixer, Selem, Elem};
use alsa_lib;
use alsa::card::Card;
use alsa::mixer::{Mixer, Selem, SelemId, Elem};
use alsa;
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);
}
/// Get all available alsa cards.
pub fn get_alsa_cards() -> alsa_lib::card::Iter {
return alsa_lib::card::Iter::new();
pub fn get_alsa_cards() -> alsa::card::Iter {
return alsa::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 {
@ -47,7 +39,6 @@ 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() {
@ -68,7 +59,6 @@ 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?;
@ -81,7 +71,6 @@ 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) {
@ -93,13 +82,11 @@ 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 Ok(Mixer::new(&format!("hw:{}", card.get_index()), false)?);
return Mixer::new(&format!("hw:{}", card.get_index()), false).from_err();
}
/// 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.
@ -108,7 +95,6 @@ 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) {
@ -118,7 +104,6 @@ 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);
@ -128,7 +113,6 @@ 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) {
@ -143,13 +127,13 @@ pub fn get_playable_selem_names(mixer: &Mixer) -> Vec<String> {
}
/// Get a playable `Selem` by the given name.
pub fn get_playable_selem_by_name(
mixer: &Mixer,
name: String,
) -> Result<Selem> {
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);
@ -159,7 +143,7 @@ pub fn get_playable_selem_by_name(
}
/// Check whether the given `Selem` is playable.
pub fn selem_is_playable(selem: &Selem) -> bool {
return selem.has_playback_volume();
}

58
src/support_audio.rs Normal file
View File

@ -0,0 +1,58 @@
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 Normal file
View File

@ -0,0 +1,26 @@
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();
}

71
src/support_ui.rs Normal file
View File

@ -0,0 +1,71 @@
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,
size: i32,
theme: &gtk::IconTheme)
-> Result<gdk_pixbuf::Pixbuf> {
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 {:?}",
icon_name,
icon_info.get_filename().unwrap_or(PathBuf::new()));
// TODO: propagate error
let pixbuf = icon_info.load_icon().unwrap();
return Ok(pixbuf);
}
pub fn pixbuf_new_from_file(filename: &str) -> Result<gdk_pixbuf::Pixbuf> {
ensure!(!filename.is_empty(), "Filename is empty");
let mut syspath = String::new();
let sysdir = option_env!("PIXMAPSDIR").map(|s| {
syspath = format!("{}/{}",
s,
filename);
Path::new(syspath.as_str())
});
let cargopath = format!("./data/pixmaps/{}", filename);
let cargodir = Path::new(cargopath.as_str());
// prefer local dir
let final_dir = {
if cargodir.exists() {
cargodir
} else if sysdir.is_some() && sysdir.unwrap().exists() {
sysdir.unwrap()
} else {
bail!("No valid path found")
}
};
let str_path = final_dir.to_str().ok_or("Path is not valid unicode")?;
debug!("Loading icon from {}", str_path);
// TODO: propagate error
return Ok(gdk_pixbuf::Pixbuf::new_from_file(str_path).unwrap());
}

137
src/ui/entry.rs
View File

@ -1,137 +0,0 @@
//! 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
View File

@ -1,143 +0,0 @@
//! 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
View File

@ -1,8 +0,0 @@
//! 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;

340
src/ui/popup_window.rs
View File

@ -1,340 +0,0 @@
//! 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
View File

@ -1,725 +0,0 @@
//! 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;
}

103
src/ui_entry.rs Normal file
View File

@ -0,0 +1,103 @@
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;
}

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

@ -1,57 +1,41 @@
#![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::frontend::*;
use audio::{AudioUser, AudioSignal};
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,
menu_window: gtk::Window,
menubar: gtk::MenuBar,
menu: gtk::Menu,
about_item: gtk::MenuItem,
mixer_item: gtk::MenuItem,
mute_item: gtk::MenuItem,
mute_check: gtk::CheckButton,
prefs_item: gtk::MenuItem,
quit_item: gtk::MenuItem,
reload_item: gtk::MenuItem
);
create_builder_item!(PopupMenu,
menu_window: gtk::Window,
menubar: gtk::MenuBar,
menu: gtk::Menu,
about_item: gtk::MenuItem,
mixer_item: gtk::MenuItem,
mute_item: gtk::MenuItem,
mute_check: gtk::CheckButton,
prefs_item: gtk::MenuItem,
quit_item: gtk::MenuItem,
reload_item: gtk::MenuItem);
/// Initialize the popup menu subsystem, registering all callbacks.
pub fn init_popup_menu<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
pub fn init_popup_menu(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_menu.menu.get_visible() {
if !apps.gui
.popup_menu
.menu
.get_visible() {
return;
}
match (s, u) {
@ -64,9 +48,10 @@ where
/* 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));
}
@ -75,10 +60,7 @@ where
let apps = appstate.clone();
let mixer_item = &appstate.gui.popup_menu.mixer_item;
mixer_item.connect_activate(move |_| {
let _ = result_warn!(
execute_vol_control_command(&apps.prefs.borrow()),
Some(&apps.gui.popup_menu.menu_window)
);
try_w!(execute_vol_control_command(&apps.prefs.borrow()));
});
}
@ -86,8 +68,10 @@ where
{
let apps = appstate.clone();
let mute_item = &appstate.gui.popup_menu.mute_item;
mute_item.connect_activate(move |_| if apps.audio.has_mute() {
try_w!(apps.audio.toggle_mute(AudioUser::Popup));
mute_item.connect_activate(move |_| {
if apps.audio.has_mute() {
try_w!(apps.audio.toggle_mute(AudioUser::Popup));
}
});
}
@ -95,18 +79,18 @@ where
{
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 */
@ -114,12 +98,10 @@ where
let apps = appstate.clone();
let reload_item = &appstate.gui.popup_menu.reload_item;
reload_item.connect_activate(move |_| {
try_w!(audio_reload(
apps.audio.as_ref(),
&apps.prefs.borrow(),
AudioUser::Popup,
))
});
try_w!(audio_reload(&apps.audio,
&apps.prefs.borrow(),
AudioUser::Popup))
});
}
@ -131,11 +113,7 @@ where
}
/// When the about menu item is activated.
fn on_about_item_activate<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
fn on_about_item_activate(appstate: &AppS) {
let popup_menu = &appstate.gui.popup_menu.menu_window;
let about_dialog = create_about_dialog();
about_dialog.set_skip_taskbar_hint(true);
@ -145,7 +123,6 @@ where
}
/// Create the About dialog from scratch.
fn create_about_dialog() -> gtk::AboutDialog {
let about_dialog: gtk::AboutDialog = gtk::AboutDialog::new();
@ -176,21 +153,13 @@ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.",
}
/// When the Preferences item is activated.
fn on_prefs_item_activate<T>(appstate: &Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
fn on_prefs_item_activate(appstate: &Rc<AppS>) {
/* TODO: only create if needed */
show_prefs_dialog(appstate);
}
/// When the Mute item is checked.
fn set_mute_check<T>(apps: &Rc<AppS<T>>)
where
T: AudioFrontend,
{
fn set_mute_check(apps: &Rc<AppS>) {
let mute_check = &apps.gui.popup_menu.mute_check;
let m_muted = apps.audio.get_mute();
match m_muted {

295
src/ui_popup_window.rs Normal file
View File

@ -0,0 +1,295 @@
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));
}
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(());
}

403
src/ui_prefs_dialog.rs Normal file
View File

@ -0,0 +1,403 @@
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 */
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(),
card_combo: builder.get_object("card_combo").unwrap(),
chan_combo: builder.get_object("chan_combo").unwrap(),
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(),
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(),
#[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.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 {
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);
}

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

@ -1,12 +1,8 @@
//! 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::frontend::*;
use audio::*;
use errors::*;
use glib;
use gio;
use gdk;
use gdk_pixbuf;
use gdk_pixbuf_sys;
@ -16,34 +12,28 @@ 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;
// TODO tooltip
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;
@ -54,31 +44,20 @@ impl TrayIcon {
RefCell::new(None)
}
};
// 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.
let audio_pix = AudioPix::default();
let audio_pix = AudioPix::new(ICON_MIN_SIZE, prefs)?;
let status_icon = gtk::StatusIcon::new();
return Ok(TrayIcon {
_cant_construct: (),
volmeter,
audio_pix: RefCell::new(audio_pix),
status_icon,
icon_size: Cell::new(ICON_MIN_SIZE),
});
_cant_construct: (),
volmeter,
audio_pix: RefCell::new(audio_pix),
status_icon,
icon_size: Cell::new(ICON_MIN_SIZE),
});
}
/// 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<()> {
fn update_pixbuf(&self, cur_vol: f64, vol_level: VolLevel) -> Result<()> {
let audio_pix = self.audio_pix.borrow();
let pixbuf = audio_pix.select_pix(vol_level);
@ -96,17 +75,22 @@ impl TrayIcon {
}
/// 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()
fn update_audio(&self, audio: &Audio) -> Result<()> {
return self.update_pixbuf(audio.vol()?, audio.vol_level());
}
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()
.map(|s| format!("{}", s.round()))
.unwrap_or(String::from("unknown volume"));
let mute_info = {
@ -118,28 +102,20 @@ impl TrayIcon {
""
}
};
self.status_icon.set_tooltip_text(
format!(
"{} ({})\nVolume: {}{}",
cardname,
channame,
vol,
mute_info
).as_str(),
);
self.status_icon.set_tooltip_text(format!("{} ({})\nVolume: {}{}",
cardname,
channame,
vol,
mute_info)
.as_str());
}
/// Update the whole tray icon state.
pub fn update_all<T>(
&self,
prefs: &Prefs,
audio: &T,
m_size: Option<i32>,
) -> Result<()>
where
T: AudioFrontend,
{
pub fn update_all(&self,
prefs: &Prefs,
audio: &Audio,
m_size: Option<i32>)
-> Result<()> {
match m_size {
Some(s) => {
if s < ICON_MIN_SIZE {
@ -161,15 +137,13 @@ impl TrayIcon {
*self.volmeter.borrow_mut() = Some(volmeter);
}
self.update_tooltip(audio);
return self.update_vol_meter(audio.get_vol()?, audio.vol_level());
self.update_tooltip(&audio);
return self.update_pixbuf(audio.vol()?, audio.vol_level());
}
}
/// The volume meter, describes by its colors, offset and width/row
/// properties.
pub struct VolMeter {
red: u8,
green: u8,
@ -183,64 +157,50 @@ 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,
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,
/* dynamic */
width: Cell::new(0),
row: RefCell::new(vec![]),
};
red: (prefs.view_prefs.vol_meter_color.red * 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,
/* dynamic */
width: Cell::new(0),
row: RefCell::new(vec![]),
};
}
// TODO: cache input pixbuf?
/// 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> {
fn meter_draw(&self,
volume: i64,
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 = pixbuf.copy();
let new_pixbuf = copy_pixbuf(pixbuf);
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,
"x coordinate invalid: {}",
x
);
((i_width - vm_width) as f64 / 100.0)) as i64;
ensure!(x >= 0 && (x + vm_width) <= i_width,
"x coordinate invalid: {}",
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,
"y coordinate invalid: {}",
y
);
ensure!(y >= 0 && (y + vm_height) <= i_height,
"y coordinate invalid: {}",
y);
/* Let's check if the icon width changed, in which case we
* must reinit our internal row of pixels.
@ -276,9 +236,8 @@ 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());
}
}
@ -292,7 +251,6 @@ 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,
@ -301,30 +259,8 @@ pub struct AudioPix {
off: gdk_pixbuf::Pixbuf,
}
impl Default for AudioPix {
fn default() -> AudioPix {
let dummy_pixbuf = unsafe {
gdk_pixbuf::Pixbuf::new(
gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
false,
8,
1,
1,
).unwrap()
};
return AudioPix {
muted: dummy_pixbuf.clone(),
low: dummy_pixbuf.clone(),
medium: dummy_pixbuf.clone(),
high: dummy_pixbuf.clone(),
off: dummy_pixbuf.clone(),
};
}
}
impl AudioPix {
/// Constructor.
fn new(size: i32, prefs: &Prefs) -> Result<AudioPix> {
let system_theme = prefs.view_prefs.system_theme;
@ -372,21 +308,11 @@ impl AudioPix {
}
} else {
AudioPix {
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"
)?,
muted: pixbuf_new_from_file("pnmixer-muted.png")?,
low: pixbuf_new_from_file("pnmixer-low.png")?,
medium: pixbuf_new_from_file("pnmixer-medium.png")?,
high: pixbuf_new_from_file("pnmixer-high.png")?,
off: pixbuf_new_from_file("pnmixer-off.png")?,
}
}
};
@ -394,7 +320,6 @@ 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,
@ -407,43 +332,32 @@ impl AudioPix {
}
/// Initialize the tray icon subsystem.
pub fn init_tray_icon<T>(appstate: Rc<AppS<T>>)
where
T: AudioFrontend + 'static,
{
pub fn init_tray_icon(appstate: Rc<AppS>) {
let audio = &appstate.audio;
let tray_icon = &appstate.gui.tray_icon;
try_e!(tray_icon.update_all(&appstate.prefs.borrow_mut(), &audio, None));
tray_icon.status_icon.set_visible(true);
/* connect audio handler */
{
let apps = appstate.clone();
appstate.audio.connect_handler(
Box::new(move |s, u| match (s, u) {
(_, _) => {
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(),
));
}
}),
);
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_audio(&apps.audio));
}
}));
}
/* 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.as_ref(),
Some(size),
),
false
);
try_wr!(apps.gui.tray_icon.update_all(&apps.prefs.borrow_mut(),
&apps.audio,
Some(size)),
false);
return false;
});
}
@ -451,9 +365,9 @@ where
/* 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 */
@ -479,30 +393,10 @@ where
on_tray_button_release_event(&apps, eb)
});
}
/* default_theme.connect_changed */
{
let apps = appstate.clone();
let default_theme = try_w!(gtk::IconTheme::get_default().ok_or(
"Couldn't get default icon theme",
));
default_theme.connect_changed(move |_| {
let tray_icon = &apps.gui.tray_icon;
try_e!(tray_icon.update_all(
&apps.prefs.borrow_mut(),
apps.audio.as_ref(),
None,
));
});
}
}
/// When the tray icon is activated.
fn on_tray_icon_activate<T>(appstate: &AppS<T>)
where
T: AudioFrontend,
{
fn on_tray_icon_activate(appstate: &AppS) {
let popup_window = &appstate.gui.popup_window.popup_window;
if popup_window.get_visible() {
@ -513,11 +407,7 @@ where
}
/// 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,
{
fn on_tray_icon_popup_menu(appstate: &AppS) {
let popup_window = &appstate.gui.popup_window.popup_window;
let popup_menu = &appstate.gui.popup_menu.menu;
@ -526,43 +416,17 @@ where
}
/// 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,
{
fn on_tray_icon_scroll_event(appstate: &AppS,
event: &gdk::EventScroll)
-> bool {
let scroll_dir: gdk::ScrollDirection = event.get_direction();
match scroll_dir {
gdk::ScrollDirection::Up => {
try_wr!(
appstate.audio.increase_vol(
AudioUser::TrayIcon,
appstate
.prefs
.borrow()
.behavior_prefs
.unmute_on_vol_change,
),
false
);
try_wr!(appstate.audio.increase_vol(AudioUser::TrayIcon), false);
}
gdk::ScrollDirection::Down => {
try_wr!(
appstate.audio.decrease_vol(
AudioUser::TrayIcon,
appstate
.prefs
.borrow()
.behavior_prefs
.unmute_on_vol_change,
),
false
);
try_wr!(appstate.audio.decrease_vol(AudioUser::TrayIcon), false);
}
_ => (),
}
@ -571,16 +435,9 @@ where
}
/// 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,
{
fn on_tray_button_release_event(appstate: &Rc<AppS>,
event_button: &gdk::EventButton)
-> bool {
let button = event_button.get_button();
if button != 2 {
@ -596,25 +453,18 @@ where
match middle_click_action {
&MiddleClickAction::ToggleMute => {
if audio.has_mute() {
try_wr!(audio.toggle_mute(AudioUser::TrayIcon), false);
try_wr!(audio.toggle_mute(AudioUser::Popup), false);
}
}
// TODO
&MiddleClickAction::ShowPreferences => show_prefs_dialog(&appstate),
&MiddleClickAction::VolumeControl => {
let _ = result_warn!(
execute_vol_control_command(&appstate.prefs.borrow()),
Some(&appstate.gui.popup_menu.menu_window)
);
try_wr!(execute_vol_control_command(&appstate.prefs.borrow()),
false);
}
&MiddleClickAction::CustomCommand => {
match custom_command {
&Some(ref cmd) => {
let _ = result_warn!(
execute_command(cmd.as_str()),
Some(&appstate.gui.popup_menu.menu_window)
);
}
&Some(ref cmd) => try_wr!(execute_command(cmd.as_str()), false),
&None => warn!("No custom command found"),
}
}