Update

src/alsa_pn.rs

@@ -78,10 +78,21 @@ impl AlsaCard {
     }
 
 
+    pub fn card_name(&self) -> Result<String> {
+        return self.card.get_name().from_err();
+    }
+
+
+    pub fn chan_name(&self) -> Result<String> {
+        let n = self.selem_id
+            .get_name()
+            .map(|y| String::from(y))?;
+        return Ok(n);
+    }
+
+
     pub fn selem(&self) -> Selem {
-        return get_selems(&self.mixer)
-                   .nth(self.selem_id.get_index() as usize)
-                   .unwrap();
+        return self.mixer.find_selem(&self.selem_id).unwrap();
     }
 
 
@@ -254,6 +265,19 @@ pub fn get_alsa_cards() -> alsa::card::Iter {
 }
 
 
+pub fn get_alsa_card_names() -> Vec<String> {
+    let mut vec = vec![];
+    for card in get_alsa_cards() {
+        match card.and_then(|c| c.get_name()) {
+            Ok(name) => vec.push(name),
+            _ => (),
+        }
+    }
+
+    return vec;
+}
+
+
 pub fn get_alsa_card_by_name(name: String) -> Result<Card> {
     for r_card in get_alsa_cards() {
         let card = r_card?;
@@ -284,6 +308,22 @@ pub fn get_selems(mixer: &Mixer) -> Map<alsa::mixer::Iter, fn(Elem) -> Selem> {
 }
 
 
+pub fn get_selem_names(mixer: &Mixer) -> Vec<String> {
+    let mut vec = vec![];
+    for selem in get_selems(mixer) {
+        let n = selem.get_id()
+            .get_name()
+            .map(|y| String::from(y));
+        match n {
+            Ok(name) => vec.push(name),
+            _ => (),
+        }
+    }
+
+    return vec;
+}
+
+
 pub fn get_selem_by_name(mixer: &Mixer, name: String) -> Result<Selem> {
     for selem in get_selems(mixer) {
         let n = selem.get_id()

src/app_state.rs

@@ -1,8 +1,6 @@
 use gtk;
 use audio::Audio;
-use std::cell::RefCell;
-use std::rc::Rc;
-use glade_helpers::*;
+
 
 
 // TODO: destructors
@@ -19,8 +17,12 @@ impl AppS {
         let builder_popup_window =
             gtk::Builder::new_from_string(include_str!("../data/ui/popup-window.glade"));
         let builder_popup_menu = gtk::Builder::new_from_string(include_str!("../data/ui/popup-menu.glade"));
+        let builder_prefs_dialog =
+            gtk::Builder::new_from_string(include_str!("../data/ui/prefs-dialog.glade"));
         return AppS {
-                   gui: Gui::new(builder_popup_window, builder_popup_menu),
+                   gui: Gui::new(builder_popup_window,
+                                 builder_popup_menu,
+                                 builder_prefs_dialog),
                    audio: Audio::new(None, Some(String::from("Master")))
                        .unwrap(),
                };
@@ -32,31 +34,41 @@ pub struct Gui {
     pub status_icon: gtk::StatusIcon,
     pub popup_window: PopupWindow,
     pub popup_menu: PopupMenu,
+    pub prefs_dialog: PrefsDialog,
 }
 
 
 impl Gui {
     pub fn new(builder_popup_window: gtk::Builder,
-               builder_popup_menu: gtk::Builder)
+               builder_popup_menu: gtk::Builder,
+               builder_prefs_dialog: gtk::Builder)
                -> Gui {
         return Gui {
                    status_icon: gtk::StatusIcon::new_from_icon_name("pnmixer"),
                    popup_window: PopupWindow::new(builder_popup_window),
                    popup_menu: PopupMenu::new(builder_popup_menu),
+                   prefs_dialog: PrefsDialog::new(builder_prefs_dialog),
                };
     }
 }
 
 
-create_builder_item!(PopupMenu,
-                     menu_window: gtk::Window,
-                     menubar: gtk::MenuBar,
-                     menu: gtk::Menu,
-                     about_item: gtk::MenuItem);
-
-
 create_builder_item!(PopupWindow,
                      popup_window: gtk::Window,
                      vol_scale_adj: gtk::Adjustment,
                      vol_scale: gtk::Scale,
                      mute_check: gtk::CheckButton);
+
+
+create_builder_item!(PopupMenu,
+                     menu_window: gtk::Window,
+                     menubar: gtk::MenuBar,
+                     menu: gtk::Menu,
+                     about_item: gtk::MenuItem,
+                     prefs_item: gtk::MenuItem);
+
+
+create_builder_item!(PrefsDialog,
+                     prefs_dialog: gtk::Dialog,
+                     card_combo: gtk::ComboBoxText,
+                     chan_combo: gtk::ComboBoxText);

src/audio.rs

@@ -1,6 +1,7 @@
 use errors::*;
 use glib;
 use std::cell::Cell;
+use std::cell::Ref;
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::f64;
@@ -28,11 +29,34 @@ pub enum AudioSignal {
 }
 
 
+#[derive(Clone)]
+pub struct Handlers {
+    inner: Rc<RefCell<Vec<Box<Fn(AudioSignal, AudioUser)>>>>,
+}
+
+
+impl Handlers {
+    fn new() -> Handlers {
+        return Handlers { inner: Rc::new(RefCell::new(vec![])) };
+    }
+
+
+    fn borrow(&self) -> Ref<Vec<Box<Fn(AudioSignal, AudioUser)>>> {
+        return self.inner.borrow();
+    }
+
+
+    fn add_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>) {
+        self.inner.borrow_mut().push(cb);
+    }
+}
+
+
 pub struct Audio {
     _cannot_construct: (),
     pub acard: RefCell<Box<AlsaCard>>,
     pub last_action_timestamp: Rc<RefCell<i64>>,
-    pub handlers: Rc<RefCell<Vec<Box<Fn(AudioSignal, AudioUser)>>>>,
+    pub handlers: Handlers,
     pub scroll_step: Cell<u32>,
 }
 
@@ -42,16 +66,18 @@ impl Audio {
                elem_name: Option<String>)
                -> Result<Audio> {
 
-        let handlers = Rc::new(RefCell::new(vec![]));
+        let handlers = Handlers::new();
         let last_action_timestamp = Rc::new(RefCell::new(0));
 
-        let myhandler = handlers.clone();
-        let ts = last_action_timestamp.clone();
-        let cb = Rc::new(move |event| {
-                             Audio::on_alsa_event(&mut *ts.borrow_mut(),
-                                                  &myhandler.borrow(),
-                                                  event)
-                         });
+        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 audio = Audio {
             _cannot_construct: (),
@@ -70,12 +96,18 @@ impl Audio {
                         elem_name: Option<String>)
                         -> Result<()> {
         debug!("Switching cards");
-        let cb = self.acard.borrow().cb.clone();
-        let mut ac = self.acard.borrow_mut();
-        *ac = AlsaCard::new(card_name,
-                            elem_name,
-                            cb)?;
-
+        debug!("Old card name: {}", self.acard.borrow().card_name().unwrap());
+        debug!("Old chan name: {}", self.acard.borrow().chan_name().unwrap());
+        let cb = self.acard
+            .borrow()
+            .cb
+            .clone();
+        {
+            let mut ac = self.acard.borrow_mut();
+            *ac = AlsaCard::new(card_name, elem_name, cb)?;
+        }
+        debug!("Old card name: {}", self.acard.borrow().card_name().unwrap());
+        debug!("Old chan name: {}", self.acard.borrow().chan_name().unwrap());
         return Ok(());
     }
 
@@ -92,7 +124,11 @@ impl Audio {
         }
         // TODO invoke handlers, make use of user
 
-        debug!("Setting vol to {:?} by user {:?}", new_vol, user);
+        debug!("Setting vol on card {:?} and chan {:?} to {:?} by user {:?}",
+               self.acard.borrow().card_name().unwrap(),
+               self.acard.borrow().chan_name().unwrap(),
+               new_vol,
+               user);
         return self.acard.borrow().set_vol(new_vol);
     }
 
@@ -105,7 +141,11 @@ impl Audio {
         let old_vol = self.vol()?;
         let new_vol = f64::ceil(old_vol + (self.scroll_step.get() as f64));
 
-        debug!("Increase vol by {:?} to {:?}", (new_vol - old_vol), new_vol);
+        debug!("Increase vol on card {:?} and chan {:?} by {:?} to {:?}",
+               self.acard.borrow().card_name().unwrap(),
+               self.acard.borrow().chan_name().unwrap(),
+               (new_vol - old_vol),
+               new_vol);
 
         return self.set_vol(new_vol, user);
     }
@@ -119,7 +159,11 @@ impl Audio {
         let old_vol = self.vol()?;
         let new_vol = old_vol - (self.scroll_step.get() as f64);
 
-        debug!("Decrease vol by {:?} to {:?}", (new_vol - old_vol), new_vol);
+        debug!("Decrease vol on card {:?} and chan {:?} by {:?} to {:?}",
+               self.acard.borrow().card_name().unwrap(),
+               self.acard.borrow().chan_name().unwrap(),
+               (new_vol - old_vol),
+               new_vol);
 
         return self.set_vol(new_vol, user);
     }
@@ -139,57 +183,65 @@ impl Audio {
         let mut rc = self.last_action_timestamp.borrow_mut();
         *rc = glib::get_monotonic_time();
         // TODO invoke handlers, make use of user
-        debug!("Setting mute to {} by user {:?}", mute, user);
+
+        debug!("Setting mute to {} on card {:?} and chan {:?} by user {:?}",
+               mute,
+               self.acard.borrow().card_name().unwrap(),
+               self.acard.borrow().chan_name().unwrap(),
+               user);
+
         return self.acard.borrow().set_mute(mute);
     }
 
 
     pub fn connect_handler(&self, cb: Box<Fn(AudioSignal, AudioUser)>) {
-        self.handlers.borrow_mut().push(cb);
-    }
-
-
-    fn invoke_handlers(handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
-                       signal: AudioSignal,
-                       user: AudioUser) {
-        debug!("Invoking handlers for signal {:?} by user {:?}",
-               signal,
-               user);
-        for handler in handlers {
-            let unboxed = handler.as_ref();
-            unboxed(signal, user);
-        }
-    }
-
-
-    fn on_alsa_event(last_action_timestamp: &mut i64,
-                     handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
-                     alsa_event: AlsaEvent) {
-        let last: i64 = *last_action_timestamp;
-
-        if last != 0 {
-            let now: i64 = glib::get_monotonic_time();
-            let delay: i64 = now - last;
-            if delay < 1000000 {
-                return;
-            }
-            debug!("Discarding last time stamp, too old");
-            *last_action_timestamp = 0;
-        }
-
-        /* external change */
-        match alsa_event {
-            // TODO: invoke handlers with AudioUserUnknown
-            AlsaEvent::AlsaCardError => debug!("AlsaCardError"),
-            AlsaEvent::AlsaCardDiconnected => debug!("AlsaCardDiconnected"),
-            AlsaEvent::AlsaCardValuesChanged => {
-                debug!("AlsaCardValuesChanged");
-                Audio::invoke_handlers(handlers,
-                                       self::AudioSignal::AudioValuesChanged,
-                                       self::AudioUser::AudioUserUnknown);
-            }
-            e => warn!("Unhandled alsa event: {:?}", e),
-        }
-
+        self.handlers.add_handler(cb);
     }
 }
+
+
+fn invoke_handlers(handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
+                   signal: AudioSignal,
+                   user: AudioUser) {
+    debug!("Invoking handlers for signal {:?} by user {:?}",
+           signal,
+           user);
+    for handler in handlers {
+        let unboxed = handler.as_ref();
+        unboxed(signal, user);
+    }
+}
+
+
+fn on_alsa_event(last_action_timestamp: &mut i64,
+                 handlers: &Vec<Box<Fn(AudioSignal, AudioUser)>>,
+                 alsa_event: AlsaEvent) {
+    let last: i64 = *last_action_timestamp;
+
+    debug!("Last: {}", last);
+
+    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 {
+        // TODO: invoke handlers with AudioUserUnknown
+        AlsaEvent::AlsaCardError => debug!("AlsaCardError"),
+        AlsaEvent::AlsaCardDiconnected => debug!("AlsaCardDiconnected"),
+        AlsaEvent::AlsaCardValuesChanged => {
+            debug!("AlsaCardValuesChanged");
+            invoke_handlers(handlers,
+                            self::AudioSignal::AudioValuesChanged,
+                            self::AudioUser::AudioUserUnknown);
+        }
+        e => warn!("Unhandled alsa event: {:?}", e),
+    }
+
+}

src/errors.rs

@@ -36,16 +36,16 @@ macro_rules! try_wr {
         },
     });
     ($expr:expr, $ret:expr, $fmt:expr) => (match $expr {
-        std::result::Result::Ok(val) => val,
-        std::result::Result::Err(err) => {
+        ::std::result::Result::Ok(val) => val,
+        ::std::result::Result::Err(err) => {
             warn!("Original error: {:?}", err);
             warn!($fmt);
             return $ret;
         },
     });
     ($expr:expr, $ret:expr, $fmt:expr, $($arg:tt)+) => (match $expr {
-        std::result::Result::Ok(val) => val,
-        std::result::Result::Err(err) => {
+        ::std::result::Result::Ok(val) => val,
+        ::std::result::Result::Err(err) => {
             warn!("Original error: {:?}", err);
             warn!(format!($fmt, $(arg)+));
             return $ret;
@@ -57,8 +57,8 @@ macro_rules! try_wr {
 #[macro_export]
 macro_rules! try_r {
     ($expr:expr, $ret:expr) => (match $expr {
-        std::result::Result::Ok(val) => val,
-        std::result::Result::Err(err) => {
+        ::std::result::Result::Ok(val) => val,
+        ::std::result::Result::Err(err) => {
             return $ret;
         },
     });
@@ -90,16 +90,16 @@ macro_rules! try_er {
         },
     });
     ($expr:expr, $ret:expr, $fmt:expr) => (match $expr {
-        std::result::Result::Ok(val) => val,
-        std::result::Result::Err(err) => {
+        ::std::result::Result::Ok(val) => val,
+        ::std::result::Result::Err(err) => {
             err!("Original error: {:?}", err);
             err!($fmt);
             return $ret;
         },
     });
     ($expr:expr, $ret:expr, $fmt:expr, $($arg:tt)+) => (match $expr {
-        std::result::Result::Ok(val) => val,
-        std::result::Result::Err(err) => {
+        ::std::result::Result::Ok(val) => val,
+        ::std::result::Result::Err(err) => {
             err!("Original error: {:?}", err);
             err!(format!($fmt, $(arg)+));
             return $ret;

src/ui_entry.rs

@@ -4,6 +4,7 @@ use std::rc::Rc;
 use ui_popup_menu::*;
 use ui_popup_window::*;
 use ui_tray_icon::*;
+use ui_prefs_dialog::*;
 
 
 
@@ -25,4 +26,5 @@ pub fn init(appstate: Rc<AppS>) {
     init_tray_icon(appstate.clone());
     init_popup_window(appstate.clone());
     init_popup_menu(appstate.clone());
+    init_prefs_dialog(appstate.clone());
 }

src/ui_popup_menu.rs

@@ -21,6 +21,18 @@ pub fn init_popup_menu(appstate: Rc<AppS>) {
                                         on_about_item_activate(&apps);
                                     });
     }
+
+    /* about_item.connect_activate_link */
+    {
+        let apps = appstate.clone();
+        let prefs_item = &appstate.clone()
+                              .gui
+                              .popup_menu
+                              .prefs_item;
+        prefs_item.connect_activate(move |_| {
+                                        on_prefs_item_activate(&apps);
+                                    });
+    }
 }
 
 
@@ -60,3 +72,14 @@ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA."));
 
     return about_dialog;
 }
+
+
+fn on_prefs_item_activate(appstate: &AppS) {
+    /* TODO: only create if needed */
+    let prefs_dialog = &appstate.gui.prefs_dialog.prefs_dialog;
+    let popup_menu = &appstate.gui.popup_menu.menu_window;
+
+    prefs_dialog.set_transient_for(popup_menu);
+    prefs_dialog.run();
+    // prefs_dialog.destroy();
+}

src/ui_prefs_dialog.rs

@@ -0,0 +1,119 @@
+use app_state::*;
+use gtk::prelude::*;
+use std::rc::Rc;
+use gtk;
+use alsa_pn;
+
+
+pub fn init_prefs_dialog(appstate: Rc<AppS>) {
+    /* prefs_dialog.connect_show */
+    {
+        let apps = appstate.clone();
+        let prefs_dialog = &appstate.clone()
+                                .gui
+                                .prefs_dialog
+                                .prefs_dialog;
+        prefs_dialog.connect_show(move |_| { on_prefs_dialog_show(&apps); });
+    }
+
+    /* card_combo.connect_changed */
+    {
+        let apps = appstate.clone();
+        let card_combo = &appstate.gui.prefs_dialog.card_combo;
+
+        card_combo.connect_changed(move |_| { on_card_combo_changed(&apps); });
+    }
+    /* card_combo.connect_changed */
+    {
+        let apps = appstate.clone();
+        let chan_combo = &appstate.gui.prefs_dialog.chan_combo;
+
+        chan_combo.connect_changed(move |_| { on_chan_combo_changed(&apps); });
+    }
+}
+
+
+fn on_prefs_dialog_show(appstate: &AppS) {
+    let card_combo = &appstate.gui.prefs_dialog.card_combo;
+    let chan_combo = &appstate.gui.prefs_dialog.chan_combo;
+    let acard = appstate.audio.acard.borrow();
+
+
+    /* set card combo */
+    let cur_card_name = try_w!(acard.card_name(),
+                               "Can't get current card name!");
+    let available_card_names = alsa_pn::get_alsa_card_names();
+
+    /* set_active_id doesn't work, so save the index */
+    let mut c_index: i32 = -1;
+    for i in 0..available_card_names.len() {
+        let name = available_card_names.get(i).unwrap();
+        if *name == cur_card_name {
+            c_index = i as i32;
+        }
+        card_combo.append_text(&name);
+    }
+
+    // TODO, block signal?
+    card_combo.set_active(c_index);
+
+
+
+    /* set chan combo */
+    let cur_chan_name = try_w!(acard.chan_name());
+    let available_chan_names = alsa_pn::get_selem_names(&acard.mixer);
+
+    /* set_active_id doesn't work, so save the index */
+    let mut c_index: i32 = -1;
+    for i in 0..available_chan_names.len() {
+        let name = available_chan_names.get(i).unwrap();
+        if *name == cur_chan_name {
+            c_index = i as i32;
+        }
+        chan_combo.append_text(&name);
+    }
+
+    /* TODO, block signal?`*/
+    chan_combo.set_active(c_index);
+
+}
+
+
+fn on_card_combo_changed(appstate: &AppS) {
+    let card_combo = &appstate.gui.prefs_dialog.card_combo;
+    let chan_combo = &appstate.gui.prefs_dialog.chan_combo;
+    let active_card_item =
+        try_w!(card_combo.get_active_text().ok_or("No active Card item found"));
+    let active_chan_item =
+        chan_combo.get_active_id();
+    let cur_card_name = {
+        let acard = appstate.audio.acard.borrow();
+        try_w!(acard.card_name(),
+                               "Can't get current card name!")
+    };
+
+    if active_card_item != cur_card_name {
+        appstate.audio.switch_acard(Some(cur_card_name), active_chan_item);
+    }
+}
+
+
+fn on_chan_combo_changed(appstate: &AppS) {
+    let card_combo = &appstate.gui.prefs_dialog.card_combo;
+    let chan_combo = &appstate.gui.prefs_dialog.chan_combo;
+    let active_chan_item =
+        try_w!(chan_combo.get_active_text().ok_or("No active Chan item found"));
+    let cur_card_name = {
+        let acard = appstate.audio.acard.borrow();
+        acard.card_name().ok()
+    };
+    let cur_chan_name = {
+        let acard = appstate.audio.acard.borrow();
+        try_w!(acard.chan_name())
+    };
+
+    if active_chan_item != cur_chan_name {
+        appstate.audio.switch_acard(cur_card_name, Some(active_chan_item));
+    }
+}
+