.gitignore

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

Cargo.toml

@@ -1,83 +1,68 @@
 [package]
-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"
+version = "0.1.0"
-repository = "https://github.com/hasufell/pnmixer-rust"
+authors = ["Julian Ospald <hasufell@posteo.de>"]
-version = "0.1.2"
+
+[lib]
+name = "pnmixerlib"
+path = "src/lib.rs"
+doc = true
 
 [[bin]]
-doc = false
 name = "pnmixer-rs"
 path = "src/bin.rs"
+doc = false
 
 [dependencies]
-alsa = "0.2.0"
+alsa = "^0.1.8"
-alsa-sys = "0.1.1"
+alsa-sys = "^0.1.1"
-error-chain = "0.11.0"
+error-chain = { git = "https://github.com/hasufell/error-chain.git", branch = "PR-from-error" }
-ffi = "0.0.2"
+ffi = "^0.0.2"
-flexi_logger = "0.6.11"
+flexi_logger = "^0.5.1"
-gdk-pixbuf = "0.3.0"
+gdk-pixbuf = { git = "https://github.com/gtk-rs/gdk-pixbuf.git" }
-gdk-pixbuf-sys = "0.5.0"
+gdk-pixbuf-sys = { git = "https://github.com/gtk-rs/sys" }
-gdk-sys = "0.5.0"
+gdk-sys = { git = "https://github.com/gtk-rs/sys" }
-getopts = "0.2.17"
+gio = { git = "https://github.com/gtk-rs/gio.git" }
-gio = "0.3.0"
+glib = { git = "https://github.com/gtk-rs/glib.git" }
-glib = "0.4.1"
+glib-sys = { git = "https://github.com/gtk-rs/sys" }
-glib-sys = "0.5.0"
+gobject-sys = { git = "https://github.com/gtk-rs/sys" }
-gobject-sys = "0.5.0"
+gtk-sys = { git = "https://github.com/gtk-rs/sys" }
-gtk-sys = "0.5.0"
+libc = "^0.2.23"
-lazy_static = "1.0.0"
+log = "^0.3.8"
-libc = "0.2.36"
+serde = "^1.0.9"
-libnotify = { version = "1.0.2", optional = true }
+serde_derive = "^1.0.9"
-log = "0.4.1"
+toml = "^0.4.2"
-png = "0.11.0"
+which = "*"
-serde = "1.0.27"
+xdg = "*"
-serde_derive = "1.0.27"
+libnotify = { git = "https://github.com/hasufell/rust-libnotify.git", branch = "git-deps", optional = true }
-toml = "0.4.5"
+png = "^0.9.0"
-w_result = "0.1.2"
+lazy_static = "^0.2.8"
-which = "1.0.3"
+w_result = "^0.1.2"
-xdg = "2.1.0"
 
-[dependencies.gdk]
-features = [
-    "v3_10",
-    "v3_12",
-    "v3_22",
-]
-version = "0.7.0"
-
-[dependencies.gtk]
-features = [
-    "v3_10",
-    "v3_12",
-    "v3_22",
-]
-version = "0.3.0"
 
 [dependencies.x11]
-features = [
+version = "^2.14.0"
-    "xlib",
+features = ["xlib", "xtst"]
-    "xtst",
+
-]
+[dependencies.gtk]
-version = "2.17.2"
+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'
+
 
 [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

README.md

@@ -1,4 +1,3 @@
-[![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/)
@@ -53,4 +52,3 @@ 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)

src/alsa_card.rs

@@ -0,0 +1,573 @@
+#![allow(illegal_floating_point_literal_pattern)]
+
+//! 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::card::Card;
+use alsa::mixer::SelemChannelId::*;
+use alsa::mixer::{Mixer, Selem, SelemId};
+use alsa::poll::PollDescriptors;
+use alsa_sys;
+use audio::*;
+use errors::*;
+use glib;
+use glib_sys;
+use libc::c_uint;
+use libc::pollfd;
+use libc::size_t;
+use std::cell::Cell;
+use std::cell::RefCell;
+use std::mem;
+use std::ptr;
+use std::rc::Rc;
+use std::u8;
+use support_alsa::*;
+use support_audio::*;
+
+
+
+#[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>> {
+        let card = {
+            match card_name {
+                Some(name) => {
+                    if name == "(default)" {
+                        let default = get_default_alsa_card();
+                        if alsa_card_has_playable_selem(&default) {
+                            default
+                        } else {
+                            warn!("Default alsa card not playabla, trying others");
+                            get_first_playable_alsa_card()?
+                        }
+                    } else {
+                        let mycard = get_alsa_card_by_name(name.clone());
+                        match mycard {
+                            Ok(card) => card,
+                            Err(_) => {
+                                warn!("Card {} not playable, trying others",
+                                      name);
+                                get_first_playable_alsa_card()?
+                            }
+                        }
+                    }
+                }
+                None => get_first_playable_alsa_card()?,
+            }
+        };
+        let mixer = get_mixer(&card)?;
+
+        let selem_id = {
+            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(_) => {
+                    warn!("No playable Selem found, trying others");
+                    get_first_playable_selem(&mixer)?.get_id()
+                }
+            }
+        };
+
+        let vec_pollfd = PollDescriptors::get(&mixer)?;
+
+        let acard = Box::new(AlsaCard {
+                                 _cannot_construct: (),
+                                 card,
+                                 mixer,
+                                 selem_id,
+                                 watch_ids: Cell::new(vec![]),
+                                 cb,
+                             });
+
+        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`.
+    fn selem(&self) -> Selem {
+        let selem_id = &self.selem_id;
+        let selem = self.mixer.find_selem(selem_id);
+        return selem.unwrap();
+    }
+
+    /// Watch the given alsa card poll descriptors and
+    /// return the corresponding watch IDs for saving
+    /// in the `AlsaCard` struct.
+    fn watch_poll_descriptors(polls: Vec<pollfd>,
+                              acard: &AlsaCard)
+                              -> Vec<c_uint> {
+        let mut watch_ids: Vec<c_uint> = vec![];
+        let acard_ptr =
+            unsafe { mem::transmute::<&AlsaCard, glib_sys::gpointer>(acard) };
+        for poll in polls {
+            let gioc: *mut glib_sys::GIOChannel =
+                unsafe { glib_sys::g_io_channel_unix_new(poll.fd) };
+            let id = unsafe {
+                glib_sys::g_io_add_watch(
+                    gioc,
+                    glib_sys::GIOCondition::from_bits(
+                        glib_sys::G_IO_IN.bits() | glib_sys::G_IO_ERR.bits(),
+                    ).unwrap(),
+                    Some(watch_cb),
+                    acard_ptr,
+                )
+            };
+            watch_ids.push(id);
+            unsafe { glib_sys::g_io_channel_unref(gioc) }
+        }
+
+        return watch_ids;
+    }
+
+    /// Unwatch the given poll descriptors.
+    fn unwatch_poll_descriptors(watch_ids: &Vec<u32>) {
+        for watch_id in watch_ids {
+            unsafe {
+                glib_sys::g_source_remove(*watch_id);
+            }
+        }
+    }
+}
+
+
+impl Drop for AlsaCard {
+    /// Destructs the watch IDs corresponding to the current poll descriptors.
+    fn drop(&mut self) {
+        debug!("Destructing watch_ids: {:?}", self.watch_ids.get_mut());
+        AlsaCard::unwatch_poll_descriptors(&self.watch_ids.get_mut());
+    }
+}
+
+
+/// 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)?;
+        }
+
+        invoke_handlers(&self.handlers.borrow(),
+                        AudioSignal::CardInitialized,
+                        user);
+
+        return Ok(());
+    }
+
+    fn card_name(&self) -> Result<String> {
+        return self.acard
+                   .borrow()
+                   .card
+                   .get_name()
+                   .from_err();
+    }
+
+    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();
+    }
+}
+
+
+
+
+
+/// 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 {
+
+    let acard =
+        unsafe { mem::transmute::<glib_sys::gpointer, &AlsaCard>(data) };
+    let cb = &acard.cb;
+
+    unsafe {
+        let mixer_ptr =
+            mem::transmute::<&Mixer, &*mut alsa_sys::snd_mixer_t>(&acard.mixer);
+        alsa_sys::snd_mixer_handle_events(*mixer_ptr);
+    };
+
+    if cond == glib_sys::G_IO_ERR {
+        return false as glib_sys::gboolean;
+    }
+
+    let mut sread: size_t = 1;
+    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())
+            };
+
+        match stat {
+            glib_sys::G_IO_STATUS_AGAIN => {
+                debug!("G_IO_STATUS_AGAIN");
+                continue;
+            }
+            glib_sys::G_IO_STATUS_NORMAL => {
+                error!("Alsa failed to clear the channel");
+                cb(AlsaEvent::AlsaCardError);
+            }
+            glib_sys::G_IO_STATUS_ERROR => (),
+            glib_sys::G_IO_STATUS_EOF => {
+                error!("GIO error has occurred");
+                cb(AlsaEvent::AlsaCardError);
+            }
+        }
+        return true as glib_sys::gboolean;
+    }
+    cb(AlsaEvent::AlsaCardValuesChanged);
+
+    return true as glib_sys::gboolean;
+}
+
+
+/// 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);
+        }
+    }
+}

src/app_state.rs

@@ -1,16 +1,16 @@
 //! Global application state.
 
 
-use audio::alsa::backend::*;
+use alsa_card::*;
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use gtk;
 use hotkeys::Hotkeys;
 use prefs::*;
 use std::cell::RefCell;
 use std::rc::Rc;
-use support::audio::*;
+use support_audio::*;
-use ui::entry::Gui;
+use ui_entry::Gui;
 
 #[cfg(feature = "notify")]
 use notif::*;
@@ -20,8 +20,7 @@ use notif::*;
 // TODO: destructors
 /// The global application state struct.
 pub struct AppS<T>
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     _cant_construct: (),
     /// Mostly static GUI state.
@@ -43,56 +42,56 @@ where
 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 card_name = prefs.borrow()
-    let chan_name = prefs.borrow().device_prefs.channel.clone();
+        .device_prefs
-    let audio = Rc::new(unwrap_error!(
+        .card
-        AlsaBackend::new(Some(card_name), Some(chan_name)),
+        .clone();
-        None
+    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
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     /// Create an application state instance. There should really only be one.
     pub fn new(prefs: RefCell<Prefs>, audio: Rc<T>) -> Self {
         let builder_popup_window =
-            gtk::Builder::new_from_string(include_str!(concat!(
+            gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
-                env!("CARGO_MANIFEST_DIR"),
+                                                               "/data/ui/popup-window.glade")));
-                "/data/ui/popup-window.glade"
-            )));
         let builder_popup_menu =
-            gtk::Builder::new_from_string(include_str!(concat!(
+            gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
-                env!("CARGO_MANIFEST_DIR"),
+                                                               "/data/ui/popup-menu.glade")));
-                "/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!(
+        let hotkeys = unwrap_error!(wresult_warn!(
-                wresult_warn!(Hotkeys::new(&prefs.borrow(), audio.clone()), None),
+                    Hotkeys::new(&prefs.borrow(),
-                None
+                                 audio.clone()), None),
-            );
+                                    None);
 
         let gui =
             Gui::new(builder_popup_window, builder_popup_menu, &prefs.borrow());
 
         return AppS {
-            _cant_construct: (),
+                   _cant_construct: (),
-            gui,
+                   gui,
-            audio,
+                   audio,
-            prefs,
+                   prefs,
-            #[cfg(feature = "notify")]
+                   #[cfg(feature = "notify")]
-            notif,
+                   notif,
-            hotkeys: RefCell::new(hotkeys),
+                   hotkeys: RefCell::new(hotkeys),
-        };
+               };
     }
 
 
@@ -101,11 +100,9 @@ where
     /// Update the tray icon state.
     pub fn update_tray_icon(&self) -> Result<()> {
         debug!("Update tray icon!");
-        return self.gui.tray_icon.update_all(
+        return self.gui.tray_icon.update_all(&self.prefs.borrow(),
-            &self.prefs.borrow(),
+                                             self.audio.as_ref(),
-            self.audio.as_ref(),
+                                             None);
-            None,
-        );
     }
 
     /// Update the Popup Window state.
@@ -119,9 +116,7 @@ where
     pub fn update_notify(&self) {
         match self.notif {
             Some(ref n) => n.reload(&self.prefs.borrow()),
-            None => {
+            None => warn!("Notification system not unitialized, skipping update"),
-                warn!("Notification system not unitialized, skipping update")
-            }
         }
     }
 

src/audio.rs

@@ -13,7 +13,7 @@ use std::cell::Ref;
 use std::cell::RefCell;
 use std::f64;
 use std::rc::Rc;
-use support::audio::*;
+use support_audio::*;
 
 
 
@@ -76,30 +76,25 @@ impl Handlers {
 }
 
 
-/// This is the audio frontend, which can be implemented by different backends,
+// TODO: explain more, specify details that need to be implemented
-/// 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(
+    fn switch_card(&self,
-        &self,
+                   card_name: Option<String>,
-        card_name: Option<String>,
+                   elem_name: Option<String>,
-        elem_name: Option<String>,
+                   user: AudioUser)
-        user: AudioUser,
+                   -> Result<()>;
-    ) -> Result<()>;
 
     /// Current volume. Between 0 and 100.
-    /// This always gets the volume of the `FrontRight` channel, because that
+    /// This always gets the volume of the `FrontRight` channel, because the
     /// 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.
+    /// Set the volume to this value.
     /// ## `user`
     /// Where the card switch originates from.
     /// ## `dir`
@@ -107,13 +102,12 @@ pub trait AudioFrontend {
     /// or increase. This helps with rounding problems.
     /// ## `auto_unmute`
     /// Whether to automatically unmute if the volume changes.
-    fn set_vol(
+    fn set_vol(&self,
-        &self,
+               new_vol: f64,
-        new_vol: f64,
+               user: AudioUser,
-        user: AudioUser,
+               dir: VolDir,
-        dir: VolDir,
+               auto_unmute: bool)
-        auto_unmute: bool,
+               -> Result<()>;
-    ) -> Result<()>;
 
     /// Current volume level, nicely usable for e.g. selecting from a set
     /// of images.

src/audio/alsa/backend.rs

@@ -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,
-            );
-        }
-    }
-}

src/audio/alsa/card.rs

@@ -1,256 +0,0 @@
-//! 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_sys;
-use errors::*;
-use glib_sys;
-use libc::c_uint;
-use libc::pollfd;
-use libc::size_t;
-use std::cell::Cell;
-use std::mem;
-use std::ptr;
-use std::rc::Rc;
-use std::u8;
-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>> {
-        let card = {
-            match card_name {
-                Some(name) => {
-                    if name == "(default)" {
-                        let default = get_default_alsa_card();
-                        if alsa_card_has_playable_selem(&default) {
-                            default
-                        } else {
-                            warn!(
-                                "Default alsa card not playabla, trying others"
-                            );
-                            get_first_playable_alsa_card()?
-                        }
-                    } else {
-                        let mycard = get_alsa_card_by_name(name.clone());
-                        match mycard {
-                            Ok(card) => card,
-                            Err(_) => {
-                                warn!(
-                                    "Card {} not playable, trying others",
-                                    name
-                                );
-                                get_first_playable_alsa_card()?
-                            }
-                        }
-                    }
-                }
-                None => get_first_playable_alsa_card()?,
-            }
-        };
-        let mixer = get_mixer(&card)?;
-
-        let selem_id = {
-            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(_) => {
-                    warn!("No playable Selem found, trying others");
-                    get_first_playable_selem(&mixer)?.get_id()
-                }
-            }
-        };
-
-        let vec_pollfd = PollDescriptors::get(&mixer)?;
-
-        let acard = Box::new(AlsaCard {
-            _cannot_construct: (),
-            card,
-            mixer,
-            selem_id,
-            watch_ids: Cell::new(vec![]),
-            cb,
-        });
-
-        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();
-    }
-
-    /// Watch the given alsa card poll descriptors and
-    /// return the corresponding watch IDs for saving
-    /// in the `AlsaCard` struct.
-    fn watch_poll_descriptors(
-        polls: Vec<pollfd>,
-        acard: &AlsaCard,
-    ) -> Vec<c_uint> {
-        let mut watch_ids: Vec<c_uint> = vec![];
-        let acard_ptr =
-            unsafe { mem::transmute::<&AlsaCard, glib_sys::gpointer>(acard) };
-        for poll in polls {
-            let gioc: *mut glib_sys::GIOChannel =
-                unsafe { glib_sys::g_io_channel_unix_new(poll.fd) };
-            let id = unsafe {
-                glib_sys::g_io_add_watch(
-                    gioc,
-                    glib_sys::GIOCondition::from_bits(
-                        glib_sys::G_IO_IN.bits() | glib_sys::G_IO_ERR.bits(),
-                    ).unwrap(),
-                    Some(watch_cb),
-                    acard_ptr,
-                )
-            };
-            watch_ids.push(id);
-            unsafe { glib_sys::g_io_channel_unref(gioc) }
-        }
-
-        return watch_ids;
-    }
-
-    /// Unwatch the given poll descriptors.
-    fn unwatch_poll_descriptors(watch_ids: &Vec<u32>) {
-        for watch_id in watch_ids {
-            unsafe {
-                glib_sys::g_source_remove(*watch_id);
-            }
-        }
-    }
-}
-
-
-impl Drop for AlsaCard {
-    /// Destructs the watch IDs corresponding to the current poll descriptors.
-    fn drop(&mut self) {
-        debug!("Destructing watch_ids: {:?}", self.watch_ids.get_mut());
-        AlsaCard::unwatch_poll_descriptors(&self.watch_ids.get_mut());
-    }
-}
-
-
-/// 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 {
-
-    let acard =
-        unsafe { mem::transmute::<glib_sys::gpointer, &AlsaCard>(data) };
-    let cb = &acard.cb;
-
-    unsafe {
-        let mixer_ptr =
-            mem::transmute::<&Mixer, &*mut alsa_sys::snd_mixer_t>(&acard.mixer);
-        alsa_sys::snd_mixer_handle_events(*mixer_ptr);
-    };
-
-    if cond == glib_sys::G_IO_ERR {
-        return false as glib_sys::gboolean;
-    }
-
-    let mut sread: size_t = 1;
-    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(),
-            )
-        };
-
-        match stat {
-            glib_sys::G_IO_STATUS_AGAIN => {
-                continue;
-            }
-            glib_sys::G_IO_STATUS_NORMAL => {
-                error!("Alsa failed to clear the channel");
-                cb(AlsaEvent::AlsaCardError);
-            }
-            glib_sys::G_IO_STATUS_ERROR => (),
-            glib_sys::G_IO_STATUS_EOF => {
-                error!("GIO error has occurred");
-                cb(AlsaEvent::AlsaCardError);
-            }
-            _ => {
-                error!("Internal error: unknown status!");
-            },
-        }
-        return true as glib_sys::gboolean;
-    }
-    cb(AlsaEvent::AlsaCardValuesChanged);
-
-    return true as glib_sys::gboolean;
-}

src/audio/alsa/mod.rs

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

src/audio/mod.rs

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

src/bin.rs

@@ -1,78 +1,28 @@
 #![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();
+    gtk::init().unwrap();
 
-    let mut opts = Options::new();
+    flexi_logger::LogOptions::new()
-    opts.optflag("h", "help", "Show help");
+       .log_to_file(false)
-    opts.optopt("", "log-to-file",
+       // ... your configuration options go here ...
-                "Log files to the specified dir instead of stderr",
+       .init(Some("pnmixer=debug".to_string()))
-                "DIRECTORY");
+       .unwrap_or_else(|e| panic!("Logger initialization failed with {}", e));
-    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);
+    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));
-}

src/errors.rs

@@ -1,7 +1,6 @@
 #![allow(missing_docs)]
 
-use alsa_lib;
+use alsa;
-use glib;
 use png;
 use std::convert::From;
 use std;
@@ -11,11 +10,10 @@ 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 {
@@ -149,12 +147,12 @@ macro_rules! error_dialog {
     ($msg:expr, $parent:expr) => {
         {
             use gtk::DialogExt;
-            use gtk::prelude::GtkWindowExt;
             use gtk::WidgetExt;
+            use gtk::WindowExt;
 
             let parent: Option<&gtk::Window> = $parent;
             let dialog = gtk::MessageDialog::new(parent,
-                                                 gtk::DialogFlags::DESTROY_WITH_PARENT,
+                                                 gtk::DIALOG_DESTROY_WITH_PARENT,
                                                  gtk::MessageType::Error,
                                                  gtk::ButtonsType::Close,
                                                  $msg);

src/gdk_x11.rs

@@ -18,10 +18,8 @@ mod ffi {
     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(
+        pub fn gdk_x11_window_foreign_new_for_display(display: *mut GdkDisplay,
-            display: *mut GdkDisplay,
+window: Window) -> * mut GdkWindow;
-            window: Window,
-        ) -> *mut GdkWindow;
     }
 }
 
@@ -66,17 +64,14 @@ pub fn gdk_x11_get_default_root_xwindow() -> Window {
 ///
 /// 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(
+pub fn gdk_x11_window_foreign_new_for_display(gdk_display: &mut gdk::Display,
-    gdk_display: &mut gdk::Display,
+                                              xwindow: Window)
-    xwindow: Window,
+                                              -> Option<gdk::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(
+        return from_glib_full(
-            display,
+            ffi::gdk_x11_window_foreign_new_for_display(display, xwindow));
-            xwindow,
-        ));
     }
 }

src/hotkey.rs

@@ -7,11 +7,11 @@
 use errors::*;
 use gdk;
 use gdk_sys;
+use gdk_x11::*;
 use gtk;
+use x11;
 use libc::c_int;
 use libc::c_uint;
-use support::gdk_x11::*;
-use x11;
 
 
 /// `xmodmap -pm`
@@ -50,9 +50,8 @@ impl Hotkey {
         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(
+        let gtk_accel = gtk::accelerator_name(sym as u32, mods)
-            "Could net get accelerator name",
+            .ok_or("Could net get accelerator name")?;
-        )?;
 
         let hotkey = Hotkey {
             code,
@@ -85,15 +84,13 @@ impl Hotkey {
         /* Grab the key */
         for key in KEY_MASKS.iter() {
             unsafe {
-                x11::xlib::XGrabKey(
+                x11::xlib::XGrabKey(display,
-                    display,
+                                    self.code,
-                    self.code,
+                                    self.mod_bits | key,
-                    self.mod_bits | key,
+                                    gdk_x11_get_default_root_xwindow(),
-                    gdk_x11_get_default_root_xwindow(),
+                                    1,
-                    1,
+                                    x11::xlib::GrabModeAsync,
-                    x11::xlib::GrabModeAsync,
+                                    x11::xlib::GrabModeAsync);
-                    x11::xlib::GrabModeAsync,
-                );
             }
         }
 
@@ -122,12 +119,10 @@ impl Hotkey {
 
         for key in KEY_MASKS.iter() {
             unsafe {
-                x11::xlib::XUngrabKey(
+                x11::xlib::XUngrabKey(display,
-                    display,
+                                      self.code,
-                    self.code,
+                                      self.mod_bits | key,
-                    self.mod_bits | key,
+                                      gdk_x11_get_default_root_xwindow());
-                    gdk_x11_get_default_root_xwindow(),
-                );
             }
         }
     }
@@ -164,10 +159,8 @@ pub fn hotkey_accel_to_code(accel: &str) -> (gdk::key, gdk::ModifierType) {
 
     unsafe {
         if sym != 0 {
-            return (
+            return (x11::xlib::XKeysymToKeycode(display, sym as u64) as i32,
-                x11::xlib::XKeysymToKeycode(display, sym as u64) as i32,
+                    mods);
-                mods,
-            );
         } else {
             return (-1, mods);
         }
@@ -177,10 +170,9 @@ pub fn hotkey_accel_to_code(accel: &str) -> (gdk::key, gdk::ModifierType) {
 
 static mut GRAB_ERROR: u8 = 0;
 
-extern "C" fn grab_error_handler(
+extern "C" fn grab_error_handler(_: *mut x11::xlib::Display,
-    _: *mut x11::xlib::Display,
+                                 _: *mut x11::xlib::XErrorEvent)
-    _: *mut x11::xlib::XErrorEvent,
+                                 -> c_int {
-) -> c_int {
     warn!("Error while grabbing hotkey");
     unsafe {
         GRAB_ERROR = 1;

src/hotkeys.rs

@@ -5,18 +5,18 @@
 //! before they can be interpreted by Gtk/Gdk.
 
 
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use errors;
 use gdk;
 use gdk_sys;
+use gdk_x11;
 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;
 
@@ -24,8 +24,7 @@ use x11;
 
 /// The possible Hotkeys for manipulating the volume.
 pub struct Hotkeys<T>
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     enabled: bool,
     mute_key: Option<Hotkey>,
@@ -38,30 +37,31 @@ where
 }
 
 impl<T> Hotkeys<T>
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     /// Creates the hotkeys subsystem and binds the hotkeys.
-    pub fn new(
+    pub fn new(prefs: &Prefs,
-        prefs: &Prefs,
+               audio: Rc<T>)
-        audio: Rc<T>,
+               -> WResult<Box<Hotkeys<T>>, errors::Error, errors::Error> {
-    ) -> WResult<Box<Hotkeys<T>>, errors::Error, errors::Error> {
         debug!("Creating hotkeys control");
-        let mut hotkeys = Box::new(Hotkeys {
+        let mut hotkeys =
-            enabled: false,
+            Box::new(Hotkeys {
-            mute_key: None,
+                         enabled: false,
-            up_key: None,
+                         mute_key: None,
-            down_key: None,
+                         up_key: None,
-            audio: audio,
+                         down_key: None,
-            auto_unmute: prefs.behavior_prefs.unmute_on_vol_change,
+                         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 {
+        let data_ptr =
-            mem::transmute::<&Hotkeys<T>, glib_sys::gpointer>(hotkeys.as_ref())
+            unsafe {
-        };
+                mem::transmute::<&Hotkeys<T>,
+                                 glib_sys::gpointer>(hotkeys.as_ref())
+            };
         hotkeys_add_filter(Some(key_filter::<T>), data_ptr);
         return WOk(hotkeys, warn);
     }
@@ -104,20 +104,20 @@ where
         /* Setup mute hotkey */
         let (m_unmute_key, mute_err) =
             new_hotkey(&hotkey_prefs.mute_unmute_key);
-        if let Some(key) = m_unmute_key {
+        if m_unmute_key.is_some() {
-            self.mute_key = Some(key);
+            self.mute_key = Some(m_unmute_key.unwrap());
         }
 
         /* Setup volume uphotkey */
         let (m_up_key, up_err) = new_hotkey(&hotkey_prefs.vol_up_key);
-        if let Some(key) = m_up_key {
+        if m_up_key.is_some() {
-            self.up_key = Some(key);
+            self.up_key = Some(m_up_key.unwrap());
         }
 
         /* Setup volume down hotkey */
         let (m_down_key, down_err) = new_hotkey(&hotkey_prefs.vol_down_key);
-        if let Some(key) = m_down_key {
+        if m_down_key.is_some() {
-            self.down_key = Some(key);
+            self.down_key = Some(m_down_key.unwrap());
         }
 
         if mute_err || up_err || down_err {
@@ -134,23 +134,32 @@ where
     /// Bind hotkeys manually. Should be paired with an `unbind()` call.
     pub fn bind(&self) {
         debug!("Bind hotkeys");
-
+        if self.mute_key.is_some() {
-        if let Some(ref key) = self.mute_key {
+            if self.mute_key
-            if key.grab().is_err() {
+                   .as_ref()
+                   .unwrap()
+                   .grab()
+                   .is_err() {
                 warn!("Could not grab mute key");
-            }
+            };
         }
-
+        if self.up_key.is_some() {
-        if let Some(ref key) = self.up_key {
+            if self.up_key
-            if key.grab().is_err() {
+                   .as_ref()
-                warn!("Could not grab mute key");
+                   .unwrap()
-            }
+                   .grab()
+                   .is_err() {
+                warn!("Could not grab volume up key");
+            };
         }
-
+        if self.down_key.is_some() {
-        if let Some(ref key) = self.down_key {
+            if self.down_key
-            if key.grab().is_err() {
+                   .as_ref()
-                warn!("Could not grab mute key");
+                   .unwrap()
-            }
+                   .grab()
+                   .is_err() {
+                warn!("Could not grab volume down key");
+            };
         }
 
         let data_ptr =
@@ -161,17 +170,23 @@ where
     /// Unbind hotkeys manually. Should be paired with a `bind()` call.
     pub fn unbind(&self) {
         debug!("Unbind hotkeys");
-
+        if self.mute_key.is_some() {
-        if let Some(ref key) = self.mute_key {
+            self.mute_key
-            key.ungrab();
+                .as_ref()
+                .unwrap()
+                .ungrab();
         }
-
+        if self.up_key.is_some() {
-        if let Some(ref key) = self.up_key {
+            self.up_key
-            key.ungrab();
+                .as_ref()
+                .unwrap()
+                .ungrab();
         }
-
+        if self.down_key.is_some() {
-        if let Some(ref key) = self.down_key {
+            self.down_key
-            key.ungrab();
+                .as_ref()
+                .unwrap()
+                .ungrab();
         }
 
         let data_ptr =
@@ -181,8 +196,7 @@ where
 }
 
 impl<T> Drop for Hotkeys<T>
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     fn drop(&mut self) {
         debug!("Freeing hotkeys");
@@ -201,15 +215,13 @@ where
 
 /// Attaches the `key_filter()` function as a filter
 /// to the root window, so it will intercept window events.
-fn hotkeys_add_filter(
+fn hotkeys_add_filter(function: gdk_sys::GdkFilterFunc,
-    function: gdk_sys::GdkFilterFunc,
+                      data: glib_sys::gpointer) {
-    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(),
+        gdk_x11::gdk_x11_get_default_root_xwindow()
-    ).unwrap();
+        ).unwrap();
 
     unsafe {
         gdk_sys::gdk_window_add_filter(window.to_glib_none().0, function, data);
@@ -219,22 +231,18 @@ fn hotkeys_add_filter(
 
 /// Removes the previously attached `key_filter()` function from
 /// the root window.
-fn hotkeys_remove_filter(
+fn hotkeys_remove_filter(function: gdk_sys::GdkFilterFunc,
-    function: gdk_sys::GdkFilterFunc,
+                         data: glib_sys::gpointer) {
-    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(),
+        gdk_x11::gdk_x11_get_default_root_xwindow()
-    ).unwrap();
+        ).unwrap();
 
     unsafe {
-        gdk_sys::gdk_window_remove_filter(
+        gdk_sys::gdk_window_remove_filter(window.to_glib_none().0,
-            window.to_glib_none().0,
+                                          function,
-            function,
+                                          data);
-            data,
-        );
     }
 
 }
@@ -242,13 +250,11 @@ fn hotkeys_remove_filter(
 
 /// This function is called before Gtk/Gdk can respond
 /// to any(!) window event and handles pressed hotkeys.
-extern "C" fn key_filter<T>(
+extern "C" fn key_filter<T>(gdk_xevent: *mut gdk_sys::GdkXEvent,
-    gdk_xevent: *mut gdk_sys::GdkXEvent,
+                            _: *mut gdk_sys::GdkEvent,
-    _: *mut gdk_sys::GdkEvent,
+                            data: glib_sys::gpointer)
-    data: glib_sys::gpointer,
+                            -> gdk_sys::GdkFilterReturn
-) -> gdk_sys::GdkFilterReturn
+    where T: AudioFrontend
-where
-    T: AudioFrontend,
 {
     let xevent = gdk_xevent as *mut x11::xlib::XKeyEvent;
 
@@ -261,7 +267,7 @@ where
 
     let xevent_type = unsafe { (*xevent).type_ };
     if xevent_type == x11::xlib::KeyPress {
-        return gdk_sys::GDK_FILTER_CONTINUE;
+        return gdk_sys::GdkFilterReturn::Continue;
     }
 
     let xevent_key = unsafe { (*xevent).keycode };
@@ -269,33 +275,27 @@ where
 
 
     if mute_key.as_ref().is_some() &&
-        mute_key.as_ref().unwrap().matches(
+       mute_key.as_ref()
-            xevent_key as i32,
+           .unwrap()
-            gdk::ModifierType::from_bits(xevent_state)
+           .matches(xevent_key as i32,
-                .unwrap(),
+                    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(
+              up_key.as_ref()
-            xevent_key as i32,
+                  .unwrap()
-            gdk::ModifierType::from_bits(
+                  .matches(xevent_key as i32,
-                xevent_state,
+                           gdk::ModifierType::from_bits(xevent_state)
-            ).unwrap(),
+                               .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(
+              down_key.as_ref()
-            xevent_key as i32,
+                  .unwrap()
-            gdk::ModifierType::from_bits(
+                  .matches(xevent_key as i32,
-                xevent_state,
+                           gdk::ModifierType::from_bits(xevent_state)
-            ).unwrap(),
+                               .unwrap()) {
-        )
-    {
         just_warn!(audio.decrease_vol(AudioUser::Hotkeys, hotkeys.auto_unmute));
     }
 
-    return gdk_sys::GDK_FILTER_CONTINUE;
+    return gdk_sys::GdkFilterReturn::Continue;
 }

src/lib.rs

@@ -44,7 +44,7 @@ extern crate serde_derive;
 extern crate toml;
 extern crate serde;
 
-extern crate alsa as alsa_lib;
+extern crate alsa;
 extern crate alsa_sys;
 extern crate ffi;
 extern crate gdk;
@@ -73,15 +73,27 @@ extern crate lazy_static;
 #[macro_use]
 pub mod errors;
 
+#[macro_use]
+pub mod glade_helpers;
+
+pub mod alsa_card;
 pub mod app_state;
 pub mod audio;
+pub mod gdk_x11;
 pub mod hotkey;
 pub mod hotkeys;
 pub mod prefs;
+pub mod support_alsa;
+pub mod support_audio;
+pub mod support_cmd;
 #[macro_use]
-pub mod support;
+pub mod support_ui;
-#[macro_use]
+pub mod ui_entry;
-pub mod ui;
+pub mod ui_hotkey_dialog;
+pub mod ui_popup_menu;
+pub mod ui_popup_window;
+pub mod ui_prefs_dialog;
+pub mod ui_tray_icon;
 
 #[cfg(feature = "notify")]
 pub mod notif;

src/notif.rs

@@ -5,7 +5,7 @@
 
 
 use app_state::*;
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use glib::prelude::*;
 use libnotify;
@@ -63,23 +63,18 @@ impl Notif {
         self.from_external.set(prefs.notify_prefs.notify_external);
 
         self.volume_notif.set_timeout(timeout as i32);
-        self.volume_notif.set_hint(
+        self.volume_notif.set_hint("x-canonical-private-synchronous",
-            "x-canonical-private-synchronous",
+                                   Some("".to_variant()));
-            Some("".to_variant()),
-        );
 
 
         self.text_notif.set_timeout(timeout as i32);
-        self.text_notif.set_hint(
+        self.text_notif.set_hint("x-canonical-private-synchronous",
-            "x-canonical-private-synchronous",
+                                 Some("".to_variant()));
-            Some("".to_variant()),
-        );
     }
 
     /// Shows a volume notification, e.g. for volume or mute state change.
     pub fn show_volume_notif<T>(&self, audio: &T) -> Result<()>
-    where
+        where T: AudioFrontend
-        T: AudioFrontend,
     {
         let vol = audio.get_vol()?;
         let vol_level = audio.vol_level();
@@ -98,23 +93,19 @@ impl Notif {
             match vol_level {
                 VolLevel::Muted => String::from("Volume muted"),
                 _ => {
-                    format!(
+                    format!("{} ({})\nVolume: {}",
-                        "{} ({})\nVolume: {}",
+                            audio.card_name()?,
-                        audio.card_name()?,
+                            audio.chan_name()?,
-                        audio.chan_name()?,
+                            vol as i32)
-                        vol as i32
-                    )
                 }
             }
         };
 
-        self.volume_notif
+        // TODO: error handling
-            .update(summary.as_str(), None, Some(icon))?;
+        self.volume_notif.update(summary.as_str(), None, Some(icon)).unwrap();
-        self.volume_notif.set_hint(
+        self.volume_notif.set_hint("value", Some((vol as i32).to_variant()));
-            "value",
+        // TODO: error handling
-            Some((vol as i32).to_variant()),
+        self.volume_notif.show().unwrap();
-        );
-        self.volume_notif.show()?;
 
         return Ok(());
     }
@@ -122,8 +113,10 @@ impl Notif {
 
     /// 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)?;
+        // TODO: error handling
-        self.text_notif.show()?;
+        self.text_notif.update(summary, Some(body), None).unwrap();
+        // TODO: error handling
+        self.text_notif.show().unwrap();
 
         return Ok(());
     }
@@ -139,8 +132,7 @@ impl Drop for Notif {
 
 /// Initialize the notification subsystem.
 pub fn init_notify<T>(appstate: Rc<AppS<T>>)
-where
+    where T: AudioFrontend + 'static
-    T: AudioFrontend + 'static,
 {
     {
         /* connect handler */

src/prefs.rs

@@ -73,16 +73,16 @@ impl From<MiddleClickAction> for i32 {
 /// 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)"),
+                   card: String::from("(default)"),
-            channel: String::from("Master"),
+                   channel: String::from("Master"),
-        };
+               };
     }
 }
 
@@ -94,18 +94,18 @@ 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,
+                   draw_vol_meter: true,
-            vol_meter_offset: 10,
+                   vol_meter_offset: 10,
-            system_theme: true,
+                   system_theme: true,
-            vol_meter_color: VolColor::default(),
+                   vol_meter_color: VolColor::default(),
-        };
+               };
     }
 }
 
@@ -122,10 +122,10 @@ pub struct VolColor {
 impl Default for VolColor {
     fn default() -> VolColor {
         return VolColor {
-            red: 0.960784313725,
+                   red: 0.960784313725,
-            green: 0.705882352941,
+                   green: 0.705882352941,
-            blue: 0.0,
+                   blue: 0.0,
-        };
+               };
     }
 }
 
@@ -139,19 +139,19 @@ pub struct BehaviorPrefs {
     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,
+                   unmute_on_vol_change: true,
-            vol_control_cmd: None,
+                   vol_control_cmd: None,
-            vol_scroll_step: 5.0,
+                   vol_scroll_step: 5.0,
-            vol_fine_scroll_step: 1.0,
+                   vol_fine_scroll_step: 1.0,
-            middle_click_action: MiddleClickAction::default(),
+                   middle_click_action: MiddleClickAction::default(),
-            custom_command: None,
+                   custom_command: None,
-        };
+               };
     }
 }
 
@@ -173,13 +173,13 @@ pub struct NotifyPrefs {
 impl Default for NotifyPrefs {
     fn default() -> NotifyPrefs {
         return NotifyPrefs {
-            enable_notifications: true,
+                   enable_notifications: true,
-            notifcation_timeout: 1500,
+                   notifcation_timeout: 1500,
-            notify_mouse_scroll: true,
+                   notify_mouse_scroll: true,
-            notify_popup: true,
+                   notify_popup: true,
-            notify_external: true,
+                   notify_external: true,
-            notify_hotkeys: true,
+                   notify_hotkeys: true,
-        };
+               };
     }
 }
 
@@ -249,26 +249,22 @@ impl Prefs {
 
     /// Store the current preferences to the config file.
     pub fn store_config(&self) -> Result<()> {
-        let config_path = get_xdg_dirs()
+        let config_path = get_xdg_dirs().place_config_file("pnmixer.toml")
-            .place_config_file("pnmixer.toml")
             .chain_err(|| {
-                format!(
+                           format!("Could not create config directory at {:?}",
-                    "Could not create config directory at {:?}",
+                                   get_xdg_dirs().get_config_home())
-                    get_xdg_dirs().get_config_home()
+                       })?;
-                )
-            })?;
 
         debug!("Storing config in {:?}", config_path);
 
-        let mut f = File::create(config_path.clone()).chain_err(|| {
+        let mut f = File::create(config_path.clone())
-            format!(
+            .chain_err(|| format!("Could not open/create config file {:?} for writing",
-                "Could not open/create config file {:?} for writing",
+                       config_path))?;
-                config_path
+        f.write_all(self.to_str().as_bytes())
-            )
+            .chain_err(|| {
-        })?;
+                           format!("Could not write to config file {:?}",
-        f.write_all(self.to_str().as_bytes()).chain_err(|| {
+                                   config_path)
-            format!("Could not write to config file {:?}", config_path)
+                       })?;
-        })?;
 
         return Ok(());
     }
@@ -301,10 +297,9 @@ impl Prefs {
 }
 
 impl Display for Prefs {
-    fn fmt(
+    fn fmt(&self,
-        &self,
+           f: &mut Formatter)
-        f: &mut Formatter,
+           -> std::result::Result<(), std::fmt::Error> {
-    ) -> std::result::Result<(), std::fmt::Error> {
         let s = self.to_str();
         return write!(f, "{}", s);
     }

src/support/mod.rs

@@ -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;

src/support_alsa.rs

@@ -4,9 +4,9 @@
 //! out the details we don't care about.
 
 
-use alsa_lib::card::Card;
+use alsa::card::Card;
-use alsa_lib::mixer::{Mixer, Selem, Elem};
+use alsa::mixer::{Mixer, Selem, Elem};
-use alsa_lib;
+use alsa;
 use errors::*;
 use libc::c_int;
 
@@ -25,8 +25,8 @@ pub fn get_alsa_card_by_id(index: c_int) -> Card {
 
 
 /// Get all available alsa cards.
-pub fn get_alsa_cards() -> alsa_lib::card::Iter {
+pub fn get_alsa_cards() -> alsa::card::Iter {
-    return alsa_lib::card::Iter::new();
+    return alsa::card::Iter::new();
 }
 
 
@@ -95,7 +95,7 @@ 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();
 }
 
 
@@ -144,12 +144,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(
+pub fn get_playable_selem_by_name(mixer: &Mixer,
-    mixer: &Mixer,
+                                  name: String)
-    name: String,
+                                  -> Result<Selem> {
-) -> 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);

src/support_audio.rs

@@ -6,10 +6,10 @@
 //! but are important helpers.
 
 
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use prefs::*;
-use support::alsa::*;
+use support_alsa::*;
 
 
 #[derive(Clone, Copy, Debug)]
@@ -55,8 +55,7 @@ pub fn lrint(v: f64, dir: VolDir) -> f64 {
 
 /// Reload the audio system.
 pub fn audio_reload<T>(audio: &T, prefs: &Prefs, user: AudioUser) -> Result<()>
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let card = &prefs.device_prefs.card;
     let channel = &prefs.device_prefs.channel;
@@ -70,12 +69,10 @@ where
 /// of the volume level.
 pub fn vol_to_percent(vol: i64, range: (i64, i64)) -> Result<f64> {
     let (min, max) = range;
-    ensure!(
+    ensure!(min < max,
-        min < max,
+            "Invalid playback volume range [{} - {}]",
-        "Invalid playback volume range [{} - {}]",
+            min,
-        min,
+            max);
-        max
-    );
     let perc = ((vol - min) as f64) / ((max - min) as f64) * 100.0;
     return Ok(perc);
 }
@@ -86,12 +83,10 @@ pub fn vol_to_percent(vol: i64, range: (i64, i64)) -> Result<f64> {
 /// range.
 pub fn percent_to_vol(vol: f64, range: (i64, i64), dir: VolDir) -> Result<i64> {
     let (min, max) = range;
-    ensure!(
+    ensure!(min < max,
-        min < max,
+            "Invalid playback volume range [{} - {}]",
-        "Invalid playback volume range [{} - {}]",
+            min,
-        min,
+            max);
-        max
-    );
 
     let _v = lrint(vol / 100.0 * ((max - min) as f64), dir) + (min as f64);
     return Ok(_v as i64);

src/support_cmd.rs

@@ -24,8 +24,10 @@ pub fn execute_vol_control_command(prefs: &Prefs) -> Result<()> {
 
 /// Try to execute the given command asynchronously via gtk.
 pub fn execute_command(cmd: &str) -> Result<()> {
-    return Ok(glib::spawn_command_line_async(cmd)
+    return glib::spawn_command_line_async(cmd)
-        .map_err(|e| {
+               .map_err(|e| {
-            std::io::Error::new(std::io::ErrorKind::Other, e.description())
+                            std::io::Error::new(std::io::ErrorKind::Other,
-        })?);
+                                                e.description())
+                        })
+               .from_err();
 }

src/support_ui.rs

@@ -3,29 +3,43 @@
 
 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::*;
 
 
 
+/// Copy a `Pixbuf` explicitly, since they don't implement the `Copy` trait.
+/// Currently does not call `gdk_pixbuf_copy_options()`.
+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;
+}
+
+
 /// 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(
+pub fn pixbuf_new_from_theme(icon_name: &str,
-    icon_name: &str,
+                             size: i32,
-    size: i32,
+                             theme: &gtk::IconTheme)
-    theme: &gtk::IconTheme,
+                             -> Result<gdk_pixbuf::Pixbuf> {
-) -> Result<gdk_pixbuf::Pixbuf> {
 
-    let icon_info = theme
+    let icon_info =
-        .lookup_icon(icon_name, size, gtk::IconLookupFlags::empty())
+        theme.lookup_icon(icon_name, size, gtk::IconLookupFlags::empty())
-        .ok_or(format!("Couldn't find icon {}", icon_name))?;
+            .ok_or(format!("Couldn't find icon {}", icon_name))?;
 
-    debug!(
+    debug!("Loading stock icon {} from {:?}",
-        "Loading stock icon {} from {:?}",
+           icon_name,
-        icon_name,
+           icon_info.get_filename().unwrap_or(PathBuf::new()));
-        icon_info.get_filename().unwrap_or(PathBuf::new())
-    );
 
     // TODO: propagate error
     let pixbuf = icon_info.load_icon().unwrap();

src/ui/entry.rs

@@ -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;
-}

src/ui/mod.rs

@@ -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;

src/ui_entry.rs

@@ -0,0 +1,123 @@
+//! Global GUI state.
+
+
+use app_state::*;
+use audio::*;
+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::*;
+
+
+
+/// 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::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;
+}

src/ui_hotkey_dialog.rs

@@ -10,6 +10,7 @@ use gdk_sys;
 use glib::translate::*;
 use gtk::prelude::*;
 use gtk;
+use gtk_sys;
 use libc::c_uint;
 use std;
 
@@ -25,26 +26,23 @@ pub struct HotkeyDialog {
 impl HotkeyDialog {
     /// Creates a new hotkey dialog.
     pub fn new<P>(parent: &P, hotkey: String) -> HotkeyDialog
-    where
+        where P: IsA<gtk::Window>
-        P: IsA<gtk::Window>,
     {
-        let builder = gtk::Builder::new_from_string(include_str!(concat!(
+        let builder =
-            env!("CARGO_MANIFEST_DIR"),
+            gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
-            "/data/ui/hotkey-dialog.glade"
+                                                               "/data/ui/hotkey-dialog.glade")));
-        )));
 
-        let hotkey_dialog: gtk::Dialog =
+        let hotkey_dialog: gtk::Dialog = builder.get_object("hotkey_dialog")
-            builder.get_object("hotkey_dialog").unwrap();
+            .unwrap();
-        let instruction_label: gtk::Label =
+        let instruction_label: gtk::Label = builder.get_object("instruction_label")
-            builder.get_object("instruction_label").unwrap();
+            .unwrap();
-        let key_pressed_label: gtk::Label =
+        let key_pressed_label: gtk::Label = builder.get_object("key_pressed_label")
-            builder.get_object("key_pressed_label").unwrap();
+            .unwrap();
 
         hotkey_dialog.set_title(format!("Set {} HotKey", hotkey).as_str());
-        instruction_label.set_markup(
+        instruction_label.set_markup(format!("Press new HotKey for <b>{}</b>",
-            format!("Press new HotKey for <b>{}</b>", hotkey)
+                                             hotkey)
-                .as_str(),
+                                             .as_str());
-        );
 
         hotkey_dialog.set_transient_for(parent);
 
@@ -65,19 +63,16 @@ impl HotkeyDialog {
                         &mut keyval as *mut c_uint,
                         std::ptr::null_mut(),
                         std::ptr::null_mut(),
-                        &mut consumed as *mut gdk_sys::GdkModifierType,
+                        &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_pressed_label.set_text(key_text
-                        key_text
+                                               .unwrap_or(String::from("(None)"))
-                            .unwrap_or(String::from("(None)"))
+                                               .as_str());
-                            .as_str(),
-                    );
                 };
                 return Inhibit(false);
             });
@@ -86,35 +81,33 @@ impl HotkeyDialog {
 
 
         hotkey_dialog.connect_key_release_event(move |w, _| {
-            w.response(gtk::ResponseType::Ok.into());
+            w.response(gtk_sys::GtkResponseType::Ok as i32);
             return Inhibit(false);
         });
 
         return HotkeyDialog {
-            hotkey_dialog,
+                   hotkey_dialog,
-            key_pressed_label,
+                   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(
+        let device = gtk::get_current_event_device()
-            "Could not get current device",
+            .ok_or("Could not get current device")?;
-        )?;
+        let window = self.hotkey_dialog
-        let window = self.hotkey_dialog.get_window().ok_or(
+            .get_window()
-            "Could not get window",
+            .ok_or("Could not get window")?;
-        )?;
 
-        let m_grab_status = device.grab(
+        let m_grab_status =
-            &window,
+            device.grab(&window,
-            gdk::GrabOwnership::Application,
+                        gdk::GrabOwnership::Application,
-            true,
+                        true,
-            gdk::EventMask::KEY_PRESS_MASK,
+                        gdk::KEY_PRESS_MASK,
-            None,
+                        None,
-            gdk_sys::GDK_CURRENT_TIME as u32,
+                        gdk_sys::GDK_CURRENT_TIME as u32);
-        );
 
         if m_grab_status != gdk::GrabStatus::Success {
             bail!("Could not grab the keyboard");
@@ -124,14 +117,12 @@ impl HotkeyDialog {
         device.ungrab(gdk_sys::GDK_CURRENT_TIME as u32);
 
         if resp != gtk::ResponseType::Ok.into() {
-            bail!(ErrorKind::GtkResponseCancel(
+            bail!(ErrorKind::GtkResponseCancel(String::from("not assigning hotkey")));
-                String::from("not assigning hotkey"),
-            ));
         }
 
-        return Ok(self.key_pressed_label.get_text().ok_or(
+        return Ok(self.key_pressed_label
-            "Could not get text",
+                      .get_text()
-        )?);
+                      .ok_or("Could not get text")?);
     }
 }
 

src/ui_popup_menu.rs

@@ -12,46 +12,46 @@
 //! * Quit
 
 use app_state::*;
-use audio::frontend::*;
+use audio::*;
 use gtk::prelude::*;
 use gtk;
 use std::rc::Rc;
-use support::audio::*;
+use support_audio::*;
-use support::cmd::*;
+use support_cmd::*;
-use ui::prefs_dialog::*;
+use ui_prefs_dialog::*;
 
 
 const VERSION: &'static str = env!("CARGO_PKG_VERSION");
 
 
 
-create_builder_item!(
+create_builder_item!(PopupMenu,
-    PopupMenu,
+                     menu_window: gtk::Window,
-    menu_window: gtk::Window,
+                     menubar: gtk::MenuBar,
-    menubar: gtk::MenuBar,
+                     menu: gtk::Menu,
-    menu: gtk::Menu,
+                     about_item: gtk::MenuItem,
-    about_item: gtk::MenuItem,
+                     mixer_item: gtk::MenuItem,
-    mixer_item: gtk::MenuItem,
+                     mute_item: gtk::MenuItem,
-    mute_item: gtk::MenuItem,
+                     mute_check: gtk::CheckButton,
-    mute_check: gtk::CheckButton,
+                     prefs_item: gtk::MenuItem,
-    prefs_item: gtk::MenuItem,
+                     quit_item: gtk::MenuItem,
-    quit_item: gtk::MenuItem,
+                     reload_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
+    where T: AudioFrontend + 'static
-    T: AudioFrontend + 'static,
 {
     /* audio.connect_handler */
     {
         let apps = appstate.clone();
         appstate.audio.connect_handler(Box::new(move |s, u| {
             /* skip if window is hidden */
-            if !apps.gui.popup_menu.menu.get_visible() {
+            if !apps.gui
+                    .popup_menu
+                    .menu
+                    .get_visible() {
                 return;
             }
             match (s, u) {
@@ -64,9 +64,10 @@ where
     /* popup_menu.menu.connect_show */
     {
         let apps = appstate.clone();
-        appstate.gui.popup_menu.menu.connect_show(
+        appstate.gui
-            move |_| set_mute_check(&apps),
+            .popup_menu
-        );
+            .menu
+            .connect_show(move |_| set_mute_check(&apps));
 
     }
 
@@ -75,10 +76,8 @@ where
         let apps = appstate.clone();
         let mixer_item = &appstate.gui.popup_menu.mixer_item;
         mixer_item.connect_activate(move |_| {
-            let _ = result_warn!(
+            let _ = result_warn!(execute_vol_control_command(&apps.prefs.borrow()),
-                execute_vol_control_command(&apps.prefs.borrow()),
+                Some(&apps.gui.popup_menu.menu_window));
-                Some(&apps.gui.popup_menu.menu_window)
-            );
         });
     }
 
@@ -86,8 +85,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() {
+        mute_item.connect_activate(move |_| {
-            try_w!(apps.audio.toggle_mute(AudioUser::Popup));
+            if apps.audio.has_mute() {
+                try_w!(apps.audio.toggle_mute(AudioUser::Popup));
+            }
         });
     }
 
@@ -95,18 +96,18 @@ where
     {
         let apps = appstate.clone();
         let about_item = &appstate.gui.popup_menu.about_item;
-        about_item.connect_activate(
+        about_item.connect_activate(move |_| {
-            move |_| { on_about_item_activate(&apps); },
+                                        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(
+        prefs_item.connect_activate(move |_| {
-            move |_| { on_prefs_item_activate(&apps); },
+                                        on_prefs_item_activate(&apps);
-        );
+                                    });
     }
 
     /* reload_item.connect_activate_link */
@@ -114,12 +115,10 @@ where
         let apps = appstate.clone();
         let reload_item = &appstate.gui.popup_menu.reload_item;
         reload_item.connect_activate(move |_| {
-            try_w!(audio_reload(
+                                         try_w!(audio_reload(apps.audio.as_ref(),
-                apps.audio.as_ref(),
+                                                 &apps.prefs.borrow(),
-                &apps.prefs.borrow(),
+                                                 AudioUser::Popup))
-                AudioUser::Popup,
+                                     });
-            ))
-        });
     }
 
 
@@ -133,8 +132,7 @@ where
 
 /// When the about menu item is activated.
 fn on_about_item_activate<T>(appstate: &AppS<T>)
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let popup_menu = &appstate.gui.popup_menu.menu_window;
     let about_dialog = create_about_dialog();
@@ -178,8 +176,7 @@ 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
+    where T: AudioFrontend + 'static
-    T: AudioFrontend + 'static,
 {
     /* TODO: only create if needed */
     show_prefs_dialog(appstate);
@@ -188,8 +185,7 @@ where
 
 /// When the Mute item is checked.
 fn set_mute_check<T>(apps: &Rc<AppS<T>>)
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let mute_check = &apps.gui.popup_menu.mute_check;
     let m_muted = apps.audio.get_mute();

src/ui_popup_window.rs

@@ -5,13 +5,12 @@
 
 
 use app_state::*;
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use gdk::DeviceExt;
-use gdk::{GrabOwnership, GrabStatus};
+use gdk::{GrabOwnership, GrabStatus, BUTTON_PRESS_MASK, KEY_PRESS_MASK};
 use gdk;
 use gdk_sys::{GDK_KEY_Escape, GDK_CURRENT_TIME};
-use glib::translate::*;
 use glib;
 use gtk::ToggleButtonExt;
 use gtk::prelude::*;
@@ -19,8 +18,8 @@ use gtk;
 use prefs::*;
 use std::cell::Cell;
 use std::rc::Rc;
-use support::audio::*;
+use support_audio::*;
-use support::cmd::*;
+use support_cmd::*;
 
 
 
@@ -50,22 +49,21 @@ impl PopupWindow {
     /// Constructor.
     pub fn new(builder: gtk::Builder) -> PopupWindow {
         return PopupWindow {
-            _cant_construct: (),
+                   _cant_construct: (),
-            popup_window: builder.get_object("popup_window").unwrap(),
+                   popup_window: builder.get_object("popup_window").unwrap(),
-            vol_scale_adj: builder.get_object("vol_scale_adj").unwrap(),
+                   vol_scale_adj: builder.get_object("vol_scale_adj").unwrap(),
-            vol_scale: builder.get_object("vol_scale").unwrap(),
+                   vol_scale: builder.get_object("vol_scale").unwrap(),
-            mute_check: builder.get_object("mute_check").unwrap(),
+                   mute_check: builder.get_object("mute_check").unwrap(),
-            mixer_button: builder.get_object("mixer_button").unwrap(),
+                   mixer_button: builder.get_object("mixer_button").unwrap(),
-            toggle_signal: Cell::new(0),
+                   toggle_signal: Cell::new(0),
-            changed_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
+        where T: AudioFrontend
-        T: AudioFrontend,
     {
         let cur_vol = audio.get_vol()?;
         set_slider(&self.vol_scale_adj, cur_vol);
@@ -77,13 +75,11 @@ impl PopupWindow {
 
     /// Update the mute checkbutton.
     pub fn update_mute_check<T>(&self, audio: &T)
-    where
+        where T: AudioFrontend
-        T: AudioFrontend,
     {
         let m_muted = audio.get_mute();
 
-        glib::signal_handler_block(&self.mute_check,
+        glib::signal_handler_block(&self.mute_check, self.toggle_signal.get());
-                                   &from_glib(self.toggle_signal.get()));
 
         match m_muted {
             Ok(val) => {
@@ -101,36 +97,34 @@ impl PopupWindow {
             }
         }
 
-        glib::signal_handler_unblock(
+        glib::signal_handler_unblock(&self.mute_check,
-            &self.mute_check,
+                                     self.toggle_signal.get());
-            &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(
+        self.vol_scale_adj
-            prefs.behavior_prefs.vol_scroll_step,
+            .set_page_increment(prefs.behavior_prefs.vol_scroll_step);
-        );
+        self.vol_scale_adj
-        self.vol_scale_adj.set_step_increment(
+            .set_step_increment(prefs.behavior_prefs.vol_fine_scroll_step);
-            prefs.behavior_prefs.vol_fine_scroll_step,
-        );
     }
 }
 
 
 /// Initialize the popup window subsystem.
 pub fn init_popup_window<T>(appstate: Rc<AppS<T>>)
-where
+    where T: AudioFrontend + 'static
-    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() {
+            if !apps.gui
+                    .popup_window
+                    .popup_window
+                    .get_visible() {
                 return;
             }
             match (s, u) {
@@ -142,9 +136,8 @@ where
                  * and not the real value reported by the audio system.
                  */
                 (_, AudioUser::Popup) => {
-                    apps.gui.popup_window.update_mute_check(
+                    apps.gui.popup_window.update_mute_check(apps.audio
-                        apps.audio.as_ref(),
+                                                                .as_ref());
-                    );
                 }
                 /* external change, safe to update slider too */
                 (_, _) => {
@@ -157,47 +150,70 @@ where
     /* mute_check.connect_toggled */
     {
         let _appstate = appstate.clone();
-        let mute_check = &appstate.clone().gui.popup_window.mute_check;
+        let mute_check = &appstate.clone()
-        let toggle_signal = mute_check.connect_toggled(move |_| {
+                              .gui
-            on_mute_check_toggled(&_appstate)
+                              .popup_window
-        });
+                              .mute_check;
-        appstate.gui.popup_window.toggle_signal.set(toggle_signal.to_glib());
+        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;
+        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 vol_scale_adj = &appstate.clone()
-        let changed_signal = vol_scale_adj.connect_value_changed(move |_| {
+                                 .gui
-            on_vol_scale_value_changed(&_appstate)
+                                 .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());
+        appstate.gui
+            .popup_window
+            .changed_signal
+            .set(changed_signal);
     }
 
     /* popup_window.connect_event */
     {
-        let popup_window = &appstate.clone().gui.popup_window.popup_window;
+        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;
+        let mixer_button = &appstate.clone()
+                                .gui
+                                .popup_window
+                                .mixer_button;
         mixer_button.connect_clicked(move |_| {
-            apps.gui.popup_window.popup_window.hide();
+            apps.gui
-            let _ = result_warn!(
+                .popup_window
-                execute_vol_control_command(&apps.prefs.borrow()),
+                .popup_window
-                Some(&apps.gui.popup_menu.menu_window)
+                .hide();
-            );
+            let _ = result_warn!(execute_vol_control_command(&apps.prefs.borrow()),
+                Some(&apps.gui.popup_menu.menu_window));
         });
     }
 }
@@ -205,22 +221,15 @@ where
 
 /// When the popup window is shown.
 fn on_popup_window_show<T>(appstate: &AppS<T>)
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let popup_window = &appstate.gui.popup_window;
-    appstate.gui.popup_window.set_vol_increment(
+    appstate.gui.popup_window.set_vol_increment(&appstate.prefs.borrow());
-        &appstate.prefs.borrow(),
+    glib::signal_handler_block(&popup_window.vol_scale_adj,
-    );
+                               popup_window.changed_signal.get());
-    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(
+    glib::signal_handler_unblock(&popup_window.vol_scale_adj,
-        &popup_window.vol_scale_adj,
+                                 popup_window.changed_signal.get());
-        &from_glib(popup_window.changed_signal.get()),
-    );
     popup_window.vol_scale.grab_focus();
     try_w!(grab_devices(&appstate.gui.popup_window.popup_window));
 }
@@ -258,29 +267,31 @@ fn on_popup_window_event(w: &gtk::Window, e: &gdk::Event) -> gtk::Inhibit {
 
 /// When the volume scale slider is moved.
 fn on_vol_scale_value_changed<T>(appstate: &AppS<T>)
-where
+    where T: AudioFrontend
-    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 val = appstate.gui
+        .popup_window
+        .vol_scale
+        .get_value();
 
     let dir = vol_change_to_voldir(old_vol, val);
 
-    try_w!(audio.set_vol(
+    try_w!(audio.set_vol(val,
-        val,
+                         AudioUser::Popup,
-        AudioUser::Popup,
+                         dir,
-        dir,
+                         appstate.prefs
-        appstate.prefs.borrow().behavior_prefs.unmute_on_vol_change,
+                             .borrow()
-    ));
+                             .behavior_prefs
+                             .unmute_on_vol_change));
 }
 
 
 /// When the mute checkbutton is toggled.
 fn on_mute_check_toggled<T>(appstate: &AppS<T>)
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let audio = &appstate.audio;
     try_w!(audio.toggle_mute(AudioUser::Popup))
@@ -300,40 +311,32 @@ fn grab_devices(window: &gtk::Window) -> Result<()> {
     let gdk_window = window.get_window().ok_or("No window?!")?;
 
     /* Grab the mouse */
-    let m_grab_status = device.grab(
+    let m_grab_status =
-        &gdk_window,
+        device.grab(&gdk_window,
-        GrabOwnership::None,
+                    GrabOwnership::None,
-        true,
+                    true,
-        gdk::EventMask::BUTTON_PRESS_MASK,
+                    BUTTON_PRESS_MASK,
-        None,
+                    None,
-        GDK_CURRENT_TIME as u32,
+                    GDK_CURRENT_TIME as u32);
-    );
 
     if m_grab_status != GrabStatus::Success {
-        warn!(
+        warn!("Could not grab {}",
-            "Could not grab {}",
+              device.get_name().unwrap_or(String::from("UNKNOWN DEVICE")));
-            device.get_name().unwrap_or(String::from("UNKNOWN DEVICE"))
-        );
     }
 
     /* Grab the keyboard */
-    let k_dev = device.get_associated_device().ok_or(
+    let k_dev = device.get_associated_device()
-        "Couldn't get associated device",
+        .ok_or("Couldn't get associated device")?;
-    )?;
 
-    let k_grab_status = k_dev.grab(
+    let k_grab_status = k_dev.grab(&gdk_window,
-        &gdk_window,
+                                   GrabOwnership::None,
-        GrabOwnership::None,
+                                   true,
-        true,
+                                   KEY_PRESS_MASK,
-        gdk::EventMask::KEY_PRESS_MASK,
+                                   None,
-        None,
+                                   GDK_CURRENT_TIME as u32);
-        GDK_CURRENT_TIME as u32,
-    );
     if k_grab_status != GrabStatus::Success {
-        warn!(
+        warn!("Could not grab {}",
-            "Could not grab {}",
+              k_dev.get_name().unwrap_or(String::from("UNKNOWN DEVICE")));
-            k_dev.get_name().unwrap_or(String::from("UNKNOWN DEVICE"))
-        );
     }
 
     return Ok(());

src/ui_prefs_dialog.rs

@@ -3,17 +3,18 @@
 
 
 use app_state::*;
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use gdk;
 use gtk::ResponseType;
 use gtk::prelude::*;
 use gtk;
 use prefs::*;
+use std::ascii::AsciiExt;
 use std::cell::RefCell;
 use std::rc::Rc;
-use support::audio::*;
+use support_audio::*;
-use ui::hotkey_dialog::HotkeyDialog;
+use ui_hotkey_dialog::HotkeyDialog;
 
 
 
@@ -73,10 +74,9 @@ pub struct PrefsDialog {
 
 impl PrefsDialog {
     fn new() -> PrefsDialog {
-        let builder = gtk::Builder::new_from_string(include_str!(concat!(
+        let builder =
-            env!("CARGO_MANIFEST_DIR"),
+            gtk::Builder::new_from_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"),
-            "/data/ui/prefs-dialog.glade"
+                                                               "/data/ui/prefs-dialog.glade")));
-        )));
         let prefs_dialog = PrefsDialog {
             _cant_construct: (),
             prefs_dialog: builder.get_object("prefs_dialog").unwrap(),
@@ -87,44 +87,32 @@ impl PrefsDialog {
             chan_combo: builder.get_object("chan_combo").unwrap(),
 
             /* ViewPrefs */
-            vol_meter_draw_check: builder
+            vol_meter_draw_check: builder.get_object("vol_meter_draw_check")
-                .get_object("vol_meter_draw_check")
                 .unwrap(),
-            vol_meter_pos_spin: builder
+            vol_meter_pos_spin: builder.get_object("vol_meter_pos_spin")
-                .get_object("vol_meter_pos_spin")
                 .unwrap(),
-            vol_meter_color_button: builder
+            vol_meter_color_button: builder.get_object("vol_meter_color_button")
-                .get_object("vol_meter_color_button")
                 .unwrap(),
             system_theme: builder.get_object("system_theme").unwrap(),
 
             /* BehaviorPrefs */
-            unmute_on_vol_change: builder
+            unmute_on_vol_change: builder.get_object("unmute_on_vol_change")
-                .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
+            fine_scroll_step_spin: builder.get_object("fine_scroll_step_spin")
-                .get_object("fine_scroll_step_spin")
                 .unwrap(),
-            middle_click_combo: builder
+            middle_click_combo: builder.get_object("middle_click_combo")
-                .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(),
@@ -134,41 +122,33 @@ impl PrefsDialog {
             noti_hotkey_check: builder.get_object("noti_hotkey_check").unwrap(),
 
             /* HotkeyPrefs */
-            hotkeys_enable_check: builder
+            hotkeys_enable_check: builder.get_object("hotkeys_enable_check")
-                .get_object("hotkeys_enable_check")
                 .unwrap(),
-            hotkeys_mute_label: builder
+            hotkeys_mute_label: builder.get_object("hotkeys_mute_label")
-                .get_object("hotkeys_mute_label")
                 .unwrap(),
             hotkeys_up_label: builder.get_object("hotkeys_up_label").unwrap(),
-            hotkeys_down_label: builder
+            hotkeys_down_label: builder.get_object("hotkeys_down_label")
-                .get_object("hotkeys_down_label")
                 .unwrap(),
 
             /* Hotkey stuff (not prefs) */
-            hotkeys_mute_eventbox: builder
+            hotkeys_mute_eventbox: builder.get_object("hotkeys_mute_eventbox")
-                .get_object("hotkeys_mute_eventbox")
                 .unwrap(),
-            hotkeys_up_eventbox: builder
+            hotkeys_up_eventbox: builder.get_object("hotkeys_up_eventbox")
-                .get_object("hotkeys_up_eventbox")
                 .unwrap(),
-            hotkeys_down_eventbox: builder
+            hotkeys_down_eventbox: builder.get_object("hotkeys_down_eventbox")
-                .get_object("hotkeys_down_eventbox")
                 .unwrap(),
             hotkey_dialog: RefCell::new(None),
         };
 
         #[cfg(feature = "notify")]
-        let notify_tab: gtk::Box =
+        let notify_tab: gtk::Box = builder.get_object("noti_vbox_enabled")
-            builder.get_object("noti_vbox_enabled").unwrap();
+            .unwrap();
         #[cfg(not(feature = "notify"))]
-        let notify_tab: gtk::Box =
+        let notify_tab: gtk::Box = builder.get_object("noti_vbox_disabled")
-            builder.get_object("noti_vbox_disabled").unwrap();
+            .unwrap();
 
-        prefs_dialog.notebook.append_page(
+        prefs_dialog.notebook.append_page(&notify_tab,
-            &notify_tab,
+                                          Some(&gtk::Label::new(Some("Notifications"))));
-            Some(&gtk::Label::new(Some("Notifications"))),
-        );
         return prefs_dialog;
     }
 
@@ -181,13 +161,9 @@ impl PrefsDialog {
         self.chan_combo.remove_all();
 
         /* ViewPrefs */
-        self.vol_meter_draw_check.set_active(
+        self.vol_meter_draw_check.set_active(prefs.view_prefs.draw_vol_meter);
-            prefs.view_prefs.draw_vol_meter,
+        self.vol_meter_pos_spin.set_value(prefs.view_prefs.vol_meter_offset as
-        );
+                                          f64);
-        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,
@@ -199,105 +175,64 @@ impl PrefsDialog {
         self.system_theme.set_active(prefs.view_prefs.system_theme);
 
         /* BehaviorPrefs */
-        self.unmute_on_vol_change.set_active(
+        self.unmute_on_vol_change
-            prefs
+            .set_active(prefs.behavior_prefs.unmute_on_vol_change);
-                .behavior_prefs
+        self.vol_control_entry.set_text(prefs.behavior_prefs
-                .unmute_on_vol_change,
+                                            .vol_control_cmd
-        );
+                                            .as_ref()
-        self.vol_control_entry.set_text(
+                                            .unwrap_or(&String::from(""))
-            prefs
+                                            .as_str());
-                .behavior_prefs
+        self.scroll_step_spin.set_value(prefs.behavior_prefs.vol_scroll_step);
-                .vol_control_cmd
+        self.fine_scroll_step_spin
-                .as_ref()
+            .set_value(prefs.behavior_prefs.vol_fine_scroll_step);
-                .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(
+        self.middle_click_combo.append_text("Custom Command (set below)");
-            "Custom Command (set below)",
+        self.middle_click_combo.set_active(prefs.behavior_prefs
-        );
+                                               .middle_click_action
-        self.middle_click_combo.set_active(
+                                               .into());
-            prefs
+        self.custom_entry.set_text(prefs.behavior_prefs
-                .behavior_prefs
+                                       .custom_command
-                .middle_click_action
+                                       .as_ref()
-                .into(),
+                                       .unwrap_or(&String::from(""))
-        );
+                                       .as_str());
-        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(
+            self.noti_enable_check
-                prefs
+                .set_active(prefs.notify_prefs.enable_notifications);
-                    .notify_prefs
+            self.noti_timeout_spin
-                    .enable_notifications,
+                .set_value(prefs.notify_prefs.notifcation_timeout as f64);
-            );
+            self.noti_mouse_check
-            self.noti_timeout_spin.set_value(
+                .set_active(prefs.notify_prefs.notify_mouse_scroll);
-                prefs.notify_prefs.notifcation_timeout as
+            self.noti_popup_check.set_active(prefs.notify_prefs.notify_popup);
-                    f64,
+            self.noti_ext_check.set_active(prefs.notify_prefs.notify_external);
-            );
+            self.noti_hotkey_check
-            self.noti_mouse_check.set_active(
+                .set_active(prefs.notify_prefs.notify_hotkeys);
-                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(
+        self.hotkeys_enable_check.set_active(prefs.hotkey_prefs.enable_hotkeys);
-            prefs.hotkey_prefs.enable_hotkeys,
+        self.hotkeys_mute_label.set_text(prefs.hotkey_prefs
-        );
+                                             .mute_unmute_key
-        self.hotkeys_mute_label.set_text(
+                                             .clone()
-            prefs
+                                             .unwrap_or(String::from("(None)"))
-                .hotkey_prefs
+                                             .as_str());
-                .mute_unmute_key
+        self.hotkeys_up_label.set_text(prefs.hotkey_prefs
-                .clone()
+                                           .vol_up_key
-                .unwrap_or(String::from("(None)"))
+                                           .clone()
-                .as_str(),
+                                           .unwrap_or(String::from("(None)"))
-        );
+                                           .as_str());
-        self.hotkeys_up_label.set_text(
+        self.hotkeys_down_label.set_text(prefs.hotkey_prefs
-            prefs
+                                             .vol_down_key
-                .hotkey_prefs
+                                             .clone()
-                .vol_up_key
+                                             .unwrap_or(String::from("(None)"))
-                .clone()
+                                             .as_str());
-                .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(),
-        );
     }
 
 
@@ -329,16 +264,19 @@ impl PrefsDialog {
             vol_meter_color,
         };
 
-        let vol_control_cmd = self.vol_control_entry.get_text().and_then(|x| {
+        let vol_control_cmd =
-            if x.is_empty() { None } else { Some(x) }
+            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
+                                                      None
-            } else {
+                                                  } else {
-                Some(x)
+                                                      Some(x)
-            });
+                                                  });
 
         let behavior_prefs = BehaviorPrefs {
             unmute_on_vol_change: self.unmute_on_vol_change.get_active(),
@@ -353,49 +291,42 @@ impl PrefsDialog {
         let notify_prefs = NotifyPrefs {
             enable_notifications: self.noti_enable_check.get_active(),
             notifcation_timeout: self.noti_timeout_spin.get_value_as_int() as
-                i64,
+                                 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 =
+        let hotkey_prefs = HotkeyPrefs {
-            HotkeyPrefs {
+            enable_hotkeys: self.hotkeys_enable_check.get_active(),
-                enable_hotkeys: self.hotkeys_enable_check.get_active(),
+            mute_unmute_key:
-                mute_unmute_key: self.hotkeys_mute_label.get_text().and_then(
+                self.hotkeys_mute_label.get_text().and_then(|s| if s ==
-                    |s| {
+                                                                   "(None)" {
-                        if s == "(None)" { None } else { Some(s) }
+                                                                None
-                    },
+                                                            } else {
-                ),
+                                                                Some(s)
-                vol_up_key: self.hotkeys_up_label.get_text().and_then(
+                                                            }),
-                    |s| if s ==
+            vol_up_key:
-                        "(None)"
+                self.hotkeys_up_label.get_text().and_then(|s| if s ==
-                    {
+                                                                 "(None)" {
-                        None
+                                                              None
-                    } else {
+                                                          } else {
-                        Some(s)
+                                                              Some(s)
-                    },
+                                                          }),
-                ),
+            vol_down_key: self.hotkeys_down_label.get_text().and_then(|s| {
-                vol_down_key: self.hotkeys_down_label.get_text().and_then(
+                if s == "(None)" { None } else { Some(s) }
-                    |s| if s ==
+            }),
-                        "(None)"
+        };
-                    {
-                        None
-                    } else {
-                        Some(s)
-                    },
-                ),
-            };
 
         return Prefs {
-            device_prefs,
+                   device_prefs,
-            view_prefs,
+                   view_prefs,
-            behavior_prefs,
+                   behavior_prefs,
-            #[cfg(feature = "notify")]
+                   #[cfg(feature = "notify")]
-            notify_prefs,
+                   notify_prefs,
-            hotkey_prefs,
+                   hotkey_prefs,
-        };
+               };
 
     }
 }
@@ -404,10 +335,12 @@ impl PrefsDialog {
 /// 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
+    where T: AudioFrontend + 'static
-    T: AudioFrontend + 'static,
 {
-    if appstate.gui.prefs_dialog.borrow().is_some() {
+    if appstate.gui
+           .prefs_dialog
+           .borrow()
+           .is_some() {
         return;
     }
 
@@ -429,13 +362,15 @@ where
 /// Initialize the internal prefs dialog handler that connects to the audio
 /// system.
 pub fn init_prefs_callback<T>(appstate: Rc<AppS<T>>)
-where
+    where T: AudioFrontend + 'static
-    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() {
+        if apps.gui
+               .prefs_dialog
+               .borrow()
+               .is_none() {
             return;
         }
 
@@ -453,8 +388,7 @@ where
 
 /// Initialize the preferences dialog gtk callbacks.
 fn init_prefs_dialog<T>(appstate: &Rc<AppS<T>>)
-where
+    where T: AudioFrontend + 'static
-    T: AudioFrontend + 'static,
 {
 
     /* prefs_dialog.connect_show */
@@ -463,9 +397,9 @@ where
         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_card_combo(&apps);
-            fill_chan_combo(&apps, None);
+                                         fill_chan_combo(&apps, None);
-        });
+                                     });
     }
 
     /* card_combo.connect_changed */
@@ -491,8 +425,7 @@ where
         pd.prefs_dialog.connect_response(move |_, response_id| {
 
             if response_id == ResponseType::Ok.into() ||
-                response_id == ResponseType::Apply.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();
@@ -501,25 +434,23 @@ where
 
             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.as_ref()
+                    .unwrap()
+                    .prefs_dialog
+                    .destroy();
                 *prefs_dialog = None;
             }
 
             if response_id == ResponseType::Ok.into() ||
-                response_id == ResponseType::Apply.into()
+               response_id == ResponseType::Apply.into() {
-            {
                 try_w!(apps.update_popup_window());
                 try_w!(apps.update_tray_icon());
-                let _ = result_warn!(
+                let _ = result_warn!(apps.update_hotkeys(),
-                    apps.update_hotkeys(),
+                                     Some(&apps.gui.popup_menu.menu_window));
-                    Some(&apps.gui.popup_menu.menu_window)
-                );
                 apps.update_notify();
                 try_w!(apps.update_audio(AudioUser::PrefsWindow));
-                let _ = result_warn!(
+                let _ = result_warn!(apps.update_config(),
-                    apps.update_config(),
+                                     Some(&apps.gui.popup_menu.menu_window));
-                    Some(&apps.gui.popup_menu.menu_window)
-                );
             }
 
         });
@@ -531,13 +462,9 @@ where
         let m_pd = appstate.gui.prefs_dialog.borrow();
         let pd = m_pd.as_ref().unwrap();
 
-        pd.hotkeys_mute_eventbox.connect_button_press_event(
+        pd.hotkeys_mute_eventbox.connect_button_press_event(move |w, e| {
-            move |w, e| {
+            return Inhibit(on_hotkey_event_box_button_press_event(&apps, &w, e));
-                return Inhibit(
+        });
-                    on_hotkey_event_box_button_press_event(&apps, &w, e),
-                );
-            },
-        );
     }
 
     /* prefs_dialog.hotkeys_up_eventbox */
@@ -546,13 +473,9 @@ where
         let m_pd = appstate.gui.prefs_dialog.borrow();
         let pd = m_pd.as_ref().unwrap();
 
-        pd.hotkeys_up_eventbox.connect_button_press_event(
+        pd.hotkeys_up_eventbox.connect_button_press_event(move |w, e| {
-            move |w, e| {
+            return Inhibit(on_hotkey_event_box_button_press_event(&apps, &w, e));
-                return Inhibit(
+        });
-                    on_hotkey_event_box_button_press_event(&apps, &w, e),
-                );
-            },
-        );
     }
 
     /* prefs_dialog.hotkeys_down_eventbox */
@@ -561,21 +484,16 @@ where
         let m_pd = appstate.gui.prefs_dialog.borrow();
         let pd = m_pd.as_ref().unwrap();
 
-        pd.hotkeys_down_eventbox.connect_button_press_event(
+        pd.hotkeys_down_eventbox.connect_button_press_event(move |w, e| {
-            move |w, e| {
+            return Inhibit(on_hotkey_event_box_button_press_event(&apps, &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
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let m_cc = appstate.gui.prefs_dialog.borrow();
     let card_combo = &m_cc.as_ref().unwrap().card_combo;
@@ -583,8 +501,8 @@ where
     let audio = &appstate.audio;
 
     /* set card combo */
-    let cur_card_name =
+    let cur_card_name = try_w!(audio.card_name(),
-        try_w!(audio.card_name(), "Can't get current 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 */
@@ -604,8 +522,7 @@ where
 
 /// Fill the channel combo box in the Devices tab.
 fn fill_chan_combo<T>(appstate: &AppS<T>, cardname: Option<String>)
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let m_cc = appstate.gui.prefs_dialog.borrow();
     let chan_combo = &m_cc.as_ref().unwrap().chan_combo;
@@ -636,13 +553,11 @@ where
 }
 
 
-fn on_hotkey_event_box_button_press_event<T>(
+fn on_hotkey_event_box_button_press_event<T>(appstate: &AppS<T>,
-    appstate: &AppS<T>,
+                                             widget: &gtk::EventBox,
-    widget: &gtk::EventBox,
+                                             event: &gdk::EventButton)
-    event: &gdk::EventButton,
+                                             -> bool
-) -> bool
+    where T: AudioFrontend
-where
-    T: AudioFrontend,
 {
     let borrow = appstate.gui.prefs_dialog.borrow();
     let prefs_dialog = &borrow.as_ref().unwrap();
@@ -658,20 +573,13 @@ where
 
     let (hotkey_label, hotkey) = {
         if *widget == prefs_dialog.hotkeys_mute_eventbox {
-            (
+            (prefs_dialog.hotkeys_mute_label.clone(),
-                prefs_dialog.hotkeys_mute_label.clone(),
+             String::from("Mute/Unmute"))
-                String::from("Mute/Unmute"),
-            )
         } else if *widget == prefs_dialog.hotkeys_up_eventbox {
-            (
+            (prefs_dialog.hotkeys_up_label.clone(), String::from("Volume Up"))
-                prefs_dialog.hotkeys_up_label.clone(),
-                String::from("Volume Up"),
-            )
         } else if *widget == prefs_dialog.hotkeys_down_eventbox {
-            (
+            (prefs_dialog.hotkeys_down_label.clone(),
-                prefs_dialog.hotkeys_down_label.clone(),
+             String::from("Volume Down"))
-                String::from("Volume Down"),
-            )
         } else {
             warn!("Unknown hotkey eventbox");
             return false;
@@ -690,7 +598,10 @@ where
     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();
+    let key_pressed = hotkey_dialog.borrow()
+        .as_ref()
+        .unwrap()
+        .run();
     *hotkey_dialog.borrow_mut() = None;
 
     /* Bind hotkeys */
@@ -712,10 +623,8 @@ where
         }
         Err(e) => {
             // Could not grab hotkey, most likely
-            error_dialog!(
+            error_dialog!(e.description(),
-                e.description(),
+                          Some(&appstate.gui.popup_menu.menu_window));
-                Some(&appstate.gui.popup_menu.menu_window)
-            );
             warn!("{}", e);
             return false;
         }

src/ui_tray_icon.rs

@@ -5,7 +5,7 @@
 
 
 use app_state::*;
-use audio::frontend::*;
+use audio::*;
 use errors::*;
 use gdk;
 use gdk_pixbuf;
@@ -16,9 +16,9 @@ use prefs::{Prefs, MiddleClickAction};
 use std::cell::Cell;
 use std::cell::RefCell;
 use std::rc::Rc;
-use support::cmd::*;
+use support_cmd::*;
-use support::ui::*;
+use support_ui::*;
-use ui::prefs_dialog::show_prefs_dialog;
+use ui_prefs_dialog::show_prefs_dialog;
 
 
 
@@ -63,22 +63,21 @@ impl TrayIcon {
         let status_icon = gtk::StatusIcon::new();
 
         return Ok(TrayIcon {
-            _cant_construct: (),
+                      _cant_construct: (),
-            volmeter,
+                      volmeter,
-            audio_pix: RefCell::new(audio_pix),
+                      audio_pix: RefCell::new(audio_pix),
-            status_icon,
+                      status_icon,
-            icon_size: Cell::new(ICON_MIN_SIZE),
+                      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(
+    fn update_vol_meter(&self,
-        &self,
+                        cur_vol: f64,
-        cur_vol: f64,
+                        vol_level: VolLevel)
-        vol_level: VolLevel,
+                        -> Result<()> {
-    ) -> Result<()> {
         let audio_pix = self.audio_pix.borrow();
         let pixbuf = audio_pix.select_pix(vol_level);
 
@@ -98,15 +97,13 @@ impl TrayIcon {
 
     /// Update the tooltip of the tray icon.
     fn update_tooltip<T>(&self, audio: &T)
-    where
+        where T: AudioFrontend
-        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
+        let vol = audio.get_vol()
-            .get_vol()
             .map(|s| format!("{}", s.round()))
             .unwrap_or(String::from("unknown volume"));
         let mute_info = {
@@ -118,27 +115,22 @@ impl TrayIcon {
                 ""
             }
         };
-        self.status_icon.set_tooltip_text(
+        self.status_icon.set_tooltip_text(format!("{} ({})\nVolume: {}{}",
-            format!(
+                                                  cardname,
-                "{} ({})\nVolume: {}{}",
+                                                  channame,
-                cardname,
+                                                  vol,
-                channame,
+                                                  mute_info)
-                vol,
+                                                  .as_str());
-                mute_info
-            ).as_str(),
-        );
     }
 
 
     /// Update the whole tray icon state.
-    pub fn update_all<T>(
+    pub fn update_all<T>(&self,
-        &self,
+                         prefs: &Prefs,
-        prefs: &Prefs,
+                         audio: &T,
-        audio: &T,
+                         m_size: Option<i32>)
-        m_size: Option<i32>,
+                         -> Result<()>
-    ) -> Result<()>
+        where T: AudioFrontend
-    where
-        T: AudioFrontend,
     {
         match m_size {
             Some(s) => {
@@ -186,61 +178,50 @@ 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,
+                   red: (prefs.view_prefs.vol_meter_color.red * 255.0) as u8,
-            green: (prefs.view_prefs.vol_meter_color.green * 255.0) as u8,
+                   green: (prefs.view_prefs.vol_meter_color.green * 255.0) as
-            blue: (prefs.view_prefs.vol_meter_color.blue * 255.0) as u8,
+                          u8,
-            x_offset_pct: prefs.view_prefs.vol_meter_offset as i64,
+                   blue: (prefs.view_prefs.vol_meter_color.blue * 255.0) as u8,
-            y_offset_pct: 10,
+                   x_offset_pct: prefs.view_prefs.vol_meter_offset as i64,
-            /* dynamic */
+                   y_offset_pct: 10,
-            width: Cell::new(0),
+                   /* dynamic */
-            row: RefCell::new(vec![]),
+                   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(
+    fn meter_draw(&self,
-        &self,
+                  volume: i64,
-        volume: i64,
+                  pixbuf: &gdk_pixbuf::Pixbuf)
-        pixbuf: &gdk_pixbuf::Pixbuf,
+                  -> Result<gdk_pixbuf::Pixbuf> {
-    ) -> Result<gdk_pixbuf::Pixbuf> {
 
-        ensure!(
+        ensure!(pixbuf.get_colorspace() == gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
-            pixbuf.get_colorspace() == gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
+                "Invalid colorspace in pixbuf");
-            "Invalid colorspace in pixbuf"
+        ensure!(pixbuf.get_bits_per_sample() == 8,
-        );
+                "Invalid bits per sample 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!(
+        ensure!(pixbuf.get_n_channels() == 4,
-            pixbuf.get_n_channels() == 4,
+                "Invalid number of channels in pixbuf");
-            "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
+                 ((i_width - vm_width) as f64 / 100.0)) as i64;
-            i64;
+        ensure!(x >= 0 && (x + vm_width) <= i_width,
-        ensure!(
+                "x coordinate invalid: {}",
-            x >= 0 && (x + vm_width) <= i_width,
+                x);
-            "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!(
+        ensure!(y >= 0 && (y + vm_height) <= i_height,
-            y >= 0 && (y + vm_height) <= i_height,
+                "y coordinate invalid: {}",
-            "y coordinate invalid: {}",
+                y);
-            y
-        );
 
         /* Let's check if the icon width changed, in which case we
          * must reinit our internal row of pixels.
@@ -276,9 +257,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(
+                pixels[p_index..p_index + row.len()]
-                    row.as_ref(),
+                    .copy_from_slice(row.as_ref());
-                );
 
             }
         }
@@ -303,22 +283,22 @@ pub struct AudioPix {
 
 impl Default for AudioPix {
     fn default() -> AudioPix {
-        let dummy_pixbuf = unsafe {
+        let dummy_pixbuf =
-            gdk_pixbuf::Pixbuf::new(
+            unsafe {
-                gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
+                gdk_pixbuf::Pixbuf::new(gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
-                false,
+                                        false,
-                8,
+                                        8,
-                1,
+                                        1,
-                1,
+                                        1)
-            ).unwrap()
+                        .unwrap()
-        };
+            };
         return AudioPix {
-            muted: dummy_pixbuf.clone(),
+                   muted: dummy_pixbuf.clone(),
-            low: dummy_pixbuf.clone(),
+                   low: dummy_pixbuf.clone(),
-            medium: dummy_pixbuf.clone(),
+                   medium: dummy_pixbuf.clone(),
-            high: dummy_pixbuf.clone(),
+                   high: dummy_pixbuf.clone(),
-            off: dummy_pixbuf.clone(),
+                   off: dummy_pixbuf.clone(),
-        };
+               };
     }
 }
 
@@ -372,21 +352,11 @@ impl AudioPix {
                 }
             } else {
                 AudioPix {
-                    muted: pixbuf_new_from_png!(
+                    muted: pixbuf_new_from_png!("../data/pixmaps/pnmixer-muted.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")?,
-                    low: pixbuf_new_from_png!(
+                    high: pixbuf_new_from_png!("../data/pixmaps/pnmixer-high.png")?,
-                        "../../data/pixmaps/pnmixer-low.png"
+                    off: pixbuf_new_from_png!("../data/pixmaps/pnmixer-off.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"
-                    )?,
                 }
             }
         };
@@ -409,8 +379,7 @@ impl AudioPix {
 
 /// Initialize the tray icon subsystem.
 pub fn init_tray_icon<T>(appstate: Rc<AppS<T>>)
-where
+    where T: AudioFrontend + 'static
-    T: AudioFrontend + 'static,
 {
     let tray_icon = &appstate.gui.tray_icon;
 
@@ -419,31 +388,24 @@ where
     /* connect audio handler */
     {
         let apps = appstate.clone();
-        appstate.audio.connect_handler(
+        appstate.audio.connect_handler(Box::new(move |s, u| match (s, u) {
-            Box::new(move |s, u| match (s, u) {
+                                                    (_, _) => {
-                (_, _) => {
+            apps.gui.tray_icon.update_tooltip(apps.audio.as_ref());
-                    apps.gui.tray_icon.update_tooltip(apps.audio.as_ref());
+            try_w!(apps.gui.tray_icon.update_vol_meter(try_w!(apps.audio
-                    try_w!(apps.gui.tray_icon.update_vol_meter(
+                                                                  .get_vol()),
-                        try_w!(apps.audio.get_vol()),
+                                                       apps.audio.vol_level()));
-                        apps.audio.vol_level(),
+        }
-                    ));
+                                                }));
-                }
-            }),
-        );
     }
 
     /* tray_icon.connect_size_changed */
     {
         let apps = appstate.clone();
         tray_icon.status_icon.connect_size_changed(move |_, size| {
-            try_wr!(
+            try_wr!(apps.gui.tray_icon.update_all(&apps.prefs.borrow_mut(),
-                apps.gui.tray_icon.update_all(
+                                                  apps.audio.as_ref(),
-                    &apps.prefs.borrow_mut(),
+                                                  Some(size)),
-                    apps.audio.as_ref(),
+                    false);
-                    Some(size),
-                ),
-                false
-            );
             return false;
         });
     }
@@ -451,9 +413,9 @@ where
     /* tray_icon.connect_activate */
     {
         let apps = appstate.clone();
-        tray_icon.status_icon.connect_activate(
+        tray_icon.status_icon.connect_activate(move |_| {
-            move |_| on_tray_icon_activate(&apps),
+                                                   on_tray_icon_activate(&apps)
-        );
+                                               });
     }
 
     /* tray_icon.connect_scroll_event */
@@ -484,15 +446,12 @@ where
     {
         let apps = appstate.clone();
         let default_theme = try_w!(gtk::IconTheme::get_default().ok_or(
-            "Couldn't get default icon theme",
+                        "Couldn't get default icon theme",
-        ));
+                    ));
         default_theme.connect_changed(move |_| {
             let tray_icon = &apps.gui.tray_icon;
-            try_e!(tray_icon.update_all(
+            try_e!(tray_icon.update_all(&apps.prefs.borrow_mut(),
-                &apps.prefs.borrow_mut(),
+                apps.audio.as_ref(), None));
-                apps.audio.as_ref(),
-                None,
-            ));
         });
     }
 }
@@ -500,8 +459,7 @@ where
 
 /// When the tray icon is activated.
 fn on_tray_icon_activate<T>(appstate: &AppS<T>)
-where
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let popup_window = &appstate.gui.popup_window.popup_window;
 
@@ -515,8 +473,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
+    where T: AudioFrontend
-    T: AudioFrontend,
 {
     let popup_window = &appstate.gui.popup_window.popup_window;
     let popup_menu = &appstate.gui.popup_menu.menu;
@@ -528,41 +485,29 @@ where
 
 /// When the mouse scroll event happens while the mouse pointer is
 /// on the tray icon.
-fn on_tray_icon_scroll_event<T>(
+fn on_tray_icon_scroll_event<T>(appstate: &AppS<T>,
-    appstate: &AppS<T>,
+                                event: &gdk::EventScroll)
-    event: &gdk::EventScroll,
+                                -> bool
-) -> bool
+    where T: AudioFrontend
-where
-    T: AudioFrontend,
 {
 
     let scroll_dir: gdk::ScrollDirection = event.get_direction();
     match scroll_dir {
         gdk::ScrollDirection::Up => {
-            try_wr!(
+            try_wr!(appstate.audio.increase_vol(AudioUser::TrayIcon,
-                appstate.audio.increase_vol(
+                                                appstate.prefs
-                    AudioUser::TrayIcon,
+                                                    .borrow()
-                    appstate
+                                                    .behavior_prefs
-                        .prefs
+                                                    .unmute_on_vol_change),
-                        .borrow()
+                    false);
-                        .behavior_prefs
-                        .unmute_on_vol_change,
-                ),
-                false
-            );
         }
         gdk::ScrollDirection::Down => {
-            try_wr!(
+            try_wr!(appstate.audio.decrease_vol(AudioUser::TrayIcon,
-                appstate.audio.decrease_vol(
+                                                appstate.prefs
-                    AudioUser::TrayIcon,
+                                                    .borrow()
-                    appstate
+                                                    .behavior_prefs
-                        .prefs
+                                                    .unmute_on_vol_change),
-                        .borrow()
+                    false);
-                        .behavior_prefs
-                        .unmute_on_vol_change,
-                ),
-                false
-            );
         }
         _ => (),
     }
@@ -574,12 +519,10 @@ 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>(
+fn on_tray_button_release_event<T>(appstate: &Rc<AppS<T>>,
-    appstate: &Rc<AppS<T>>,
+                                   event_button: &gdk::EventButton)
-    event_button: &gdk::EventButton,
+                                   -> bool
-) -> bool
+    where T: AudioFrontend + 'static
-where
-    T: AudioFrontend + 'static,
 {
     let button = event_button.get_button();
 
@@ -602,18 +545,14 @@ where
         // TODO
         &MiddleClickAction::ShowPreferences => show_prefs_dialog(&appstate),
         &MiddleClickAction::VolumeControl => {
-            let _ = result_warn!(
+            let _ = result_warn!(execute_vol_control_command(&appstate.prefs.borrow()),
-                execute_vol_control_command(&appstate.prefs.borrow()),
+                Some(&appstate.gui.popup_menu.menu_window));
-                Some(&appstate.gui.popup_menu.menu_window)
-            );
         }
         &MiddleClickAction::CustomCommand => {
             match custom_command {
                 &Some(ref cmd) => {
-                    let _ = result_warn!(
+                    let _ = result_warn!(execute_command(cmd.as_str()),
-                        execute_command(cmd.as_str()),
+                        Some(&appstate.gui.popup_menu.menu_window));
-                        Some(&appstate.gui.popup_menu.menu_window)
-                    );
                 }
                 &None => warn!("No custom command found"),
             }