ignore_speed_adjustment = false;
comment_window = 0;
- width_button.add (*(manage (new Gtk::Image (lr_xpm))));
- hide_button.add (*(manage (new Gtk::Image (small_x_xpm))));
+ width_button.add (*(manage (new Gtk::Image (Gdk::Pixbuf::create_from_xpm_data(lr_xpm)))));
+ hide_button.add (*(manage (new Gtk::Image (Gdk::Pixbuf::create_from_xpm_data(small_x_xpm)))));
input_label.set_text (_("INPUT"));
ARDOUR_UI::instance()->tooltips().set_tip (pan_automation_style_button, _("Pan automation type"));
ARDOUR_UI::instance()->tooltips().set_tip (gain_automation_style_button, _("Gain automation type"));
- hide_button.set_events (hide_button.get_events() & ~(GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK));
+ hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
width_button.unset_flags (Gtk::CAN_FOCUS);
hide_button.unset_flags (Gtk::CAN_FOCUS);
using namespace Menu_Helpers;
gain_astate_menu.items().push_back (MenuElem (_("off"),
- bind (slot (_route, &IO::set_gain_automation_state), (AutoState) Off)));
+ bind (mem_fun (_route, &IO::set_gain_automation_state), (AutoState) Off)));
gain_astate_menu.items().push_back (MenuElem (_("play"),
- bind (slot (_route, &IO::set_gain_automation_state), (AutoState) Play)));
+ bind (mem_fun (_route, &IO::set_gain_automation_state), (AutoState) Play)));
gain_astate_menu.items().push_back (MenuElem (_("write"),
- bind (slot (_route, &IO::set_gain_automation_state), (AutoState) Write)));
+ bind (mem_fun (_route, &IO::set_gain_automation_state), (AutoState) Write)));
gain_astate_menu.items().push_back (MenuElem (_("touch"),
- bind (slot (_route, &IO::set_gain_automation_state), (AutoState) Touch)));
+ bind (mem_fun (_route, &IO::set_gain_automation_state), (AutoState) Touch)));
gain_astyle_menu.items().push_back (MenuElem (_("trim")));
gain_astyle_menu.items().push_back (MenuElem (_("abs")));
pan_astate_menu.items().push_back (MenuElem (_("off"),
- bind (slot (_route.panner(), &Panner::set_automation_state), (AutoState) Off)));
+ bind (mem_fun (_route.panner(), &Panner::set_automation_state), (AutoState) Off)));
pan_astate_menu.items().push_back (MenuElem (_("play"),
- bind (slot (_route.panner(), &Panner::set_automation_state), (AutoState) Play)));
+ bind (mem_fun (_route.panner(), &Panner::set_automation_state), (AutoState) Play)));
pan_astate_menu.items().push_back (MenuElem (_("write"),
- bind (slot (_route.panner(), &Panner::set_automation_state), (AutoState) Write)));
+ bind (mem_fun (_route.panner(), &Panner::set_automation_state), (AutoState) Write)));
pan_astate_menu.items().push_back (MenuElem (_("touch"),
- bind (slot (_route.panner(), &Panner::set_automation_state), (AutoState) Touch)));
+ bind (mem_fun (_route.panner(), &Panner::set_automation_state), (AutoState) Touch)));
pan_astyle_menu.items().push_back (MenuElem (_("trim")));
pan_astyle_menu.items().push_back (MenuElem (_("abs")));
AudioTrack* at = dynamic_cast<AudioTrack*>(&_route);
- at->FreezeChange.connect (slot (*this, &MixerStrip::map_frozen));
+ at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen));
- speed_adjustment.value_changed.connect (slot (*this, &MixerStrip::speed_adjustment_changed));
+ speed_adjustment.signal_value_changed().connect (mem_fun(*this, &MixerStrip::speed_adjustment_changed));
speed_frame.set_name ("BaseFrame");
speed_frame.set_shadow_type (Gtk::SHADOW_IN);
ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route.comment()=="" ?
_("click to add/edit comments"):
_route.comment());
- comment_button.signal_clicked().connect (slot (*this, &MixerStrip::comment_button_clicked));
+ comment_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::comment_button_clicked));
global_vpacker.set_border_width (4);
global_vpacker.set_spacing (4);
width_button.set_name ("MixerWidthButton");
hide_button.set_name ("MixerHideButton");
- width_button.signal_clicked().connect (slot (*this, &MixerStrip::width_clicked));
- hide_button.signal_clicked().connect (slot (*this, &MixerStrip::hide_clicked));
+ width_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::width_clicked));
+ hide_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::hide_clicked));
width_hide_box.pack_start (width_button, false, true);
width_hide_box.pack_end (hide_button, false, true);
_packed = false;
_embedded = false;
- _route.input_changed.connect (slot (*this, &MixerStrip::input_changed));
- _route.output_changed.connect (slot (*this, &MixerStrip::output_changed));
- _route.mute_changed.connect (slot (*this, &RouteUI::mute_changed));
- _route.solo_changed.connect (slot (*this, &RouteUI::solo_changed));
- _route.solo_safe_changed.connect (slot (*this, &RouteUI::solo_changed));
- _route.mix_group_changed.connect (slot (*this, &MixerStrip::mix_group_changed));
- _route.gain_automation_curve().automation_state_changed.connect (slot (*this, &MixerStrip::gain_automation_state_changed));
- _route.gain_automation_curve().automation_style_changed.connect (slot (*this, &MixerStrip::gain_automation_style_changed));
- _route.panner().Changed.connect (slot (*this, &MixerStrip::connect_to_pan));
+ _route.input_changed.connect (mem_fun(*this, &MixerStrip::input_changed));
+ _route.output_changed.connect (mem_fun(*this, &MixerStrip::output_changed));
+ _route.mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed));
+ _route.solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
+ _route.solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
+ _route.mix_group_changed.connect (mem_fun(*this, &MixerStrip::mix_group_changed));
+ _route.gain_automation_curve().automation_state_changed.connect (mem_fun(*this, &MixerStrip::gain_automation_state_changed));
+ _route.gain_automation_curve().automation_style_changed.connect (mem_fun(*this, &MixerStrip::gain_automation_style_changed));
+ _route.panner().Changed.connect (mem_fun(*this, &MixerStrip::connect_to_pan));
if (is_audio_track()) {
- audio_track()->diskstream_changed.connect (slot (*this, &MixerStrip::diskstream_changed));
- get_diskstream()->speed_changed.connect (slot (*this, &MixerStrip::speed_changed));
+ audio_track()->diskstream_changed.connect (mem_fun(*this, &MixerStrip::diskstream_changed));
+ get_diskstream()->speed_changed.connect (mem_fun(*this, &MixerStrip::speed_changed));
}
- _route.name_changed.connect (slot (*this, &RouteUI::name_changed));
- _route.comment_changed.connect (slot (*this, &MixerStrip::comment_changed));
- _route.gui_changed.connect (slot (*this, &MixerStrip::route_gui_changed));
+ _route.name_changed.connect (mem_fun(*this, &RouteUI::name_changed));
+ _route.comment_changed.connect (mem_fun(*this, &MixerStrip::comment_changed));
+ _route.gui_changed.connect (mem_fun(*this, &MixerStrip::route_gui_changed));
- input_button.button_release_event.connect (slot (*this, &MixerStrip::input_press));
- output_button.button_release_event.connect (slot (*this, &MixerStrip::output_press));
+ input_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::input_press));
+ output_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::output_press));
- rec_enable_button->button_press_event.connect (slot (*this, &RouteUI::rec_enable_press));
- solo_button->button_press_event.connect (slot (*this, &RouteUI::solo_press));
- solo_button->button_release_event.connect (slot (*this, &RouteUI::solo_release));
- mute_button->button_press_event.connect (slot (*this, &RouteUI::mute_press));
- mute_button->button_release_event.connect (slot (*this, &RouteUI::mute_release));
+ rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press));
+ solo_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::solo_press));
+ solo_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::solo_release));
+ mute_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::mute_press));
+ mute_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::mute_release));
- gain_automation_style_button.button_press_event.connect_after (slot (do_not_propagate));
- pan_automation_style_button.button_press_event.connect_after (slot (do_not_propagate));
- gain_automation_state_button.button_press_event.connect_after (slot (do_not_propagate));
- pan_automation_state_button.button_press_event.connect_after (slot (do_not_propagate));
+ gain_automation_style_button.signal_button_press_event().connect_after (ptr_fun (do_not_propagate));
+ pan_automation_style_button.signal_button_press_event().connect_after (ptr_fun (do_not_propagate));
+ gain_automation_state_button.signal_button_press_event().connect_after (ptr_fun (do_not_propagate));
+ pan_automation_state_button.signal_button_press_event().connect_after (ptr_fun (do_not_propagate));
- gain_automation_style_button.button_press_event.connect (slot (*this, &MixerStrip::gain_automation_style_button_event));
- gain_automation_style_button.button_release_event.connect (slot (*this, &MixerStrip::gain_automation_style_button_event));
- pan_automation_style_button.button_press_event.connect (slot (*this, &MixerStrip::pan_automation_style_button_event));
- pan_automation_style_button.button_release_event.connect (slot (*this, &MixerStrip::pan_automation_style_button_event));
+ gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::gain_automation_style_button_event));
+ gain_automation_style_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::gain_automation_style_button_event));
+ pan_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::pan_automation_style_button_event));
+ pan_automation_style_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::pan_automation_style_button_event));
- gain_automation_state_button.button_press_event.connect (slot (*this, &MixerStrip::gain_automation_state_button_event));
- gain_automation_state_button.button_release_event.connect (slot (*this, &MixerStrip::gain_automation_state_button_event));
- pan_automation_state_button.button_press_event.connect (slot (*this, &MixerStrip::pan_automation_state_button_event));
- pan_automation_state_button.button_release_event.connect (slot (*this, &MixerStrip::pan_automation_state_button_event));
+ gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::gain_automation_state_button_event));
+ gain_automation_state_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::gain_automation_state_button_event));
+ pan_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::pan_automation_state_button_event));
+ pan_automation_state_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::pan_automation_state_button_event));
- polarity_button.toggled.connect (slot (*this, &MixerStrip::polarity_toggled));
+ polarity_button.signal_toggled().connect (mem_fun(*this, &MixerStrip::polarity_toggled));
- name_button.button_release_event.connect (slot (*this, &MixerStrip::name_button_button_release));
+ name_button.signal_button_release_event().connect (mem_fun(*this, &MixerStrip::name_button_button_release));
- group_button.button_press_event.connect (slot (*this, &MixerStrip::select_mix_group));
+ group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_mix_group));
_width = (Width) -1;
set_stuff_from_route ();
set_width (Narrow);
}
else {
- error << compose(_("unknown strip width \"%1\" in XML GUI information"), prop->value()) << endmsg;
+ error << string_compose(_("unknown strip width \"%1\" in XML GUI information"), prop->value()) << endmsg;
set_width (Wide);
}
}
output_menu.set_name ("ArdourContextMenu");
citems.clear();
- citems.push_back (MenuElem (_("Edit"), slot (*this, &MixerStrip::edit_output_configuration)));
+ citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_output_configuration)));
citems.push_back (SeparatorElem());
- citems.push_back (MenuElem (_("Disconnect"), slot (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_output)));
+ citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_output)));
citems.push_back (SeparatorElem());
_session.foreach_connection (this, &MixerStrip::add_connection_to_output_menu);
}
if (output_selector->is_visible()) {
- output_selector->get_toplevel()->get_window().raise();
+ output_selector->get_toplevel()->get_window()->raise();
} else {
output_selector->show_all ();
}
}
if (input_selector->is_visible()) {
- input_selector->get_toplevel()->get_window().raise();
+ input_selector->get_toplevel()->get_window()->raise();
} else {
input_selector->show_all ();
}
#if ADVANCED_ROUTE_DISKSTREAM_CONNECTIVITY
if (is_audio_track()) {
- citems.push_back (MenuElem (_("Track"), slot (*this, &MixerStrip::select_stream_input)));
+ citems.push_back (MenuElem (_("Track"), mem_fun(*this, &MixerStrip::select_stream_input)));
}
#endif
- citems.push_back (MenuElem (_("Edit"), slot (*this, &MixerStrip::edit_input_configuration)));
+ citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_input_configuration)));
citems.push_back (SeparatorElem());
- citems.push_back (MenuElem (_("Disconnect"), slot (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
+ citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
citems.push_back (SeparatorElem());
_session.foreach_connection (this, &MixerStrip::add_connection_to_input_menu);
if (c->nports() == _route.n_inputs()) {
- citems.push_back (CheckMenuElem (c->name(), bind (slot (*this, &MixerStrip::connection_input_chosen), c)));
+ citems.push_back (CheckMenuElem (c->name(), bind (mem_fun(*this, &MixerStrip::connection_input_chosen), c)));
ARDOUR::Connection *current = _route.input_connection();
if (current == c) {
ignore_toggle = true;
- dynamic_cast<CheckMenuItem *> (citems.back())->set_active (true);
+ dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
ignore_toggle = false;
}
}
if (c->nports() == _route.n_outputs()) {
MenuList& citems = output_menu.items();
- citems.push_back (CheckMenuElem (c->name(), bind (slot (*this, &MixerStrip::connection_output_chosen), c)));
+ citems.push_back (CheckMenuElem (c->name(), bind (mem_fun(*this, &MixerStrip::connection_output_chosen), c)));
ARDOUR::Connection *current = _route.output_connection();
if (current == c) {
ignore_toggle = true;
- dynamic_cast<CheckMenuItem *> (citems.back())->set_active (true);
+ dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
ignore_toggle = false;
}
}
if (!(*i)->hidden()) {
- items.push_back (CheckMenuElem ((*i)->name(), bind (slot (*this, &MixerStrip::stream_input_chosen), *i)));
+ items.push_back (CheckMenuElem ((*i)->name(), bind (mem_fun(*this, &MixerStrip::stream_input_chosen), *i)));
if (get_diskstream() == *i) {
ignore_toggle = true;
- static_cast<CheckMenuItem *> (items.back())->set_active (true);
+ static_cast<CheckMenuItem *> (&items.back())->set_active (true);
ignore_toggle = false;
}
}
void
MixerStrip::connect_to_pan ()
{
- ENSURE_GUI_THREAD(slot (*this, &MixerStrip::connect_to_pan));
+ ENSURE_GUI_THREAD(mem_fun(*this, &MixerStrip::connect_to_pan));
panstate_connection.disconnect ();
panstyle_connection.disconnect ();
if (!_route.panner().empty()) {
StreamPanner* sp = _route.panner().front();
- panstate_connection = sp->automation().automation_state_changed.connect (slot (*this, &MixerStrip::pan_automation_state_changed));
- panstyle_connection = sp->automation().automation_style_changed.connect (slot (*this, &MixerStrip::pan_automation_style_changed));
+ panstate_connection = sp->automation().automation_state_changed.connect (mem_fun(*this, &MixerStrip::pan_automation_state_changed));
+ panstyle_connection = sp->automation().automation_style_changed.connect (mem_fun(*this, &MixerStrip::pan_automation_style_changed));
}
panners.pan_changed (this);
void
MixerStrip::diskstream_changed (void *src)
{
- Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_diskstream_display));
+ Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_diskstream_display));
}
void
void
MixerStrip::gain_automation_state_changed ()
{
- ENSURE_GUI_THREAD(slot (*this, &MixerStrip::gain_automation_state_changed));
+ ENSURE_GUI_THREAD(mem_fun(*this, &MixerStrip::gain_automation_state_changed));
bool x;
gain_watching.disconnect();
if (x) {
- gain_watching = ARDOUR_UI::RapidScreenUpdate.connect (slot (gpm, &GainMeter::effective_gain_display));
+ gain_watching = ARDOUR_UI::RapidScreenUpdate.connect (mem_fun (gpm, &GainMeter::effective_gain_display));
}
}
void
MixerStrip::pan_automation_style_changed ()
{
- ENSURE_GUI_THREAD(slot (*this, &MixerStrip::pan_automation_style_changed));
+ ENSURE_GUI_THREAD(mem_fun(*this, &MixerStrip::pan_automation_style_changed));
switch (_width) {
case Wide:
void
MixerStrip::pan_automation_state_changed ()
{
- ENSURE_GUI_THREAD(slot (*this, &MixerStrip::pan_automation_state_changed));
+ ENSURE_GUI_THREAD(mem_fun(*this, &MixerStrip::pan_automation_state_changed));
bool x;
pan_watching.disconnect();
if (x) {
- pan_watching = ARDOUR_UI::RapidScreenUpdate.connect (slot (panners, &PannerUI::effective_pan_display));
+ pan_watching = ARDOUR_UI::RapidScreenUpdate.connect (mem_fun (panners, &PannerUI::effective_pan_display));
}
}
void
MixerStrip::input_changed (IOChange change, void *src)
{
- Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_input_display));
+ Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_input_display));
}
void
MixerStrip::output_changed (IOChange change, void *src)
{
- Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_output_display));
+ Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_output_display));
}
void
void
MixerStrip::setup_comment_editor ()
{
- comment_window = new Window (GTK_WINDOW_TOPLEVEL);
+ comment_window = new Window (WINDOW_TOPLEVEL);
string str;
str = _route.name();
comment_area.set_name ("MixerTrackCommentArea");
comment_area.set_editable (true);
- comment_area.signal_focus_in_event().connect (slot (ARDOUR_UI::generic_focus_in_event));
- comment_area.signal_focus_out_event().connect (slot (ARDOUR_UI::generic_focus_out_event));
- comment_area.changed.connect (slot (*this, &MixerStrip::comment_edited));
- comment_area.button_release_event.connect_after (slot (do_not_propagate));
+ comment_area.signal_focus_in_event().connect (ptr_fun (ARDOUR_UI::generic_focus_in_event));
+ comment_area.signal_focus_out_event().connect (ptr_fun (ARDOUR_UI::generic_focus_out_event));
+ comment_area.changed.connect (mem_fun(*this, &MixerStrip::comment_edited));
+ comment_area.signal_button_release_event().connect_after (ptr_fun (do_not_propagate));
comment_area.show ();
comment_window->add (comment_area);
- comment_window->delete_event.connect (bind (slot (just_hide_it), comment_window));
+ comment_window->signal_delete_event().connect (bind (ptr_fun (just_hide_it), comment_window));
}
void
MixerStrip::comment_changed (void *src)
{
- ENSURE_GUI_THREAD(bind (slot (*this, &MixerStrip::comment_changed), src));
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::comment_changed), src));
if (src != this) {
ignore_comment_edit = true;
comment_area.freeze ();
- comment_area.delete_text (0, -1);
- comment_area.set_point (0);
- comment_area.insert (_route.comment());
+ //comment_area.get_buffer()->delete_text (0, -1);
+ //comment_area.set_point (0);
+ comment_area.get_buffer()->set_text (_route.comment());
comment_area.thaw ();
ignore_comment_edit = false;
}
void
MixerStrip::comment_edited ()
{
- ENSURE_GUI_THREAD(slot (*this, &MixerStrip::comment_edited));
+ ENSURE_GUI_THREAD(mem_fun(*this, &MixerStrip::comment_edited));
if (!ignore_comment_edit) {
- string str = comment_area.get_chars(0,-1);
+ string str = comment_area.get_buffer()->get_text();
_route.set_comment (str, this);
ARDOUR_UI::instance()->tooltips().set_tip (comment_button,
str.empty() ? _("click to add/edit comments") : str);
using namespace Menu_Helpers;
MenuList& items = group_menu->items();
- items.push_back (MenuElem (rg->name(), bind (slot (*this, &MixerStrip::set_mix_group), rg)));
+ items.push_back (MenuElem (rg->name(), bind (mem_fun(*this, &MixerStrip::set_mix_group), rg)));
}
gint
group_menu->set_name ("ArdourContextMenu");
MenuList& items = group_menu->items();
- items.push_back (MenuElem (_("no group"), bind (slot (*this, &MixerStrip::set_mix_group), (RouteGroup *) 0)));
+ items.push_back (MenuElem (_("no group"), bind (mem_fun(*this, &MixerStrip::set_mix_group), (RouteGroup *) 0)));
_session.foreach_mix_group (this, &MixerStrip::add_mix_group_to_menu);
group_menu->popup (ev->button, 0);
void
MixerStrip::mix_group_changed (void *ignored)
{
- ENSURE_GUI_THREAD(bind (slot (*this, &MixerStrip::mix_group_changed), ignored));
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::mix_group_changed), ignored));
RouteGroup *rg = _route.mix_group();
void
MixerStrip::route_gui_changed (string what_changed, void* ignored)
{
- ENSURE_GUI_THREAD(bind (slot (*this, &MixerStrip::route_gui_changed), what_changed, ignored));
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::route_gui_changed), what_changed, ignored));
if (what_changed == "color") {
if (set_color_from_route () == 0) {
void
MixerStrip::show_route_color ()
{
- Gtk::Style *style;
+ Glib::RefPtr<Gtk::Style> style;
name_button.ensure_style ();
style = name_button.get_style()->copy();
style->set_bg (Gtk::STATE_NORMAL, color());
- name_button.set_style (*style);
- style->unref();
+ name_button.set_style (style);
+ style->unrefernce();
route_active_changed ();
}
MenuList& items = route_ops_menu->items();
- items.push_back (MenuElem (_("Rename"), slot (*this, &RouteUI::route_rename)));
+ items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteUI::route_rename)));
items.push_back (SeparatorElem());
- items.push_back (CheckMenuElem (_("Active"), slot (*this, &RouteUI::toggle_route_active)));
- route_active_menu_item = dynamic_cast<CheckMenuItem *> (items.back());
+ items.push_back (CheckMenuElem (_("Active"), mem_fun(*this, &RouteUI::toggle_route_active)));
+ route_active_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
route_active_menu_item->set_active (_route.active());
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Remove"), slot (*this, &RouteUI::remove_this_route)));
+ items.push_back (MenuElem (_("Remove"), mem_fun(*this, &RouteUI::remove_this_route)));
}
gint
void
MixerStrip::speed_changed ()
{
- Gtkmm2ext::UI::instance()->call_slot (slot (*this, &MixerStrip::update_speed_display));
+ Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_speed_display));
}
void
{
AxisView::set_selected (yn);
if (_selected) {
- global_frame.set_shadow_type (GTK_SHADOW_ETCHED_OUT);
+ global_frame.set_shadow_type (Gtk::SHADOW_ETCHED_OUT);
global_frame.set_name ("MixerStripSelectedFrame");
} else {
global_frame.set_shadow_type (Gtk::SHADOW_IN);
void
MixerStrip::map_frozen ()
{
- ENSURE_GUI_THREAD (slot (*this, &MixerStrip::map_frozen));
+ ENSURE_GUI_THREAD (mem_fun(*this, &MixerStrip::map_frozen));
AudioTrack* at = dynamic_cast<AudioTrack*>(&_route);
projects / ardour.git / blobdiff