diff options
Diffstat (limited to 'gtk2_ardour/midi_channel_selector.cc')
| -rw-r--r-- | gtk2_ardour/midi_channel_selector.cc | 378 |
1 files changed, 376 insertions, 2 deletions
diff --git a/gtk2_ardour/midi_channel_selector.cc b/gtk2_ardour/midi_channel_selector.cc index 6770f0e60d..aea9d31f03 100644 --- a/gtk2_ardour/midi_channel_selector.cc +++ b/gtk2_ardour/midi_channel_selector.cc @@ -19,12 +19,25 @@ #include <algorithm> #include <sstream> +#include <gtkmm/separator.h> +#include <gtkmm/box.h> +#include <gtkmm/label.h> +#include <gtkmm/togglebutton.h> +#include <gtkmm/radiobutton.h> +#include <gtkmm/table.h> + +#include "pbd/compose.h" + +#include "gtkmm2ext/gtk_ui.h" +#include "gtkmm2ext/gui_thread.h" + +#include "ardour/midi_track.h" #include "midi_channel_selector.h" -#include "gtkmm/separator.h" -#include "i18n.h" #include "rgb_macros.h" +#include "i18n.h" + using namespace std; using namespace Gtk; using namespace ARDOUR; @@ -310,3 +323,364 @@ MidiMultipleChannelSelector::invert_selection(void) mode_changed.emit(_channel_mode, get_selected_channels()); } +/*-----------------------------------------*/ + +MidiChannelSelectorWindow::MidiChannelSelectorWindow (boost::shared_ptr<MidiTrack> mt) + : ArdourWindow (string_compose (_("MIDI Channel Control for %1"), mt->name())) + , track (mt) +{ + build (); + + playback_mask_changed (); + playback_mode_changed (); + capture_mask_changed (); + capture_mode_changed (); + + track->PlaybackChannelMaskChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::playback_mask_changed, this), gui_context()); + track->PlaybackChannelModeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::playback_mode_changed, this), gui_context()); + track->CaptureChannelMaskChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::capture_mask_changed, this), gui_context()); + track->CaptureChannelModeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::capture_mode_changed, this), gui_context()); +} + +MidiChannelSelectorWindow::~MidiChannelSelectorWindow() +{ +} + +void +MidiChannelSelectorWindow::build () +{ + VBox* vpacker; + HBox* capture_mask; + HBox* capture_mask_controls; + HBox* playback_mask; + HBox* playback_mask_controls; + Button* b; + ToggleButton* tb; + Label* l; + + vpacker = manage (new VBox); + vpacker->set_spacing (6); + vpacker->set_border_width (12); + + l = manage (new Label (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("Capture")))); + l->set_use_markup (true); + vpacker->pack_start (*l); + + { + RadioButtonGroup group; + + capture_all_button = manage (new RadioButton (group, "Record all channels")); + vpacker->pack_start (*capture_all_button); + capture_all_button->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::capture_mode_toggled), AllChannels)); + + capture_filter_button = manage (new RadioButton (group, "Record only selected channels")); + vpacker->pack_start (*capture_filter_button); + capture_filter_button->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::capture_mode_toggled), FilterChannels)); + + capture_force_button = manage (new RadioButton (group, "Force all channels to a single fixed channel")); + vpacker->pack_start (*capture_force_button); + capture_force_button->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::capture_mode_toggled), ForceChannel)); + } + + capture_mask = manage (new HBox); + + for (uint32_t n = 0; n < 16; ++n) { + char buf[3]; + snprintf (buf, sizeof (buf), "%d", n+1); + tb = manage (new ToggleButton (buf)); + Gtkmm2ext::UI::instance()->set_tip (*tb, string_compose (_("Click to toggle recording of channel %1"), n+1)); + capture_buttons.push_back (tb); + tb->set_name (X_("MidiChannelSelectorButton")); + capture_mask->pack_start (*tb); + tb->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::capture_channel_clicked), n)); + } + + vpacker->pack_start (*capture_mask); + + capture_mask_controls = manage (new HBox); + capture_mask_controls->set_spacing (6); + + b = manage (new Button (_("All"))); + Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to enable recording all channels")); + capture_mask_controls->pack_start (*b); + b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::fill_capture_mask)); + b = manage (new Button (_("None"))); + Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to disable recording all channels")); + capture_mask_controls->pack_start (*b); + b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::zero_capture_mask)); + b = manage (new Button (_("Invert"))); + Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to invert currently selected recording channels")); + capture_mask_controls->pack_start (*b); + b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::invert_capture_mask)); + + vpacker->pack_start (*capture_mask_controls); + + playback_mask = manage (new HBox); + + l = manage (new Label (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("Playback")))); + l->set_use_markup (true); + vpacker->pack_start (*l); + + { + RadioButtonGroup group; + + playback_all_button = manage (new RadioButton (group, "Playback all channels")); + vpacker->pack_start (*playback_all_button); + playback_all_button->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::playback_mode_toggled), AllChannels)); + + playback_filter_button = manage (new RadioButton (group, "Play only selected channels")); + vpacker->pack_start (*playback_filter_button); + playback_filter_button->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::playback_mode_toggled), FilterChannels)); + + playback_force_button = manage (new RadioButton (group, "Use a single fixed channel for all playback")); + vpacker->pack_start (*playback_force_button); + playback_force_button->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::playback_mode_toggled), ForceChannel)); + } + + for (uint32_t n = 0; n < 16; ++n) { + char buf[3]; + snprintf (buf, sizeof (buf), "%d", n+1); + tb = manage (new ToggleButton (buf)); + tb->set_name (X_("MidiChannelSelectorButton")); + playback_buttons.push_back (tb); + playback_mask->pack_start (*tb); + tb->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &MidiChannelSelectorWindow::playback_channel_clicked), n)); + } + + vpacker->pack_start (*playback_mask); + + playback_mask_controls = manage (new HBox); + playback_mask_controls->set_spacing (6); + + b = manage (new Button (_("All"))); + Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to enable playback of all channels")); + playback_mask_controls->pack_start (*b); + b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::fill_playback_mask)); + b = manage (new Button (_("None"))); + Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to disable playback of all channels")); + playback_mask_controls->pack_start (*b); + b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::zero_playback_mask)); + b = manage (new Button (_("Invert"))); + Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to invert current selected playback channels")); + playback_mask_controls->pack_start (*b); + b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::invert_playback_mask)); + + vpacker->pack_start (*playback_mask_controls); + + add (*vpacker); +} + +void +MidiChannelSelectorWindow::fill_playback_mask () +{ + track->set_playback_channel_mask (0xffff); +} + +void +MidiChannelSelectorWindow::zero_playback_mask () +{ + track->set_playback_channel_mask (0); +} + +void +MidiChannelSelectorWindow::invert_playback_mask () +{ + track->set_playback_channel_mask (~track->get_playback_channel_mask()); +} + +void +MidiChannelSelectorWindow::fill_capture_mask () +{ + track->set_capture_channel_mask (0xffff); +} + +void +MidiChannelSelectorWindow::zero_capture_mask () +{ + track->set_capture_channel_mask (0); +} + +void +MidiChannelSelectorWindow::invert_capture_mask () +{ + track->set_capture_channel_mask (~track->get_capture_channel_mask()); +} + +void +MidiChannelSelectorWindow::set_playback_selected_channels (uint16_t mask) +{ + for (uint16_t i = 0; i < 16; i++) { + playback_buttons[i]->set_active ((1<<i) & mask); + } +} + +void +MidiChannelSelectorWindow::set_capture_selected_channels (uint16_t mask) +{ + for (uint16_t i = 0; i < 16; i++) { + capture_buttons[i]->set_active ((1<<i) & mask); + } +} + +void +MidiChannelSelectorWindow::playback_mask_changed () +{ + set_playback_selected_channels (track->get_playback_channel_mask()); +} + +void +MidiChannelSelectorWindow::capture_mask_changed () +{ + set_capture_selected_channels (track->get_capture_channel_mask()); +} + +void +MidiChannelSelectorWindow::playback_mode_changed () +{ + switch (track->get_playback_channel_mode()) { + case AllChannels: + playback_all_button->set_active (); + break; + case FilterChannels: + playback_filter_button->set_active (); + break; + case ForceChannel: + playback_force_button->set_active (); + break; + } +} + +void +MidiChannelSelectorWindow::capture_mode_changed () +{ + switch (track->get_capture_channel_mode()) { + case AllChannels: + capture_all_button->set_active (); + break; + case FilterChannels: + capture_filter_button->set_active (); + break; + case ForceChannel: + capture_force_button->set_active (); + break; + } +} + +void +MidiChannelSelectorWindow::playback_channel_clicked (uint16_t n) +{ + if (playback_buttons[n]->get_active()) { + track->set_playback_channel_mask (track->get_playback_channel_mask() | (1<<n)); + } else { + track->set_playback_channel_mask (track->get_playback_channel_mask() & ~(1<<n)); + } +} + +void +MidiChannelSelectorWindow::capture_channel_clicked (uint16_t n) +{ + if (capture_buttons[n]->get_active()) { + track->set_capture_channel_mask (track->get_capture_channel_mask() | (1<<n)); + } else { + track->set_capture_channel_mask (track->get_capture_channel_mask() & ~(1<<n)); + } +} + +void +MidiChannelSelectorWindow::capture_mode_toggled (ChannelMode mode) +{ + /* this is called twice for every radio button change. the first time + is for the button/mode that has been turned off, and the second is for the + button/mode that has been turned on. + + so we have to check the button state to know what to do. + */ + + switch (mode) { + case AllChannels: + if (!capture_all_button->get_active()) { + return; + } + track->set_capture_channel_mode (AllChannels, track->get_capture_channel_mask()); + break; + case FilterChannels: + if (!capture_filter_button->get_active()) { + return; + } + track->set_capture_channel_mode (FilterChannels, track->get_capture_channel_mask()); + break; + case ForceChannel: + if (!capture_force_button->get_active()) { + return; + } + track->set_capture_channel_mode (ForceChannel, track->get_capture_channel_mask()); + break; + } +} + +void +MidiChannelSelectorWindow::playback_mode_toggled (ChannelMode mode) +{ + /* this is called twice for every radio button change. the first time + is for the button/mode that has been turned off, and the second is for the + button/mode that has been turned on. + + so we have to check the button state to know what to do. + */ + + switch (mode) { + case AllChannels: + if (!playback_all_button->get_active()) { + return; + } + track->set_playback_channel_mode (AllChannels, track->get_playback_channel_mask()); + break; + case FilterChannels: + if (!playback_filter_button->get_active()) { + return; + } + track->set_playback_channel_mode (FilterChannels, track->get_playback_channel_mask()); + break; + case ForceChannel: + if (!playback_force_button->get_active()) { + return; + } + track->set_playback_channel_mode (ForceChannel, track->get_playback_channel_mask()); + break; + } +} + +void +MidiChannelSelectorWindow::set_channel_colors (const uint32_t new_channel_colors[16]) +{ + for (uint32_t n = 0; n < 16; ++n) { + + char color_normal[8]; + char color_active[8]; + + snprintf(color_normal, 8, "#%x", UINT_INTERPOLATE(new_channel_colors[n], 0x000000ff, 0.6)); + snprintf(color_active, 8, "#%x", new_channel_colors[n]); + + playback_buttons[n]->modify_bg(STATE_NORMAL, Gdk::Color(color_normal)); + playback_buttons[n]->modify_bg(STATE_ACTIVE, Gdk::Color(color_active)); + + capture_buttons[n]->modify_bg(STATE_NORMAL, Gdk::Color(color_normal)); + capture_buttons[n]->modify_bg(STATE_ACTIVE, Gdk::Color(color_active)); + } +} + +void +MidiChannelSelectorWindow::set_default_channel_color() +{ + for (uint32_t n = 0; n < 16; ++n) { + playback_buttons[n]->unset_fg (STATE_NORMAL); + playback_buttons[n]->unset_bg (STATE_NORMAL); + playback_buttons[n]->unset_fg (STATE_ACTIVE); + playback_buttons[n]->unset_bg (STATE_ACTIVE); + + capture_buttons[n]->unset_fg (STATE_NORMAL); + capture_buttons[n]->unset_bg (STATE_NORMAL); + capture_buttons[n]->unset_fg (STATE_ACTIVE); + capture_buttons[n]->unset_bg (STATE_ACTIVE); + } +} |