X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fmackie%2Fgui.cc;h=99aeec14d8bf443c53b576a2f29b5b36e1f3c740;hb=ccf505c3a27f08dcfe74e32a66108f6d8eafb038;hp=bcc74ee99c5eb84447bb2d4ee5d918ece3818b77;hpb=9502fa261da714fcddfd7c27983be3541e1da659;p=ardour.git diff --git a/libs/surfaces/mackie/gui.cc b/libs/surfaces/mackie/gui.cc index bcc74ee99c..99aeec14d8 100644 --- a/libs/surfaces/mackie/gui.cc +++ b/libs/surfaces/mackie/gui.cc @@ -25,10 +25,16 @@ #include #include #include +#include +#include + +#include "pbd/strsplit.h" #include "gtkmm2ext/utils.h" #include "gtkmm2ext/actions.h" +#include "ardour/rc_configuration.h" + #include "mackie_control_protocol.h" #include "device_info.h" #include "gui.h" @@ -36,8 +42,9 @@ #include "i18n.h" using namespace std; -using namespace Mackie; using namespace Gtk; +using namespace ArdourSurface; +using namespace Mackie; void* MackieControlProtocol::get_gui () const @@ -45,14 +52,22 @@ MackieControlProtocol::get_gui () const if (!_gui) { const_cast(this)->build_gui (); } - + static_cast(_gui)->show_all(); return _gui; } void MackieControlProtocol::tear_down_gui () { + if (_gui) { + Gtk::Widget *w = static_cast(_gui)->get_parent(); + if (w) { + w->hide(); + delete w; + } + } delete (MackieControlProtocolGUI*) _gui; + _gui = 0; } void @@ -63,39 +78,150 @@ MackieControlProtocol::build_gui () MackieControlProtocolGUI::MackieControlProtocolGUI (MackieControlProtocol& p) : _cp (p) + , touch_sensitivity_adjustment (0, 0, 9, 1, 4) + , touch_sensitivity_scale (touch_sensitivity_adjustment) + , recalibrate_fader_button (_("Recalibrate Faders")) + , ipmidi_base_port_adjustment (_cp.ipmidi_base(), 0, 32767, 1, 1000) + , ipmidi_base_port_spinner (ipmidi_base_port_adjustment) + , discover_button (_("Discover Mackie Devices")) { + Gtk::Label* l; + Gtk::Alignment* align; + set_border_width (12); - Gtk::Table* table = Gtk::manage (new Gtk::Table (2, 2)); - table->set_spacings (4); - - table->attach (*manage (new Gtk::Label (_("Surface type:"))), 0, 1, 0, 1, AttachOptions(FILL|EXPAND), AttachOptions(0)); - table->attach (_surface_combo, 1, 2, 0, 1, AttachOptions(FILL|EXPAND), AttachOptions(0)); + Gtk::Table* table = Gtk::manage (new Gtk::Table (2, 9)); + table->set_row_spacings (4); + table->set_col_spacings (6); + table->set_border_width (12); + l = manage (new Gtk::Label (_("Device Type:"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 0, 1, AttachOptions(FILL|EXPAND), AttachOptions(0)); + table->attach (_surface_combo, 1, 2, 0, 1, AttachOptions(FILL|EXPAND), AttachOptions(0), 0, 20); vector surfaces; for (std::map::iterator i = DeviceInfo::device_info.begin(); i != DeviceInfo::device_info.end(); ++i) { - std::cerr << "Dveice known: " << i->first << endl; surfaces.push_back (i->first); } Gtkmm2ext::set_popdown_strings (_surface_combo, surfaces); _surface_combo.set_active_text (p.device_info().name()); _surface_combo.signal_changed().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::surface_combo_changed)); - append_page (*table, _("Device Selection")); + RadioButtonGroup rb_group = absolute_touch_mode_button.get_group(); + touch_move_mode_button.set_group (rb_group); + + recalibrate_fader_button.signal_clicked().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::recalibrate_faders)); + backlight_button.signal_clicked().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::toggle_backlight)); + + touch_sensitivity_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::touch_sensitive_change)); + touch_sensitivity_scale.set_update_policy (Gtk::UPDATE_DISCONTINUOUS); + + l = manage (new Gtk::Label (_("Button click"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 1, 2, AttachOptions(FILL|EXPAND), AttachOptions (0)); + align = manage (new Alignment); + align->set (0.0, 0.5); + align->add (relay_click_button); + table->attach (*align, 1, 2, 1, 2, AttachOptions(FILL|EXPAND), AttachOptions (0)); + l = manage (new Gtk::Label (_("Backlight"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 2, 3, AttachOptions(FILL|EXPAND), AttachOptions (0)); + align = manage (new Alignment); + align->set (0.0, 0.5); + align->add (backlight_button); + table->attach (*align, 1, 2, 2, 3, AttachOptions(FILL|EXPAND), AttachOptions (0)); + l = manage (new Gtk::Label (_("Send Fader Position Only When Touched"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 3, 4, AttachOptions(FILL|EXPAND), AttachOptions (0)); + align = manage (new Alignment); + align->set (0.0, 0.5); + align->add (absolute_touch_mode_button); + table->attach (*align, 1, 2, 3, 4, AttachOptions(FILL|EXPAND), AttachOptions (0)); + l = manage (new Gtk::Label (_("Send Fader Position When Moved"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 4, 5, AttachOptions(FILL|EXPAND), AttachOptions (0)); + align = manage (new Alignment); + align->set (0.0, 0.5); + align->add (touch_move_mode_button); + table->attach (*align, 1, 2, 4, 5, AttachOptions(FILL|EXPAND), AttachOptions (0)); + l = manage (new Gtk::Label (_("Fader Touch Sense Sensitivity"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 5, 6, AttachOptions(FILL|EXPAND), AttachOptions (0)); + touch_sensitivity_scale.property_digits() = 0; + touch_sensitivity_scale.property_draw_value() = false; + table->attach (touch_sensitivity_scale, 1, 2, 5, 6, AttachOptions(FILL|EXPAND), AttachOptions (0)); + table->attach (recalibrate_fader_button, 1, 2, 6, 7, AttachOptions(FILL|EXPAND), AttachOptions (0)); + + l = manage (new Gtk::Label (_("ipMIDI Port (lowest)"))); + l->set_alignment (1.0, 0.5); + table->attach (*l, 0, 1, 7, 8, AttachOptions(FILL|EXPAND), AttachOptions (0)); + table->attach (ipmidi_base_port_spinner, 1, 2, 7, 8, AttachOptions(FILL|EXPAND), AttachOptions (0)); + + ipmidi_base_port_spinner.set_sensitive (_cp.device_info().uses_ipmidi()); + ipmidi_base_port_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::ipmidi_spinner_changed)); + + table->attach (discover_button, 1, 2, 8, 9, AttachOptions(FILL|EXPAND), AttachOptions (0)); + discover_button.signal_clicked().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::discover_clicked)); + + vector profiles; + + profiles.push_back ("default"); + + for (std::map::iterator i = DeviceProfile::device_profiles.begin(); i != DeviceProfile::device_profiles.end(); ++i) { + profiles.push_back (i->first); + } + Gtkmm2ext::set_popdown_strings (_profile_combo, profiles); + _profile_combo.set_active_text (p.device_profile().name()); + _profile_combo.signal_changed().connect (sigc::mem_fun (*this, &MackieControlProtocolGUI::profile_combo_changed)); + + append_page (*table, _("Device Setup")); table->show_all(); /* function key editor */ - append_page (function_key_scroller, _("Function Keys")); - function_key_scroller.add (function_key_editor); + VBox* fkey_packer = manage (new VBox); + HBox* profile_packer = manage (new HBox); + HBox* observation_packer = manage (new HBox); + + l = manage (new Gtk::Label (_("Profile/Settings:"))); + profile_packer->pack_start (*l, false, false); + profile_packer->pack_start (_profile_combo, true, true); + profile_packer->set_spacing (12); + profile_packer->set_border_width (12); - rebuild_function_key_editor (); - function_key_scroller.show_all(); + l = manage (new Gtk::Label (_("* Button available at the original Mackie MCU PRO or current device if enabled (NOT implemented yet). Device specific name presented."))); + observation_packer->pack_start (*l, false, false); + + fkey_packer->pack_start (*profile_packer, false, false); + fkey_packer->pack_start (function_key_scroller, true, true); + fkey_packer->pack_start (*observation_packer, false, false); + fkey_packer->set_spacing (12); + function_key_scroller.property_shadow_type() = Gtk::SHADOW_NONE; + function_key_scroller.add (function_key_editor); + append_page (*fkey_packer, _("Function Keys")); + + build_available_action_menu (); + build_function_key_editor (); + refresh_function_key_editor (); + fkey_packer->show_all(); +} + +CellRendererCombo* +MackieControlProtocolGUI::make_action_renderer (Glib::RefPtr model, Gtk::TreeModelColumnBase column) +{ + CellRendererCombo* renderer = manage (new CellRendererCombo); + renderer->property_model() = model; + renderer->property_editable() = true; + renderer->property_text_column() = 0; + renderer->property_has_entry() = false; + renderer->signal_edited().connect (sigc::bind (sigc::mem_fun(*this, &MackieControlProtocolGUI::action_changed), column)); + + return renderer; } void -MackieControlProtocolGUI::rebuild_function_key_editor () +MackieControlProtocolGUI::build_available_action_menu () { /* build a model of all available actions (needs to be tree structured * more) @@ -103,86 +229,360 @@ MackieControlProtocolGUI::rebuild_function_key_editor () available_action_model = TreeStore::create (available_action_columns); - vector a_names; - vector a_paths; - vector a_tooltips; - vector a_keys; - vector a_bindings; + vector paths; + vector labels; + vector tooltips; + vector keys; + vector bindings; + typedef std::map NodeMap; + NodeMap nodes; + NodeMap::iterator r; + + ActionManager::get_all_actions (labels, paths, tooltips, keys, bindings); + + vector::iterator k; + vector::iterator p; + vector::iterator t; + vector::iterator l; + + available_action_model->clear (); + + /* Because there are button bindings built in that are not + in the key binding map, there needs to be a way to undo + a profile edit. */ + TreeIter rowp; + TreeModel::Row parent; + rowp = available_action_model->append(); + parent = *(rowp); + parent[available_action_columns.name] = _("Remove Binding"); + + for (l = labels.begin(), k = keys.begin(), p = paths.begin(), t = tooltips.begin(); l != labels.end(); ++k, ++p, ++t, ++l) { + + TreeModel::Row row; + vector parts; + + parts.clear (); + + split (*p, parts, '/'); + + if (parts.empty()) { + continue; + } - ActionManager::get_all_actions (a_names, a_paths, a_tooltips, a_keys, a_bindings); + //kinda kludgy way to avoid displaying menu items as mappable + if ( parts[1] == _("Main_menu") ) + continue; + if ( parts[1] == _("JACK") ) + continue; + if ( parts[1] == _("redirectmenu") ) + continue; + if ( parts[1] == _("Editor_menus") ) + continue; + if ( parts[1] == _("RegionList") ) + continue; + if ( parts[1] == _("ProcessorMenu") ) + continue; - vector::iterator n = a_names.begin(); - vector::iterator p = a_paths.begin(); - TreeModel::Row r; + if ((r = nodes.find (parts[1])) == nodes.end()) { - for (; n != a_names.end(); ++n, ++p) { - r = *(available_action_model->append()); - r[available_action_columns.name] = (*n); - r[available_action_columns.path] = (*p); + /* top level is missing */ + + TreeIter rowp; + TreeModel::Row parent; + rowp = available_action_model->append(); + nodes[parts[1]] = rowp; + parent = *(rowp); + parent[available_action_columns.name] = parts[1]; + + row = *(available_action_model->append (parent.children())); + + } else { + + row = *(available_action_model->append ((*r->second)->children())); + + } + + /* add this action */ + + if (l->empty ()) { + row[available_action_columns.name] = *t; + action_map[*t] = *p; + } else { + row[available_action_columns.name] = *l; + action_map[*l] = *p; + } + + row[available_action_columns.path] = (*p); } +} +void +MackieControlProtocolGUI::build_function_key_editor () +{ function_key_editor.append_column (_("Key"), function_key_columns.name); - CellRendererCombo* action_renderer = manage (new CellRendererCombo); - action_renderer->property_model() = available_action_model; - action_renderer->property_editable() = true; - action_renderer->property_text_column() = 1; - action_renderer->property_has_entry() = false; - TreeViewColumn* col; + CellRendererCombo* renderer; - col = manage (new TreeViewColumn (_("Plain"), *action_renderer)); - col->add_attribute (action_renderer->property_text(), function_key_columns.plain); + renderer = make_action_renderer (available_action_model, function_key_columns.plain); + col = manage (new TreeViewColumn (_("Plain"), *renderer)); + col->add_attribute (renderer->property_text(), function_key_columns.plain); function_key_editor.append_column (*col); - col = manage (new TreeViewColumn (_("Shift"), *action_renderer)); - col->add_attribute (action_renderer->property_text(), function_key_columns.shift); + renderer = make_action_renderer (available_action_model, function_key_columns.shift); + col = manage (new TreeViewColumn (_("Shift"), *renderer)); + col->add_attribute (renderer->property_text(), function_key_columns.shift); function_key_editor.append_column (*col); - col = manage (new TreeViewColumn (_("Control"), *action_renderer)); - col->add_attribute (action_renderer->property_text(), function_key_columns.control); + renderer = make_action_renderer (available_action_model, function_key_columns.control); + col = manage (new TreeViewColumn (_("Control"), *renderer)); + col->add_attribute (renderer->property_text(), function_key_columns.control); function_key_editor.append_column (*col); - col = manage (new TreeViewColumn (_("Option"), *action_renderer)); - col->add_attribute (action_renderer->property_text(), function_key_columns.option); + renderer = make_action_renderer (available_action_model, function_key_columns.option); + col = manage (new TreeViewColumn (_("Option"), *renderer)); + col->add_attribute (renderer->property_text(), function_key_columns.option); function_key_editor.append_column (*col); - col = manage (new TreeViewColumn (_("Cmd/Alt"), *action_renderer)); - col->add_attribute (action_renderer->property_text(), function_key_columns.cmdalt); + renderer = make_action_renderer (available_action_model, function_key_columns.cmdalt); + col = manage (new TreeViewColumn (_("Cmd/Alt"), *renderer)); + col->add_attribute (renderer->property_text(), function_key_columns.cmdalt); function_key_editor.append_column (*col); - col = manage (new TreeViewColumn (_("Shift+Control"), *action_renderer)); - col->add_attribute (action_renderer->property_text(), function_key_columns.shiftcontrol); + renderer = make_action_renderer (available_action_model, function_key_columns.shiftcontrol); + col = manage (new TreeViewColumn (_("Shift+Control"), *renderer)); + col->add_attribute (renderer->property_text(), function_key_columns.shiftcontrol); function_key_editor.append_column (*col); - /* now fill with data */ - function_key_model = ListStore::create (function_key_columns); + function_key_editor.set_model (function_key_model); +} + +void +MackieControlProtocolGUI::refresh_function_key_editor () +{ + function_key_editor.set_model (Glib::RefPtr()); + function_key_model->clear (); + + /* now fill with data */ - r = *(function_key_model->append()); - r[function_key_columns.name] = "F1"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F2"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F3"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F4"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F5"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F6"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F7"; - r = *(function_key_model->append()); - r[function_key_columns.name] = "F8"; + TreeModel::Row row; + DeviceProfile dp (_cp.device_profile()); + DeviceInfo di; + + for (int n = 0; n < Mackie::Button::FinalGlobalButton; ++n) { + + Mackie::Button::ID bid = (Mackie::Button::ID) n; + + row = *(function_key_model->append()); + if (di.global_buttons().find (bid) == di.global_buttons().end()) { + row[function_key_columns.name] = Mackie::Button::id_to_name (bid); + } else { + row[function_key_columns.name] = di.get_global_button_name (bid) + "*"; + } + row[function_key_columns.id] = bid; + + Glib::RefPtr act; + string action; + const string defstring = "\u2022"; + + action = dp.get_button_action (bid, 0); + if (action.empty()) { + row[function_key_columns.plain] = defstring; + } else { + act = ActionManager::get_action (action.c_str()); + if (act) { + row[function_key_columns.plain] = act->get_label(); + } else { + row[function_key_columns.plain] = defstring; + } + } + + action = dp.get_button_action (bid, MackieControlProtocol::MODIFIER_CONTROL); + if (action.empty()) { + row[function_key_columns.control] = defstring; + } else { + act = ActionManager::get_action (action.c_str()); + if (act) { + row[function_key_columns.control] = act->get_label(); + } else { + row[function_key_columns.control] = defstring; + } + } + + action = dp.get_button_action (bid, MackieControlProtocol::MODIFIER_SHIFT); + if (action.empty()) { + row[function_key_columns.shift] = defstring; + } else { + act = ActionManager::get_action (action.c_str()); + if (act) { + row[function_key_columns.shift] = act->get_label(); + } else { + row[function_key_columns.shift] = defstring; + } + } + + action = dp.get_button_action (bid, MackieControlProtocol::MODIFIER_OPTION); + if (action.empty()) { + row[function_key_columns.option] = defstring; + } else { + act = ActionManager::get_action (action.c_str()); + if (act) { + row[function_key_columns.option] = act->get_label(); + } else { + row[function_key_columns.option] = defstring; + } + } + + action = dp.get_button_action (bid, MackieControlProtocol::MODIFIER_CMDALT); + if (action.empty()) { + row[function_key_columns.cmdalt] = defstring; + } else { + act = ActionManager::get_action (action.c_str()); + if (act) { + row[function_key_columns.cmdalt] = act->get_label(); + } else { + row[function_key_columns.cmdalt] = defstring; + } + } + + action = dp.get_button_action (bid, (MackieControlProtocol::MODIFIER_SHIFT|MackieControlProtocol::MODIFIER_CONTROL)); + if (action.empty()) { + row[function_key_columns.shiftcontrol] = defstring; + } else { + act = ActionManager::get_action (action.c_str()); + if (act) { + row[function_key_columns.shiftcontrol] = act->get_label(); + } else { + row[function_key_columns.shiftcontrol] = defstring; + } + } + } function_key_editor.set_model (function_key_model); } +void +MackieControlProtocolGUI::action_changed (const Glib::ustring &sPath, const Glib::ustring &text, TreeModelColumnBase col) +{ + // Remove Binding is not in the action map but still valid + bool remove (false); + if ( text == "Remove Binding") { + remove = true; + } + Gtk::TreePath path(sPath); + Gtk::TreeModel::iterator row = function_key_model->get_iter(path); + + if (row) { + + std::map::iterator i = action_map.find (text); + + if (i == action_map.end()) { + if (!remove) { + return; + } + } + Glib::RefPtr act = ActionManager::get_action (i->second.c_str()); + + if (act || remove) { + /* update visible text, using string supplied by + available action model so that it matches and is found + within the model. + */ + if (remove) { + Glib::ustring dot = "\u2022"; + (*row).set_value (col.index(), dot); + } else { + (*row).set_value (col.index(), text); + } + + /* update the current DeviceProfile, using the full + * path + */ + + int modifier; + + switch (col.index()) { + case 3: + modifier = MackieControlProtocol::MODIFIER_SHIFT; + break; + case 4: + modifier = MackieControlProtocol::MODIFIER_CONTROL; + break; + case 5: + modifier = MackieControlProtocol::MODIFIER_OPTION; + break; + case 6: + modifier = MackieControlProtocol::MODIFIER_CMDALT; + break; + case 7: + modifier = (MackieControlProtocol::MODIFIER_SHIFT|MackieControlProtocol::MODIFIER_CONTROL); + break; + default: + modifier = 0; + } + + if (remove) { + _cp.device_profile().set_button_action ((*row)[function_key_columns.id], modifier, ""); + } else { + _cp.device_profile().set_button_action ((*row)[function_key_columns.id], modifier, i->second); + } + + } else { + std::cerr << "no such action\n"; + } + } +} + void MackieControlProtocolGUI::surface_combo_changed () { + _cp.not_session_load(); _cp.set_device (_surface_combo.get_active_text()); + + /* update ipMIDI field */ + + ipmidi_base_port_spinner.set_sensitive (_cp.device_info().uses_ipmidi()); } +void +MackieControlProtocolGUI::profile_combo_changed () +{ + string profile = _profile_combo.get_active_text(); + + _cp.set_profile (profile); + refresh_function_key_editor (); +} + +void +MackieControlProtocolGUI::ipmidi_spinner_changed () +{ + _cp.set_ipmidi_base ((int16_t) lrintf (ipmidi_base_port_spinner.get_value())); +} + +void +MackieControlProtocolGUI::discover_clicked () +{ + /* this should help to get things started */ + _cp.midi_connectivity_established (); +} + +void +MackieControlProtocolGUI::recalibrate_faders () +{ + _cp.recalibrate_faders (); +} + +void +MackieControlProtocolGUI::toggle_backlight () +{ + _cp.toggle_backlight (); +} + +void +MackieControlProtocolGUI::touch_sensitive_change () +{ + int sensitivity = (int) touch_sensitivity_adjustment.get_value (); + _cp.set_touch_sensitivity (sensitivity); +}