X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fplugin_ui.cc;h=1c7ce5d9e6895896957fbd6b5d6e158848b326db;hb=c2c224727eee4c16bd64ca4a5b5bb2d276f5afe3;hp=edc94864f2a916d51fb934f1f0088f5509d9d8d3;hpb=ab6f1ed9bafa869648b6e94ee5186ff317b32c3e;p=ardour.git diff --git a/gtk2_ardour/plugin_ui.cc b/gtk2_ardour/plugin_ui.cc index edc94864f2..1c7ce5d9e6 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,18 +15,23 @@ 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 @@ -34,23 +39,32 @@ #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" @@ -59,802 +73,419 @@ using namespace ARDOUR; using namespace PBD; using namespace Gtkmm2ext; using namespace Gtk; -using namespace sigc; -PluginUIWindow::PluginUIWindow (AudioEngine &engine, boost::shared_ptr insert, bool scrollable) - : ArdourDialog ("plugin ui") +PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptr insert, bool scrollable) + : parent (win) { + bool have_gui = false; + non_gtk_gui = false; + was_visible = false; + + Label* label = manage (new Label()); + label->set_markup ("THIS IS THE PLUGIN UI"); + if (insert->plugin()->has_editor()) { + switch (insert->type()) { + case ARDOUR::VST: + have_gui = create_vst_editor (insert); + break; -#ifdef VST_SUPPORT + case ARDOUR::AudioUnit: + have_gui = create_audiounit_editor (insert); + break; - boost::shared_ptr vp; - - if ((vp = boost::dynamic_pointer_cast (insert->plugin())) != 0) { - - - VSTPluginUI* vpu = new VSTPluginUI (insert, vp); - - _pluginui = vpu; - get_vbox()->add (*vpu); - vpu->package (*this); - - } else { -#endif + 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 { - LadspaPluginUI* pu = new LadspaPluginUI (engine, insert, scrollable); - - _pluginui = pu; - get_vbox()->add (*pu); - - signal_map_event().connect (mem_fun (*pu, &LadspaPluginUI::start_updating)); - signal_unmap_event().connect (mem_fun (*pu, &LadspaPluginUI::stop_updating)); } - 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); + 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 = pu; + add (*pu); -LadspaPluginUI::LadspaPluginUI (AudioEngine &engine, boost::shared_ptr pi, bool scrollable) - : PlugUIBase (pi), - engine(engine), - button_table (initial_button_rows, initial_button_cols), - output_table (initial_output_rows, initial_output_cols), - hAdjustment(0.0, 0.0, 0.0), - vAdjustment(0.0, 0.0, 0.0), - scroller_view(hAdjustment, vAdjustment), - automation_menu (0), - is_scrollable(scrollable) -{ - set_name ("PluginEditor"); - set_border_width (10); - set_homogeneous (false); + /* + Gtk::HBox *hbox = new Gtk::HBox(); + hbox->pack_start( *pu); + // TODO: this should be nicer + hbox->pack_start( eqgui_bin ); - settings_box.set_homogeneous (false); + add (*manage(hbox)); + */ - HBox* constraint_hbox = manage (new HBox); - HBox* smaller_hbox = manage (new HBox); - Label* combo_label = manage (new Label (_("Presets"))); - combo_label->set_use_markup (true); + set_wmclass (X_("ardour_plugin_editor"), "Ardour"); - smaller_hbox->pack_start (*combo_label, false, false, 10); - smaller_hbox->pack_start (combo, false, false); - smaller_hbox->pack_start (save_button, false, false); + signal_map_event().connect (sigc::mem_fun (*pu, &GenericPluginUI::start_updating)); + signal_unmap_event().connect (sigc::mem_fun (*pu, &GenericPluginUI::stop_updating)); + } - constraint_hbox->set_spacing (5); - constraint_hbox->pack_start (*smaller_hbox, true, false); - constraint_hbox->pack_end (bypass_button, 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); - settings_box.pack_end (*constraint_hbox, false, false); + signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), reinterpret_cast (this)), false); + insert->DropReferences.connect (death_connection, boost::bind (&PluginUIWindow::plugin_going_away, this), gui_context()); - pack_start (settings_box, false, false); + gint h = _pluginui->get_preferred_height (); + gint w = _pluginui->get_preferred_width (); - 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); + if (scrollable) { + if (h > 600) h = 600; + if (w > 600) w = 600; - } - else { - pack_start (hpacker, false, false); + if (w < 0) { + w = 450; + } } - insert->active_changed.connect (mem_fun(*this, &LadspaPluginUI::redirect_active_changed)); - bypass_button.set_active (!insert->active()); - - build (engine); + set_default_size (w, h); } -LadspaPluginUI::~LadspaPluginUI () +PluginUIWindow::~PluginUIWindow () { - if (output_controls.size() > 0) { - screen_update_connection.disconnect(); - } + delete _pluginui; } void -LadspaPluginUI::build (AudioEngine &engine) - +PluginUIWindow::set_parent (Gtk::Window* win) { - guint32 i = 0; - guint32 x = 0; - Frame* frame; - Frame* bt_frame; - VBox* box; - 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); - box->set_border_width (5); - box->set_spacing (1); - - frame = manage (new Frame); - frame->set_name ("BaseFrame"); - frame->set_label (_("Controls")); - frame->add (*box); - hpacker.pack_start(*frame, true, true); - - /* 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)) { - - /* Don't show latency control ports */ - - if (plugin->describe_parameter (i) == X_("latency")) { - continue; - } - - 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; - } - } - - if ((cui = build_control_ui (engine, i, plugin->get_nth_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) { - - output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1, - FILL|EXPAND, FILL); - - // TODO: The meters should be divided into multiple rows - - if (++output_col == output_cols) { - output_cols ++; - output_table.resize (output_rows, output_cols); - } - - /* old code, which divides meters into - * columns first, rows later. New code divides into one row - - 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 - */ - - prefheight += 30; - - } - } - - n_ins = plugin->get_info()->n_inputs; - n_outs = plugin->get_info()->n_outputs; - - if (box->children().empty()) { - hpacker.remove (*frame); - } - - if (button_table.children().empty()) { - hpacker.remove (*bt_frame); - } - - if (!output_table.children().empty()) { - frame = manage (new Frame); - frame->set_name ("BaseFrame"); - frame->add (output_table); - hpacker.pack_end (*frame, true, true); - } - - output_update (); + parent = win; +} - output_table.show_all (); - button_table.show_all (); +void +PluginUIWindow::on_map () +{ + Window::on_map (); + set_keep_above (true); } -LadspaPluginUI::ControlUI::ControlUI () - : automate_button (X_("")) // force creation of a label +bool +PluginUIWindow::on_enter_notify_event (GdkEventCrossing *ev) { - automate_button.set_name ("PluginAutomateButton"); - ARDOUR_UI::instance()->tooltips().set_tip (automate_button, - _("Automation control")); + Keyboard::the_keyboard().enter_window (ev, this); + return false; +} - /* don't fix the height, it messes up the bar controllers */ +bool +PluginUIWindow::on_leave_notify_event (GdkEventCrossing *ev) +{ + Keyboard::the_keyboard().leave_window (ev, this); + return false; +} - set_size_request_to_display_given_text (automate_button, X_("lngnuf"), 2, 2); +bool +PluginUIWindow::on_focus_in_event (GdkEventFocus *ev) +{ + Window::on_focus_in_event (ev); + //Keyboard::the_keyboard().magic_widget_grab_focus (); + return false; +} - ignore_change = 0; - display = 0; - button = 0; - control = 0; - clickbox = 0; - adjustment = 0; - meterinfo = 0; +bool +PluginUIWindow::on_focus_out_event (GdkEventFocus *ev) +{ + Window::on_focus_out_event (ev); + //Keyboard::the_keyboard().magic_widget_drop_focus (); + return false; } -LadspaPluginUI::ControlUI::~ControlUI() +void +PluginUIWindow::on_show () { - if (adjustment) { - delete adjustment; + set_role("plugin_ui"); + + if (_pluginui) { + _pluginui->update_presets (); } - if (meterinfo) { - delete meterinfo->meter; - delete meterinfo; + if (_pluginui) { + if (_pluginui->on_window_show (_title)) { + Window::on_show (); + } + } + + if (parent) { + // set_transient_for (*parent); } } void -LadspaPluginUI::automation_state_changed (ControlUI* cui) +PluginUIWindow::on_hide () { - /* update button label */ + Window::on_hide (); - switch (insert->get_port_automation_state (cui->port_index) & (Off|Play|Touch|Write)) { - case Off: - cui->automate_button.set_label (_("Off")); - break; - case Play: - cui->automate_button.set_label (_("Play")); - break; - case Write: - cui->automate_button.set_label (_("Write")); - break; - case Touch: - cui->automate_button.set_label (_("Touch")); - break; - default: - cui->automate_button.set_label (_("???")); - break; + if (_pluginui) { + _pluginui->on_window_hide (); } } - -static void integer_printer (char buf[32], Adjustment &adj, void *arg) -{ - snprintf (buf, 32, "%.0f", adj.get_value()); -} - void -LadspaPluginUI::print_parameter (char *buf, uint32_t len, uint32_t param) +PluginUIWindow::set_title(const Glib::ustring& title) { - plugin->print_parameter (param, buf, len); + //cout << "PluginUIWindow::set_title(\"" << title << "\"" << endl; + Gtk::Window::set_title(title); + _title = title; } -LadspaPluginUI::ControlUI* -LadspaPluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, PBD::Controllable* mcontrol) - +bool +#ifdef VST_SUPPORT +PluginUIWindow::create_vst_editor(boost::shared_ptr insert) +#else +PluginUIWindow::create_vst_editor(boost::shared_ptr) +#endif { - 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)) { - - boost::shared_ptr lp; - - if ((lp = boost::dynamic_pointer_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::ComboBoxText; - //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_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_combo_changed), control_ui)); - plugin->ParameterChanged.connect (bind (mem_fun (*this, &LadspaPluginUI::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, &LadspaPluginUI::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); +#ifndef VST_SUPPORT + return false; +#else - /* XXX this code is not right yet, because it doesn't handle - the absence of bounds in any sensible fashion. - */ + boost::shared_ptr vp; - control_ui->adjustment->set_lower (desc.lower); - control_ui->adjustment->set_upper (desc.upper); + 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); - 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; + _pluginui = vpu; + add (*vpu); + vpu->package (*this); + } - 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); + non_gtk_gui = true; + return true; +#endif +} - 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 { - sigc::slot pslot = sigc::bind (mem_fun(*this, &LadspaPluginUI::print_parameter), (uint32_t) port_index); - - control_ui->control = new BarController (*control_ui->adjustment, *mcontrol, pslot); - // should really match the height of the text in the automation button+label - control_ui->control->set_size_request (200, 22); - control_ui->control->set_name (X_("PluginSlider")); - control_ui->control->set_style (BarController::LeftToRight); - control_ui->control->set_use_parent (true); - - control_ui->control->StartGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::start_touch), control_ui)); - control_ui->control->StopGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::stop_touch), control_ui)); - - } +bool +#if defined (HAVE_AUDIOUNITS) && defined (GTKOSX) +PluginUIWindow::create_audiounit_editor (boost::shared_ptr insert) +#else +PluginUIWindow::create_audiounit_editor (boost::shared_ptr) +#endif +{ +#if !defined(HAVE_AUDIOUNITS) || !defined(GTKOSX) + return false; +#else + VBox* box; + _pluginui = create_au_gui (insert, &box); + add (*box); + non_gtk_gui = true; - 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)); - } + extern sigc::signal ApplicationActivationChanged; + ApplicationActivationChanged.connect (sigc::mem_fun (*this, &PluginUIWindow::app_activated)); - /* XXX memory leak: SliderController not destroyed by ControlUI - destructor, and manage() reports object hierarchy - ambiguity. - */ + return true; +#endif +} - control_ui->pack_start (control_ui->label, true, true); - if (desc.integer_step) { - control_ui->pack_start (*control_ui->clickbox, false, false); +void +#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX) +PluginUIWindow::app_activated (bool yn) +#else +PluginUIWindow::app_activated (bool) +#endif +{ +#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 { - control_ui->pack_start (*control_ui->control, false, false); + was_visible = is_visible(); + hide (); + _pluginui->deactivate (); } + } +#endif +} - control_ui->pack_start (control_ui->automate_button, false, false); - control_ui->adjustment->signal_value_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_adjustment_changed), control_ui)); - control_ui->automate_button.signal_clicked().connect (bind (mem_fun(*this, &LadspaPluginUI::astate_clicked), control_ui, (uint32_t) port_index)); - - automation_state_changed (control_ui); - - plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui)); - insert->automation_list (port_index).automation_state_changed.connect - (bind (mem_fun(*this, &LadspaPluginUI::automation_state_changed), control_ui)); - - } else if (plugin->parameter_is_output (port_index)) { - - control_ui->display = manage (new EventBox); - control_ui->display->set_name ("ParameterValueDisplay"); - - control_ui->display_label = manage (new Label); - - control_ui->display_label->set_name ("ParameterValueDisplay"); - - control_ui->display->add (*control_ui->display_label); - Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "-99,99", 2, 2); - - control_ui->display->show_all (); - - /* set up a meter */ - /* TODO: only make a meter if the port is Hinted for it */ - - MeterInfo * info = new MeterInfo(port_index); - control_ui->meterinfo = info; - - info->meter = new FastMeter (5, 100, FastMeter::Vertical); - - info->min_unbound = desc.min_unbound; - info->max_unbound = desc.max_unbound; - - info->min = desc.lower; - info->max = desc.upper; - - control_ui->vbox = manage (new VBox); - control_ui->hbox = manage (new HBox); - - control_ui->label.set_angle(90); - control_ui->hbox->pack_start (control_ui->label, false, false); - control_ui->hbox->pack_start (*info->meter, false, false); - - control_ui->vbox->pack_start (*control_ui->hbox, false, false); - - control_ui->vbox->pack_start (*control_ui->display, false, false); +bool +PluginUIWindow::create_lv2_editor(boost::shared_ptr insert) +{ +#ifndef HAVE_SLV2 + return false; +#else - control_ui->pack_start (*control_ui->vbox); + boost::shared_ptr vp; - control_ui->meterinfo->meter->show_all(); - control_ui->meterinfo->packed = true; - - output_controls.push_back (control_ui); + 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); } - - plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui)); - return control_ui; -} -void -LadspaPluginUI::start_touch (LadspaPluginUI::ControlUI* cui) -{ - insert->automation_list (cui->port_index).start_touch (); + non_gtk_gui = false; + return true; +#endif } -void -LadspaPluginUI::stop_touch (LadspaPluginUI::ControlUI* cui) +bool +PluginUIWindow::on_key_press_event (GdkEventKey* event) { - insert->automation_list (cui->port_index).stop_touch (); + return relay_key_press (event, this); } -void -LadspaPluginUI::astate_clicked (ControlUI* cui, uint32_t port) +bool +PluginUIWindow::on_key_release_event (GdkEventKey *) { - 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, &LadspaPluginUI::set_automation_state), (AutoState) Off, cui))); - items.push_back (MenuElem (_("Play"), - bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Play, cui))); - items.push_back (MenuElem (_("Write"), - bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Write, cui))); - items.push_back (MenuElem (_("Touch"), - bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Touch, cui))); - - automation_menu->popup (1, 0); + return true; } void -LadspaPluginUI::set_automation_state (AutoState state, ControlUI* cui) +PluginUIWindow::plugin_going_away () { - insert->set_port_automation_state (cui->port_index, state); -} + ENSURE_GUI_THREAD (*this, &PluginUIWindow::plugin_going_away) -void -LadspaPluginUI::control_adjustment_changed (ControlUI* cui) -{ - if (cui->ignore_change) { - return; + if (_pluginui) { + _pluginui->stop_updating(0); } - double value = cui->adjustment->get_value(); - - if (cui->logarithmic) { - value = exp(value); - } + death_connection.disconnect (); - insert->set_parameter (cui->port_index, (float) value); + delete_when_idle (this); } -void -LadspaPluginUI::parameter_changed (uint32_t abs_port_id, float val, ControlUI* cui) +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")) { - if (cui->port_index == abs_port_id) { - if (!cui->update_pending) { - cui->update_pending = true; - Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &LadspaPluginUI::update_control_display), cui)); - } - } -} + //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(sigc::mem_fun(*this, &PlugUIBase::setting_selected)); + no_load_preset = false; -void -LadspaPluginUI::update_control_display (ControlUI* cui) -{ - /* XXX how do we handle logarithmic stuff here ? */ - - cui->update_pending = false; + save_button.set_name ("PluginSaveButton"); + save_button.signal_clicked().connect(sigc::mem_fun(*this, &PlugUIBase::save_plugin_setting)); - float val = plugin->get_parameter (cui->port_index); + insert->ActiveChanged.connect (active_connection, boost::bind (&PlugUIBase::processor_active_changed, this, boost::weak_ptr(insert)), gui_context()); - 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) { + bypass_button.set_active (!pi->active()); - if (val > 0.5) { - cui->button->set_active (true); - } else { - cui->button->set_active (false); - } + bypass_button.set_name ("PluginBypassButton"); + bypass_button.signal_toggled().connect (sigc::mem_fun(*this, &PlugUIBase::bypass_toggled)); + focus_button.add_events (Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK); - } else { - if (cui->logarithmic) { - val = log(val); - } - if (val != cui->adjustment->get_value()) { - cui->adjustment->set_value (val); - } - } - cui->ignore_change--; -} + focus_button.signal_button_release_event().connect (sigc::mem_fun(*this, &PlugUIBase::focus_toggled)); + focus_button.add_events (Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK); -void -LadspaPluginUI::control_port_toggled (ControlUI* cui) -{ - if (!cui->ignore_change) { - insert->set_parameter (cui->port_index, cui->button->get_active()); - } -} + /* these images are not managed, so that we can remove them at will */ -void -LadspaPluginUI::control_combo_changed (ControlUI* cui) -{ - 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]); - } + focus_out_image = new Image (get_icon (X_("computer_keyboard"))); + focus_in_image = new Image (get_icon (X_("computer_keyboard_active"))); -} + focus_button.add (*focus_out_image); -void -PluginUIWindow::plugin_going_away (ARDOUR::Redirect* ignored) -{ - ENSURE_GUI_THREAD(bind (mem_fun(*this, &PluginUIWindow::plugin_going_away), ignored)); - - _pluginui->stop_updating(0); - delete_when_idle (this); -} + 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"), ""); -void -LadspaPluginUI::redirect_active_changed (Redirect* r, void* src) -{ - ENSURE_GUI_THREAD(bind (mem_fun(*this, &LadspaPluginUI::redirect_active_changed), r, src)); + plugin_analysis_expander.property_expanded().signal_changed().connect( sigc::mem_fun(*this, &PlugUIBase::toggle_plugin_analysis)); + plugin_analysis_expander.set_expanded(false); - bypass_button.set_active (!r->active()); + insert->DropReferences.connect (death_connection, boost::bind (&PlugUIBase::plugin_going_away, this), gui_context()); } -bool -LadspaPluginUI::start_updating (GdkEventAny* ignored) +PlugUIBase::~PlugUIBase() { - if (output_controls.size() > 0 ) { - screen_update_connection.disconnect(); - screen_update_connection = ARDOUR_UI::instance()->RapidScreenUpdate.connect - (mem_fun(*this, &LadspaPluginUI::output_update)); - } - return false; + delete latency_gui; } -bool -LadspaPluginUI::stop_updating (GdkEventAny* ignored) +void +PlugUIBase::plugin_going_away () { - if (output_controls.size() > 0 ) { - screen_update_connection.disconnect(); - } - return false; + /* drop references to the plugin/insert */ + insert.reset (); + plugin.reset (); + death_connection.disconnect (); } void -LadspaPluginUI::output_update () +PlugUIBase::set_latency_label () { - 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; - } + char buf[64]; + nframes_t l = insert->effective_latency (); + nframes_t sr = insert->session().frame_rate(); - 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 ); - } - } + 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)); } + + latency_label.set_text (buf); } -vector -LadspaPluginUI::setup_scale_values(guint32 port_index, ControlUI* cui) +void +PlugUIBase::latency_button_clicked () { - vector enums; - boost::shared_ptr lp = boost::dynamic_pointer_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); - } - - lrdf_free_setting_values(defaults); + 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 (sigc::mem_fun (*this, &PlugUIBase::set_latency_label)); } - return enums; + latency_dialog->show_all (); } -PlugUIBase::PlugUIBase (boost::shared_ptr pi) - : insert (pi), - plugin (insert->plugin()), - save_button(_("Add")), - bypass_button (_("Bypass")) +void +PlugUIBase::processor_active_changed (boost::weak_ptr weak_p) { - //combo.set_use_arrows_always(true); - set_popdown_strings (combo, plugin->get_presets()); - combo.set_size_request (100, -1); - combo.set_active_text (""); - combo.signal_changed().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)); + ENSURE_GUI_THREAD (*this, &PlugUIBase::processor_active_changed, weak_p) + boost::shared_ptr p (weak_p); + if (p) { + bypass_button.set_active (!p->active()); + } } void PlugUIBase::setting_selected() { - 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 (no_load_preset) { + return; } + 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; + } + } } void @@ -864,20 +495,21 @@ PlugUIBase::save_plugin_setting () 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); prompter.show_all(); + prompter.present (); switch (prompter.run ()) { case Gtk::RESPONSE_ACCEPT: - string name; - prompter.get_result(name); - if (name.length()) { - if(plugin->save_preset(name)){ - set_popdown_strings (combo, plugin->get_presets()); - combo.set_active_text (name); + if (plugin->save_preset(name)) { + update_presets(); + no_load_preset = true; + preset_combo.set_active_text (name); + no_load_preset = false; } } break; @@ -890,7 +522,86 @@ PlugUIBase::bypass_toggled () bool x; if ((x = bypass_button.get_active()) == insert->active()) { - insert->set_active (!x, this); + if (x) { + insert->deactivate (); + } else { + insert->activate (); + } } } +bool +PlugUIBase::focus_toggled (GdkEventButton*) +{ + 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 true; +} + +void +PlugUIBase::toggle_plugin_analysis() +{ + 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(); + } + + Gtk::Widget *gui; + + 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(); + + delete gui; + + Gtk::Widget *toplevel = plugin_analysis_expander.get_toplevel(); + if (!toplevel) { + std::cerr << "No toplevel widget?!?!" << std::endl; + return; + } + + Gtk::Container *cont = dynamic_cast(toplevel); + if (!cont) { + std::cerr << "Toplevel widget is not a container?!?" << std::endl; + return; + } + + Gtk::Allocation alloc(0, 0, 50, 50); // Just make it small + toplevel->size_allocate(alloc); + } +} + +void +PlugUIBase::update_presets () +{ + vector preset_labels; + vector presets = plugin->get_presets(); + + no_load_preset = true; + + for (vector::const_iterator i = presets.begin(); i != presets.end(); ++i) { + preset_labels.push_back(i->label); + } + + set_popdown_strings (preset_combo, preset_labels); + + no_load_preset = false; +}