X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fplugin_ui.cc;h=b6326392e2ff1760996528ce580904c183baa582;hb=ccf58b8de23619db9983a45f696fd97e13a15cce;hp=7d1047beb27b783d362182c3cf52d1d8d9ee5762;hpb=c71fc0272da4196f4bc14060f2c6bddcce76f823;p=ardour.git diff --git a/gtk2_ardour/plugin_ui.cc b/gtk2_ardour/plugin_ui.cc index 7d1047beb2..b6326392e2 100644 --- a/gtk2_ardour/plugin_ui.cc +++ b/gtk2_ardour/plugin_ui.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000 Paul Davis + Copyright (C) 2000 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,918 +15,583 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ +#ifdef WAF_BUILD +#include "gtk2ardour-config.h" +#endif + #include #include #include #include -#include -#include -#include +#include "pbd/stl_delete.h" +#include "pbd/xml++.h" +#include "pbd/failed_constructor.h" +#include +#include #include #include -#include #include #include #include +#include -#include +#include "midi++/manager.h" -#include -#include -#include -#include +#include "ardour/session.h" +#include "ardour/plugin.h" +#include "ardour/plugin_insert.h" +#include "ardour/ladspa_plugin.h" #ifdef VST_SUPPORT -#include +#include "ardour/vst_plugin.h" +#endif +#ifdef HAVE_SLV2 +#include "ardour/lv2_plugin.h" +#include "lv2_plugin_ui.h" #endif #include +#include "ardour_dialog.h" #include "ardour_ui.h" #include "prompter.h" #include "plugin_ui.h" #include "utils.h" #include "gui_thread.h" +#include "public_editor.h" +#include "keyboard.h" +#include "latency_gui.h" +#include "plugin_eq_gui.h" #include "i18n.h" using namespace std; using namespace ARDOUR; +using namespace PBD; using namespace Gtkmm2ext; using namespace Gtk; using namespace sigc; -PluginUIWindow::PluginUIWindow (AudioEngine &engine, PluginInsert& insert, bool scrollable) - : ArdourDialog ("plugin ui") +PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptr insert, bool scrollable) + : parent (win) { - if (insert.plugin().has_editor()) { + bool have_gui = false; + non_gtk_gui = false; + was_visible = false; -#ifdef VST_SUPPORT + Label* label = manage (new Label()); + label->set_markup ("THIS IS THE PLUGIN UI"); - VSTPlugin* vp; - - if ((vp = dynamic_cast (&insert.plugin())) != 0) { - - - VSTPluginUI* vpu = new VSTPluginUI (insert, *vp); - - _pluginui = vpu; - add (*vpu); - vpu->package (*this); - - } else { -#endif + if (insert->plugin()->has_editor()) { + switch (insert->type()) { + case ARDOUR::VST: + have_gui = create_vst_editor (insert); + break; + + case ARDOUR::AudioUnit: + have_gui = create_audiounit_editor (insert); + break; + + case ARDOUR::LADSPA: + error << _("Eh? LADSPA plugins don't have editors!") << endmsg; + break; + + case ARDOUR::LV2: + have_gui = create_lv2_editor (insert); + break; + + default: +#ifndef VST_SUPPORT error << _("unknown type of editor-supplying plugin (note: no VST support in this version of ardour)") << endmsg; +#else + error << _("unknown type of editor-supplying plugin") + << endmsg; +#endif throw failed_constructor (); -#ifdef VST_SUPPORT } -#endif - - } else { - PluginUI* pu = new PluginUI (engine, insert, scrollable); - - _pluginui = pu; - add (*pu); - - map_event.connect (mem_fun (*pu, &PluginUI::start_updating)); - unmap_event.connect (mem_fun (*pu, &PluginUI::stop_updating)); } - set_position (Gtk::WIN_POS_MOUSE); - set_name ("PluginEditor"); - add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK); + if (!have_gui) { - signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast (this))); - insert.GoingAway.connect (mem_fun(*this, &PluginUIWindow::plugin_going_away)); + GenericPluginUI* pu = new GenericPluginUI (insert, scrollable); - if (scrollable) { - gint h = _pluginui->get_preferred_height (); - if (h > 600) h = 600; - set_default_size (450, h); - } -} - -PluginUIWindow::~PluginUIWindow () -{ -} - -PluginUI::PluginUI (AudioEngine &engine, PluginInsert& pi, bool scrollable) - : PlugUIBase (pi), - engine(engine), - button_table (initial_button_rows, initial_button_cols), - output_table (initial_output_rows, initial_output_cols), - automation_menu (0), - is_scrollable(scrollable) -{ - set_name ("PluginEditor"); - set_border_width (10); - set_homogeneous (false); - - settings_box.set_homogeneous (false); + _pluginui = pu; + add( *pu ); - HBox* constraint_hbox = manage (new HBox); - HBox* smaller_hbox = manage (new HBox); + /* + Gtk::HBox *hbox = new Gtk::HBox(); + hbox->pack_start( *pu); + // TODO: this should be nicer + hbox->pack_start( eqgui_bin ); - smaller_hbox->pack_start (combo, false, false); - smaller_hbox->pack_start (save_button, false, false); + add (*manage(hbox)); + */ - constraint_hbox->set_spacing (10); - constraint_hbox->pack_start (*smaller_hbox, true, false); - constraint_hbox->pack_end (bypass_button, false, false); + set_wmclass (X_("ardour_plugin_editor"), "Ardour"); -// name_ebox.add (*text_hbox); -// info_vbox.pack_start (name_ebox, false, false); -// info_vbox.pack_start (makerinfo_label, false, false); -// info_vbox.pack_start (paraminfo_label, false, false, 5); + signal_map_event().connect (mem_fun (*pu, &GenericPluginUI::start_updating)); + signal_unmap_event().connect (mem_fun (*pu, &GenericPluginUI::stop_updating)); + } -// settings_box.pack_start (info_vbox, false, false, 10); - settings_box.pack_end (*constraint_hbox, false, false); + // set_position (Gtk::WIN_POS_MOUSE); + set_name ("PluginEditor"); + add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK); - pack_start (settings_box, false, false); + signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast (this)), false); + death_connection = insert->GoingAway.connect (mem_fun(*this, &PluginUIWindow::plugin_going_away)); - if ( is_scrollable ) { - scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); - scroller.set_name ("PluginEditor"); - scroller_view.set_name("PluginEditor"); - scroller_view.add (hpacker); - scroller.add (scroller_view); - - pack_start (scroller, true, true); + gint h = _pluginui->get_preferred_height (); + gint w = _pluginui->get_preferred_width (); - } - else { - pack_start (hpacker, false, false); + if (scrollable) { + if (h > 600) h = 600; + if (w > 600) w = 600; - // this is a hack to get the theme right - name_ebox.set_name ("PluginNameBox"); + if (w < 0) { + w = 450; + } } - insert.active_changed.connect (mem_fun(*this, &PluginUI::redirect_active_changed)); - bypass_button.set_active (!insert.active()); - - build (engine); + set_default_size (w, h); } -PluginUI::~PluginUI () +PluginUIWindow::~PluginUIWindow () { - if (output_controls.size() > 0) { - screen_update_connection.disconnect(); - } + delete _pluginui; } void -PluginUI::build (AudioEngine &engine) - +PluginUIWindow::set_parent (Gtk::Window* win) { - guint32 i = 0; - guint32 x = 0; - Frame* frame; - Frame* bt_frame; - VBox* box; - char info[32]; - int output_row, output_col; - int button_row, button_col; - int output_rows, output_cols; - int button_rows, button_cols; - guint32 n_ins=0, n_outs = 0; - - prefheight = 30; - hpacker.set_spacing (10); - - output_rows = initial_output_rows; - output_cols = initial_output_cols; - button_rows = initial_button_rows; - button_cols = initial_button_cols; - output_row = 0; - button_row = 0; - output_col = 0; - button_col = 0; - - button_table.set_homogeneous (false); - button_table.set_row_spacings (2); - button_table.set_col_spacings (2); - output_table.set_homogeneous (true); - output_table.set_row_spacings (2); - output_table.set_col_spacings (2); - button_table.set_border_width (5); - output_table.set_border_width (5); - - hpacker.set_border_width (10); - - bt_frame = manage (new Frame); - bt_frame->set_name ("BaseFrame"); - bt_frame->add (button_table); - hpacker.pack_start(*bt_frame, true, true); - - box = manage (new VBox); - frame = manage (new Frame); - frame->set_name ("BaseFrame"); - frame->add (*box); - hpacker.pack_start(*frame, true, true); - - box->set_border_width (5); - box->set_spacing (1); - - /* find all ports. build control elements for all appropriate control ports */ - - for (i = 0; i < plugin.parameter_count(); ++i) { - - if (plugin.parameter_is_control (i)) { - - ControlUI* cui; - - /* if we are scrollable, just use one long column */ - - if (!is_scrollable) { - if (x++ > 7){ - frame = manage (new Frame); - frame->set_name ("BaseFrame"); - box = manage (new VBox); - - box->set_border_width (5); - box->set_spacing (1); - - frame->add (*box); - hpacker.pack_start(*frame,true,true); - - x = 0; - } - } + parent = win; +} - /* Don't show latency control ports */ +void +PluginUIWindow::on_map () +{ + Window::on_map (); + set_keep_above (true); +} - if (plugin.describe_parameter (i) == X_("latency")) { - continue; - } +bool +PluginUIWindow::on_enter_notify_event (GdkEventCrossing *ev) +{ + Keyboard::the_keyboard().enter_window (ev, this); + return false; +} - if ((cui = build_control_ui (engine, i, plugin.get_nth_midi_control (i))) == 0) { - error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg; - continue; - } - - if (cui->control || cui->clickbox || cui->combo) { - - box->pack_start (*cui, false, false); - - } else if (cui->button) { - - if (button_row == button_rows) { - button_row = 0; - if (++button_col == button_cols) { - button_cols += 2; - button_table.resize (button_rows, button_cols); - } - } - - button_table.attach (*cui, button_col, button_col + 1, button_row, button_row+1, - FILL|EXPAND, FILL); - button_row++; - - } else if (cui->display) { - - if (output_row == output_rows) { - output_row = 0; - if (++output_col == output_cols) { - output_cols += 2; - output_table.resize (output_rows, output_cols); - } - } - - output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1, - FILL|EXPAND, FILL); - - output_row++; - } - - /* HACK: ideally the preferred height would be queried from - the complete hpacker, but I can't seem to get that - information in time, so this is an estimation - */ +bool +PluginUIWindow::on_leave_notify_event (GdkEventCrossing *ev) +{ + Keyboard::the_keyboard().leave_window (ev, this); + return false; +} - prefheight += 30; +bool +PluginUIWindow::on_focus_in_event (GdkEventFocus *ev) +{ + Window::on_focus_in_event (ev); + //Keyboard::the_keyboard().magic_widget_grab_focus (); + return false; +} - } - } +bool +PluginUIWindow::on_focus_out_event (GdkEventFocus *ev) +{ + Window::on_focus_out_event (ev); + //Keyboard::the_keyboard().magic_widget_drop_focus (); + return false; +} - n_ins = plugin.get_info().n_inputs; - n_outs = plugin.get_info().n_outputs; +void +PluginUIWindow::on_show () +{ + set_role("plugin_ui"); - if (box->children().empty()) { - hpacker.remove (*frame); + if (_pluginui) { + _pluginui->update_presets (); } - if (button_table.children().empty()) { - hpacker.remove (*bt_frame); + if (_pluginui) { + if (_pluginui->on_window_show (_title)) { + Window::on_show (); + } } - if (!output_table.children().empty()) { - frame = manage (new Frame); - frame->set_name ("BaseFrame"); - frame->add (output_table); - hpacker.pack_end (*frame, true, true); + if (parent) { + // set_transient_for (*parent); } +} - output_update (); +void +PluginUIWindow::on_hide () +{ + Window::on_hide (); - string pname = plugin.name(); - - if (pname.length() > 24) { - pname = pname.substr (0, 24); - pname += "..."; - ARDOUR_UI::instance()->tooltips().set_tip(name_ebox, plugin.name()); + if (_pluginui) { + _pluginui->on_window_hide (); } +} - - nameinfo_label.set_text (pname); - nameinfo_label.set_name ("PluginNameInfo"); - nameinfo_label.set_alignment (0.0, 0.0); +void +PluginUIWindow::set_title(const Glib::ustring& title) +{ + //cout << "PluginUIWindow::set_title(\"" << title << "\"" << endl; + Gtk::Window::set_title(title); + _title = title; +} + +bool +#ifdef VST_SUPPORT +PluginUIWindow::create_vst_editor(boost::shared_ptr insert) +#else +PluginUIWindow::create_vst_editor(boost::shared_ptr) +#endif +{ +#ifndef VST_SUPPORT + return false; +#else - string maker = plugin.maker(); - string::size_type email_pos; + boost::shared_ptr vp; - if ((email_pos = maker.find_first_of ('<')) != string::npos) { - maker = maker.substr (0, email_pos - 1); - } + if ((vp = boost::dynamic_pointer_cast (insert->plugin())) == 0) { + error << _("unknown type of editor-supplying plugin (note: no VST support in this version of ardour)") + << endmsg; + throw failed_constructor (); + } else { + VSTPluginUI* vpu = new VSTPluginUI (insert, vp); - if (maker.length() > 32) { - maker = maker.substr (0, 32); - maker += " ..."; + _pluginui = vpu; + add (*vpu); + vpu->package (*this); } - makerinfo_label.set_text (maker); - makerinfo_label.set_name ("PluginMakerInfo"); - makerinfo_label.set_alignment (0.0, 0.0); - - snprintf (info, sizeof(info),"[ %u %s | %u %s ]", - n_ins, ngettext(_("in"), _("ins"), n_ins), - n_outs, ngettext(_("out"), _("outs"), n_outs)); - paraminfo_label.set_text (info); - paraminfo_label.set_name ("PluginParameterInfo"); - paraminfo_label.set_alignment (0.0, 0.0); - - output_table.show_all (); - button_table.show_all (); + non_gtk_gui = true; + return true; +#endif } -PluginUI::ControlUI::ControlUI () - : automate_button (X_("")) // force creation of a label +bool +#if defined (HAVE_AUDIOUNITS) && defined (GTKOSX) +PluginUIWindow::create_audiounit_editor (boost::shared_ptr insert) +#else +PluginUIWindow::create_audiounit_editor (boost::shared_ptr) +#endif { - automate_button.set_name ("PluginAutomateButton"); - ARDOUR_UI::instance()->tooltips().set_tip (automate_button, - _("automation control")); - - /* don't fix the height, it messes up the bar controllers */ +#if !defined(HAVE_AUDIOUNITS) || !defined(GTKOSX) + return false; +#else + VBox* box; + _pluginui = create_au_gui (insert, &box); + add (*box); + non_gtk_gui = true; - set_size_request_to_display_given_text (automate_button, X_("longenuff"), 2, -1); + extern sigc::signal ApplicationActivationChanged; + ApplicationActivationChanged.connect (mem_fun (*this, &PluginUIWindow::app_activated)); - ignore_change = 0; - display = 0; - button = 0; - control = 0; - clickbox = 0; - adjustment = 0; - meterinfo = 0; + return true; +#endif } -PluginUI::ControlUI::~ControlUI() +void +#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX) +PluginUIWindow::app_activated (bool yn) +#else +PluginUIWindow::app_activated (bool) +#endif { - if (adjustment) { - delete adjustment; - } - - if (meterinfo) { - delete meterinfo->meter; - delete meterinfo; +#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX) + cerr << "APP activated ? " << yn << endl; + if (_pluginui) { + if (yn) { + if (was_visible) { + _pluginui->activate (); + present (); + was_visible = true; + } + } else { + was_visible = is_visible(); + hide (); + _pluginui->deactivate (); + } } +#endif } -void -PluginUI::automation_state_changed (ControlUI* cui) +bool +PluginUIWindow::create_lv2_editor(boost::shared_ptr insert) { - /* update button label */ +#ifndef HAVE_SLV2 + return false; +#else - switch (insert.get_port_automation_state (cui->port_index) & (Off|Play|Touch|Write)) { - case Off: - static_cast(cui->automate_button.get_child())->set_text (_("off")); - break; - case Play: - static_cast(cui->automate_button.get_child())->set_text (_("play")); - break; - case Write: - static_cast(cui->automate_button.get_child())->set_text (_("write")); - break; - case Touch: - static_cast(cui->automate_button.get_child())->set_text (_("touch")); - break; - default: - static_cast(cui->automate_button.get_child())->set_text (_("???")); - break; + boost::shared_ptr vp; + + if ((vp = boost::dynamic_pointer_cast (insert->plugin())) == 0) { + error << _("create_lv2_editor called on non-LV2 plugin") << endmsg; + throw failed_constructor (); + } else { + LV2PluginUI* lpu = new LV2PluginUI (insert, vp); + _pluginui = lpu; + add (*lpu); + lpu->package (*this); } -} + non_gtk_gui = false; + return true; +#endif +} -static void integer_printer (char buf[32], Adjustment &adj, void *arg) +bool +PluginUIWindow::on_key_press_event (GdkEventKey* event) { - snprintf (buf, 32, "%.0f", adj.get_value()); + return relay_key_press (event, this); } -void -PluginUI::print_parameter (char *buf, uint32_t len, uint32_t param) +bool +PluginUIWindow::on_key_release_event (GdkEventKey *) { - plugin.print_parameter (param, buf, len); + return true; } -PluginUI::ControlUI* -PluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, MIDI::Controllable* mcontrol) - +void +PluginUIWindow::plugin_going_away () { - ControlUI* control_ui; - Plugin::ParameterDescriptor desc; - - plugin.get_parameter_descriptor (port_index, desc); - - control_ui = manage (new ControlUI ()); - control_ui->adjustment = 0; - control_ui->combo = 0; - control_ui->combo_map = 0; - control_ui->port_index = port_index; - control_ui->update_pending = false; - control_ui->label.set_text (desc.label); - control_ui->label.set_alignment (0.0, 0.5); - control_ui->label.set_name ("PluginParameterLabel"); - - control_ui->set_spacing (5); - - if (plugin.parameter_is_input (port_index)) { - - LadspaPlugin* lp; - - if ((lp = dynamic_cast(&plugin)) != 0) { - - lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index); - - if (defaults && defaults->count > 0) { - - control_ui->combo = new Gtk::Combo; - control_ui->combo->set_value_in_list(true, false); - set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui)); - control_ui->combo->signal_unmap_event().connect( mem_fun(*this, &PluginUI::control_combo_changed), control_ui); - plugin.ParameterChanged.connect (bind (mem_fun(*this, &PluginUI::parameter_changed), control_ui)); - control_ui->pack_start(control_ui->label, true, true); - control_ui->pack_start(*control_ui->combo, false, true); - - update_control_display(control_ui); - - lrdf_free_setting_values(defaults); - return control_ui; - } - } - - if (desc.toggled) { - - /* Build a button */ - - control_ui->button = manage (new ToggleButton ()); - control_ui->button->set_name ("PluginEditorButton"); - control_ui->button->set_size_request (20, 20); - - control_ui->pack_start (control_ui->label, true, true); - control_ui->pack_start (*control_ui->button, false, true); - control_ui->pack_start (control_ui->automate_button, false, false); - - control_ui->button->signal_clicked().connect (bind (mem_fun(*this, &PluginUI::control_port_toggled), control_ui)); - - if(plugin.get_parameter (port_index) == 1){ - control_ui->button->set_active(true); - } - - return control_ui; - } - - control_ui->adjustment = new Adjustment (0, 0, 0, 0, 0); - - /* XXX this code is not right yet, because it doesn't handle - the absence of bounds in any sensible fashion. - */ - - control_ui->adjustment->set_lower (desc.lower); - control_ui->adjustment->set_upper (desc.upper); + ENSURE_GUI_THREAD(mem_fun(*this, &PluginUIWindow::plugin_going_away)); - control_ui->logarithmic = desc.logarithmic; - if (control_ui->logarithmic) { - if (control_ui->adjustment->get_lower() == 0.0) { - control_ui->adjustment->set_lower (control_ui->adjustment->get_upper()/10000); - } - control_ui->adjustment->set_upper (log(control_ui->adjustment->get_upper())); - control_ui->adjustment->set_lower (log(control_ui->adjustment->get_lower())); - } - - float delta = desc.upper - desc.lower; - - control_ui->adjustment->set_page_size (delta/100.0); - control_ui->adjustment->set_step_increment (desc.step); - control_ui->adjustment->set_page_increment (desc.largestep); - - if (desc.integer_step) { - control_ui->clickbox = new ClickBox (control_ui->adjustment, "PluginUIClickBox"); - Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2); - control_ui->clickbox->set_print_func (integer_printer, 0); - } else { -// control_ui->control = new HSliderController (ARDOUR_UI::instance()->plugin_ui_slider_pix(), -// control_ui->adjustment, -// mcontrol); - - sigc::slot pslot = sigc::bind (mem_fun(*this, &PluginUI::print_parameter), (uint32_t) port_index); - - control_ui->control = new BarController (*control_ui->adjustment, mcontrol, pslot); - control_ui->control->set_size_request (200, 15); - control_ui->control->set_name (X_("PluginSlider")); - control_ui->control->set_style (BarController::LeftToRight); - control_ui->control->set_use_parent (true); - - control_ui->control->get_spin_button().signal_focus_in_event().connect (mem_fun(*this, &PluginUI::entry_focus_event)); - control_ui->control->get_spin_button().signal_focus_out_event().connect (mem_fun(*this, &PluginUI::entry_focus_event)); - - control_ui->control->StartGesture.connect (bind (mem_fun(*this, &PluginUI::start_touch), control_ui)); - control_ui->control->StopGesture.connect (bind (mem_fun(*this, &PluginUI::stop_touch), control_ui)); - - } - - if (control_ui->logarithmic) { - control_ui->adjustment->set_value(log(plugin.get_parameter(port_index))); - } else{ - control_ui->adjustment->set_value(plugin.get_parameter(port_index)); - } - - /* XXX memory leak: SliderController not destroyed by ControlUI - destructor, and manage() reports object hierarchy - ambiguity. - */ - - control_ui->pack_start (control_ui->label, true, true); - if (desc.integer_step) { - control_ui->pack_start (*control_ui->clickbox, false, false); - } else { - control_ui->pack_start (*control_ui->control, false, false); - } - - control_ui->pack_start (control_ui->automate_button, false, false); -control_ui->adjustment->signal_value_changed().connect (bind (mem_fun(*this, &PluginUI::control_adjustment_changed), control_ui)); - control_ui->automate_button.signal_clicked().connect (bind (mem_fun(*this, &PluginUI::astate_clicked), control_ui, (uint32_t) port_index)); - - automation_state_changed (control_ui); + if (_pluginui) { + _pluginui->stop_updating(0); + } - plugin.ParameterChanged.connect (bind (mem_fun(*this, &PluginUI::parameter_changed), control_ui)); - insert.automation_list (port_index).automation_state_changed.connect - (bind (mem_fun(*this, &PluginUI::automation_state_changed), control_ui)); + death_connection.disconnect (); - } else if (plugin.parameter_is_output (port_index)) { + delete_when_idle (this); +} - control_ui->display = manage (new EventBox); - control_ui->display->set_name ("ParameterValueDisplay"); +PlugUIBase::PlugUIBase (boost::shared_ptr pi) + : insert (pi), + plugin (insert->plugin()), + save_button(_("Add")), + bypass_button (_("Bypass")), + latency_gui (0), + plugin_analysis_expander (_("Plugin analysis")) +{ + //preset_combo.set_use_arrows_always(true); + update_presets(); + preset_combo.set_size_request (100, -1); + preset_combo.set_active_text (""); + preset_combo.signal_changed().connect(mem_fun(*this, &PlugUIBase::setting_selected)); - control_ui->display_label = manage (new Label); - control_ui->display_label->set_name ("ParameterValueDisplay"); + save_button.set_name ("PluginSaveButton"); + save_button.signal_clicked().connect(mem_fun(*this, &PlugUIBase::save_plugin_setting)); - control_ui->display->add (*control_ui->display_label); - Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "g999999", 2, 2); + insert->ActiveChanged.connect (bind( + mem_fun(*this, &PlugUIBase::processor_active_changed), + boost::weak_ptr(insert))); - control_ui->display->show_all (); + bypass_button.set_active (!pi->active()); - /* set up a meter */ - /* TODO: only make a meter if the port is Hinted for it */ + bypass_button.set_name ("PluginBypassButton"); + bypass_button.signal_toggled().connect (mem_fun(*this, &PlugUIBase::bypass_toggled)); + focus_button.add_events (Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK); - MeterInfo * info = new MeterInfo(port_index); - control_ui->meterinfo = info; - - info->meter = new FastMeter (100, 5, FastMeter::Horizontal); + focus_button.signal_button_release_event().connect (mem_fun(*this, &PlugUIBase::focus_toggled)); + focus_button.add_events (Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK); - info->min_unbound = desc.min_unbound; - info->max_unbound = desc.max_unbound; + /* these images are not managed, so that we can remove them at will */ - info->min = desc.lower; - info->max = desc.upper; + focus_out_image = new Image (get_icon (X_("computer_keyboard"))); + focus_in_image = new Image (get_icon (X_("computer_keyboard_active"))); - control_ui->vbox = manage (new VBox); + focus_button.add (*focus_out_image); - control_ui->vbox->pack_start (control_ui->label, false, false); - control_ui->vbox->pack_start (*info->meter, false, false); - - control_ui->pack_start (*control_ui->vbox, false, false); - control_ui->pack_start (*control_ui->display, false, false); + ARDOUR_UI::instance()->set_tip (&focus_button, _("Click to allow the plugin to receive keyboard events that Ardour would normally use as a shortcut"), ""); + ARDOUR_UI::instance()->set_tip (&bypass_button, _("Click to enable/disable this plugin"), ""); - control_ui->meterinfo->meter->show_all(); - control_ui->meterinfo->packed = true; - - output_controls.push_back (control_ui); - } - - plugin.ParameterChanged.connect (bind (mem_fun(*this, &PluginUI::parameter_changed), control_ui)); - return control_ui; -} + plugin_analysis_expander.property_expanded().signal_changed().connect( mem_fun(*this, &PlugUIBase::toggle_plugin_analysis)); + plugin_analysis_expander.set_expanded(false); -void -PluginUI::start_touch (PluginUI::ControlUI* cui) -{ - insert.automation_list (cui->port_index).start_touch (); + insert->GoingAway.connect (mem_fun (*this, &PlugUIBase::plugin_going_away)); } -void -PluginUI::stop_touch (PluginUI::ControlUI* cui) +PlugUIBase::~PlugUIBase() { - insert.automation_list (cui->port_index).stop_touch (); + delete latency_gui; } void -PluginUI::astate_clicked (ControlUI* cui, uint32_t port) +PlugUIBase::plugin_going_away () { - using namespace Menu_Helpers; - - if (automation_menu == 0) { - automation_menu = manage (new Menu); - automation_menu->set_name ("ArdourContextMenu"); - } - - MenuList& items (automation_menu->items()); - - items.clear (); - items.push_back (MenuElem (_("off"), - bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Off, cui))); - items.push_back (MenuElem (_("play"), - bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Play, cui))); - items.push_back (MenuElem (_("write"), - bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Write, cui))); - items.push_back (MenuElem (_("touch"), - bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Touch, cui))); - - automation_menu->popup (1, 0); + /* drop references to the plugin/insert */ + insert.reset (); + plugin.reset (); } void -PluginUI::set_automation_state (AutoState state, ControlUI* cui) +PlugUIBase::set_latency_label () { - insert.set_port_automation_state (cui->port_index, state); -} + char buf[64]; + nframes_t l = insert->effective_latency (); + nframes_t sr = insert->session().frame_rate(); -void -PluginUI::control_adjustment_changed (ControlUI* cui) -{ - if (cui->ignore_change) { - return; - } - - double value = cui->adjustment->get_value(); - - if (cui->logarithmic) { - value = exp(value); + if (l < sr / 1000) { + snprintf (buf, sizeof (buf), "latency (%d samples)", l); + } else { + snprintf (buf, sizeof (buf), "latency (%.2f msecs)", (float) l / ((float) sr / 1000.0f)); } - insert.set_parameter (cui->port_index, (float) value); + latency_label.set_text (buf); } void -PluginUI::parameter_changed (uint32_t abs_port_id, float val, ControlUI* cui) +PlugUIBase::latency_button_clicked () { - if (cui->port_index == abs_port_id) { - if (!cui->update_pending) { - cui->update_pending = true; - Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &PluginUI::update_control_display), cui)); - } + if (!latency_gui) { + latency_gui = new LatencyGUI (*(insert.get()), insert->session().frame_rate(), insert->session().get_block_size()); + latency_dialog = new ArdourDialog ("Edit Latency", false, false); + latency_dialog->get_vbox()->pack_start (*latency_gui); + latency_dialog->signal_hide().connect (mem_fun (*this, &PlugUIBase::set_latency_label)); } -} - -void -PluginUI::update_control_display (ControlUI* cui) -{ - /* XXX how do we handle logarithmic stuff here ? */ - - cui->update_pending = false; - - float val = plugin.get_parameter (cui->port_index); - - cui->ignore_change++; - if (cui->combo) { - std::map::iterator it; - for (it = cui->combo_map->begin(); it != cui->combo_map->end(); ++it) { - if (it->second == val) { - cui->combo->set_active_text(it->first); - break; - } - } - } else if (cui->adjustment == 0) { - - if (val > 0.5) { - cui->button->set_active (true); - } else { - cui->button->set_active (false); - } - } else { - if (cui->logarithmic) { - val = log(val); - } - if (val != cui->adjustment->get_value()) { - cui->adjustment->set_value (val); - } - } - cui->ignore_change--; + latency_dialog->show_all (); } void -PluginUI::control_port_toggled (ControlUI* cui) -{ - if (!cui->ignore_change) { - insert.set_parameter (cui->port_index, cui->button->get_active()); - } -} - -gint -PluginUI::control_combo_changed (GdkEventAny* ignored, ControlUI* cui) +PlugUIBase::processor_active_changed (boost::weak_ptr weak_p) { - if (!cui->ignore_change) { - string value = cui->combo->get_active_text(); - std::map mapping = *cui->combo_map; - insert.set_parameter (cui->port_index, mapping[value]); + ENSURE_GUI_THREAD(bind (mem_fun(*this, &PlugUIBase::processor_active_changed), weak_p)); + boost::shared_ptr p (weak_p); + if (p) { + bypass_button.set_active (!p->active()); } - - return FALSE; } void -PluginUIWindow::plugin_going_away (ARDOUR::Redirect* ignored) +PlugUIBase::setting_selected() { - ENSURE_GUI_THREAD(bind (mem_fun(*this, &PluginUIWindow::plugin_going_away), ignored)); - - _pluginui->stop_updating(0); - delete_when_idle (this); -} - -gint -PluginUI::entry_focus_event (GdkEventFocus* ev) -{ - if (ev->in) { - ARDOUR_UI::instance()->allow_focus (true); - } else { - ARDOUR_UI::instance()->allow_focus (false); + if (preset_combo.get_active_text().length() > 0) { + const Plugin::PresetRecord* pr = plugin->preset_by_label(preset_combo.get_active_text()); + if (pr) { + plugin->load_preset(pr->uri); + } else { + warning << string_compose(_("Plugin preset %1 not found"), + preset_combo.get_active_text()) << endmsg; + } } - return TRUE; } void -PluginUI::redirect_active_changed (Redirect* r, void* src) -{ - ENSURE_GUI_THREAD(bind (mem_fun(*this, &PluginUI::redirect_active_changed), r, src)); - - bypass_button.set_active (!r->active()); -} - -gint -PluginUI::start_updating (GdkEventAny *ev) -{ - if (output_controls.size() > 0 ) { - screen_update_connection.disconnect(); - screen_update_connection = ARDOUR_UI::instance()->RapidScreenUpdate.connect - (mem_fun(*this, &PluginUI::output_update)); - } - return FALSE; -} - -gint -PluginUI::stop_updating (GdkEventAny *ev) +PlugUIBase::save_plugin_setting () { - if (output_controls.size() > 0 ) { - screen_update_connection.disconnect(); - } - return FALSE; -} + ArdourPrompter prompter (true); + prompter.set_prompt(_("Name of New Preset:")); + prompter.add_button (Gtk::Stock::ADD, Gtk::RESPONSE_ACCEPT); + prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false); + prompter.set_type_hint (Gdk::WINDOW_TYPE_HINT_UTILITY); -void -PluginUI::output_update () -{ - for (vector::iterator i = output_controls.begin(); i != output_controls.end(); ++i) { - float val = plugin.get_parameter ((*i)->port_index); - char buf[32]; - snprintf (buf, sizeof(buf), "%.2f", val); - (*i)->display_label->set_text (buf); - - /* autoscaling for the meter */ - if ((*i)->meterinfo && (*i)->meterinfo->packed) { - - if (val < (*i)->meterinfo->min) { - if ((*i)->meterinfo->min_unbound) - (*i)->meterinfo->min = val; - else - val = (*i)->meterinfo->min; - } + prompter.show_all(); + prompter.present (); - if (val > (*i)->meterinfo->max) { - if ((*i)->meterinfo->max_unbound) - (*i)->meterinfo->max = val; - else - val = (*i)->meterinfo->max; - } - - if ((*i)->meterinfo->max > (*i)->meterinfo->min ) { - float lval = (val - (*i)->meterinfo->min) / ((*i)->meterinfo->max - (*i)->meterinfo->min) ; - (*i)->meterinfo->meter->set (lval ); + switch (prompter.run ()) { + case Gtk::RESPONSE_ACCEPT: + string name; + prompter.get_result(name); + if (name.length()) { + if (plugin->save_preset(name)) { + update_presets(); + preset_combo.set_active_text (name); } } + break; } } -list -PluginUI::setup_scale_values(guint32 port_index, ControlUI* cui) +void +PlugUIBase::bypass_toggled () { - list enums; - LadspaPlugin* lp = dynamic_cast (&plugin); - - cui->combo_map = new std::map; - lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index); - if (defaults) { - for (uint32_t i = 0; i < defaults->count; ++i) { - enums.push_back(defaults->items[i].label); - pair newpair; - newpair.first = defaults->items[i].label; - newpair.second = defaults->items[i].value; - cui->combo_map->insert(newpair); - } + bool x; - lrdf_free_setting_values(defaults); + if ((x = bypass_button.get_active()) == insert->active()) { + if (x) { + insert->deactivate (); + } else { + insert->activate (); + } } - - return enums; } -PlugUIBase::PlugUIBase (PluginInsert& pi) - : insert (pi), - plugin (insert.plugin()), - save_button(_("save")), - bypass_button (_("bypass")) +bool +PlugUIBase::focus_toggled (GdkEventButton*) { - combo.set_value_in_list(true,true); - combo.set_use_arrows(true); - combo.set_use_arrows_always(true); - set_popdown_strings (combo, plugin.get_presets()); - combo.set_active_text (""); - combo.signal_unmap_event().connect(mem_fun(*this, &PlugUIBase::setting_selected)); - - save_button.set_name ("PluginSaveButton"); - save_button.signal_clicked().connect(mem_fun(*this, &PlugUIBase::save_plugin_setting)); - - bypass_button.set_name ("PluginBypassButton"); - bypass_button.signal_toggled().connect (mem_fun(*this, &PlugUIBase::bypass_toggled)); -} - -gint -PlugUIBase::setting_selected(GdkEventAny* ignored) -{ - if (combo.get_active_text().length() > 0) { - if (!plugin.load_preset(combo.get_active_text())) { - warning << string_compose(_("Plugin preset %1 not found"), combo.get_active_text()) << endmsg; - } + if (Keyboard::the_keyboard().some_magic_widget_has_focus()) { + Keyboard::the_keyboard().magic_widget_drop_focus(); + focus_button.remove (); + focus_button.add (*focus_out_image); + focus_out_image->show (); + ARDOUR_UI::instance()->set_tip (&focus_button, _("Click to allow the plugin to receive keyboard events that Ardour would normally use as a shortcut"), ""); + } else { + Keyboard::the_keyboard().magic_widget_grab_focus(); + focus_button.remove (); + focus_button.add (*focus_in_image); + focus_in_image->show (); + ARDOUR_UI::instance()->set_tip (&focus_button, _("Click to allow normal use of Ardour keyboard shortcuts"), ""); } - return FALSE; + return true; } void -PlugUIBase::save_plugin_setting () +PlugUIBase::toggle_plugin_analysis() { - ArdourPrompter prompter (true); - prompter.set_prompt(_("Name for plugin settings:")); + if (plugin_analysis_expander.get_expanded() && + !plugin_analysis_expander.get_child()) { + // Create the GUI + PluginEqGui *foo = new PluginEqGui(insert); + plugin_analysis_expander.add( *foo ); + plugin_analysis_expander.show_all(); + } - prompter.show_all(); + Gtk::Widget *gui; - switch (prompter.run ()) { - case GTK_RESPONSE_ACCEPT: + if (!plugin_analysis_expander.get_expanded() && + (gui = plugin_analysis_expander.get_child())) { + // Hide & remove + gui->hide(); + //plugin_analysis_expander.remove(*gui); + plugin_analysis_expander.remove(); - string name; + delete gui; - prompter.get_result(name); + Gtk::Widget *toplevel = plugin_analysis_expander.get_toplevel(); + if (!toplevel) { + std::cerr << "No toplevel widget?!?!" << std::endl; + return; + } - if (name.length()) { - if(plugin.save_preset(name)){ - set_popdown_strings (combo, plugin.get_presets()); - combo.set_active_text (name); - } + Gtk::Container *cont = dynamic_cast(toplevel); + if (!cont) { + std::cerr << "Toplevel widget is not a container?!?" << std::endl; + return; } - break; + + Gtk::Allocation alloc(0, 0, 50, 50); // Just make it small + toplevel->size_allocate(alloc); } } void -PlugUIBase::bypass_toggled () +PlugUIBase::update_presets () { - bool x; - - if ((x = bypass_button.get_active()) == insert.active()) { - insert.set_active (!x, this); + vector preset_labels; + vector presets = plugin->get_presets(); + for (vector::const_iterator i = presets.begin(); + i != presets.end(); ++i) { + preset_labels.push_back(i->label); } + set_popdown_strings (preset_combo, preset_labels); } -