X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fplugin_ui.cc;h=9be3d50841be6f13296cc6c8ee2fa0358e7da35e;hb=84b4dd94e34afea47dcb6b411215d5b86f112e25;hp=c575a3053ea6118d36dbb78982991f1c2726ccd2;hpb=14b0ca31bcb62e5b7e9e77634ef9cd2e8cf65800;p=ardour.git diff --git a/gtk2_ardour/plugin_ui.cc b/gtk2_ardour/plugin_ui.cc index c575a3053e..9be3d50841 100644 --- a/gtk2_ardour/plugin_ui.cc +++ b/gtk2_ardour/plugin_ui.cc @@ -38,6 +38,7 @@ #include #include #include +#include #include "midi++/manager.h" @@ -47,6 +48,7 @@ #include "ardour/ladspa_plugin.h" #ifdef VST_SUPPORT #include "ardour/vst_plugin.h" +#include "vst_pluginui.h" #endif #ifdef HAVE_SLV2 #include "ardour/lv2_plugin.h" @@ -65,6 +67,7 @@ #include "keyboard.h" #include "latency_gui.h" #include "plugin_eq_gui.h" +#include "new_plugin_preset_dialog.h" #include "i18n.h" @@ -76,10 +79,10 @@ using namespace Gtk; PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptr insert, bool scrollable) : parent (win) + , was_visible (false) + , _keyboard_focused (false) { bool have_gui = false; - non_gtk_gui = false; - was_visible = false; Label* label = manage (new Label()); label->set_markup ("THIS IS THE PLUGIN UI"); @@ -120,6 +123,7 @@ PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptrKeyboardFocused.connect (sigc::mem_fun (*this, &PluginUIWindow::keyboard_focused)); add (*pu); /* @@ -131,7 +135,7 @@ PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptrupdate_presets (); + _pluginui->update_preset_list (); + _pluginui->update_preset (); } if (_pluginui) { @@ -238,9 +243,8 @@ PluginUIWindow::on_hide () } void -PluginUIWindow::set_title(const Glib::ustring& title) +PluginUIWindow::set_title(const std::string& title) { - //cout << "PluginUIWindow::set_title(\"" << title << "\"" << endl; Gtk::Window::set_title(title); _title = title; } @@ -266,45 +270,44 @@ PluginUIWindow::create_vst_editor(boost::shared_ptr) VSTPluginUI* vpu = new VSTPluginUI (insert, vp); _pluginui = vpu; + _pluginui->KeyboardFocused.connect (sigc::mem_fun (*this, &PluginUIWindow::keyboard_focused)); add (*vpu); vpu->package (*this); } - non_gtk_gui = true; return true; #endif } bool -#if defined (HAVE_AUDIOUNITS) && defined (GTKOSX) +#ifdef GTKOSX PluginUIWindow::create_audiounit_editor (boost::shared_ptr insert) #else PluginUIWindow::create_audiounit_editor (boost::shared_ptr) #endif { -#if !defined(HAVE_AUDIOUNITS) || !defined(GTKOSX) +#ifndef GTKOSX return false; #else VBox* box; _pluginui = create_au_gui (insert, &box); + _pluginui->KeyboardFocused.connect (sigc::mem_fun (*this, &PluginUIWindow::keyboard_focused)); add (*box); - non_gtk_gui = true; - extern sigc::signal ApplicationActivationChanged; - ApplicationActivationChanged.connect (sigc::mem_fun (*this, &PluginUIWindow::app_activated)); + Application::instance()->ActivationChanged.connect (mem_fun (*this, &PluginUIWindow::app_activated)); return true; #endif } void -#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX) +#ifdef GTKOSX PluginUIWindow::app_activated (bool yn) #else PluginUIWindow::app_activated (bool) #endif { -#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX) +#ifdef GTKOSX cerr << "APP activated ? " << yn << endl; if (_pluginui) { if (yn) { @@ -341,21 +344,64 @@ PluginUIWindow::create_lv2_editor(boost::shared_ptr insert) lpu->package (*this); } - non_gtk_gui = false; return true; #endif } +void +PluginUIWindow::keyboard_focused (bool yn) +{ + _keyboard_focused = yn; +} + bool PluginUIWindow::on_key_press_event (GdkEventKey* event) { - return relay_key_press (event, this); + if (_keyboard_focused) { + if (_pluginui) { + if (_pluginui->non_gtk_gui()) { + _pluginui->forward_key_event (event); + } else { + return relay_key_press (event, this); + } + } + return true; + } else { + /* for us to be getting key press events, there really + MUST be a _pluginui, but just to be safe, check ... + */ + + if (_pluginui) { + if (_pluginui->non_gtk_gui()) { + /* pass editor window as the window for the event + to be handled in, not this one, because there are + no widgets in this window that we want to have + key focus. + */ + return relay_key_press (event, &PublicEditor::instance()); + } else { + return relay_key_press (event, this); + } + } else { + return false; + } + } } bool -PluginUIWindow::on_key_release_event (GdkEventKey *) +PluginUIWindow::on_key_release_event (GdkEventKey *event) { - return true; + if (_keyboard_focused) { + if (_pluginui) { + if (_pluginui->non_gtk_gui()) { + _pluginui->forward_key_event (event); + } + return true; + } + return false; + } else { + return true; + } } void @@ -375,21 +421,33 @@ PluginUIWindow::plugin_going_away () PlugUIBase::PlugUIBase (boost::shared_ptr pi) : insert (pi), plugin (insert->plugin()), - save_button(_("Add")), + add_button (_("Add")), + save_button (_("Save")), + delete_button (_("Delete")), 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(sigc::mem_fun(*this, &PlugUIBase::setting_selected)); - no_load_preset = false; + _preset_combo.set_size_request (100, -1); + _preset_modified.set_size_request (16, -1); + _preset_combo.signal_changed().connect(sigc::mem_fun(*this, &PlugUIBase::preset_selected)); + _no_load_preset = 0; + + _preset_box.pack_start (_preset_combo); + _preset_box.pack_start (_preset_modified); + + update_preset_list (); + update_preset (); + + add_button.set_name ("PluginAddButton"); + add_button.signal_clicked().connect (sigc::mem_fun (*this, &PlugUIBase::add_plugin_setting)); save_button.set_name ("PluginSaveButton"); save_button.signal_clicked().connect(sigc::mem_fun(*this, &PlugUIBase::save_plugin_setting)); + delete_button.set_name ("PluginDeleteButton"); + delete_button.signal_clicked().connect (sigc::mem_fun (*this, &PlugUIBase::delete_plugin_setting)); + insert->ActiveChanged.connect (active_connection, invalidator (*this), boost::bind (&PlugUIBase::processor_active_changed, this, boost::weak_ptr(insert)), gui_context()); bypass_button.set_active (!pi->active()); @@ -415,6 +473,11 @@ PlugUIBase::PlugUIBase (boost::shared_ptr pi) plugin_analysis_expander.set_expanded(false); insert->DropReferences.connect (death_connection, invalidator (*this), boost::bind (&PlugUIBase::plugin_going_away, this), gui_context()); + + plugin->PresetAdded.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::preset_added_or_removed, this), gui_context ()); + plugin->PresetRemoved.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::preset_added_or_removed, this), gui_context ()); + plugin->PresetLoaded.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::update_preset, this), gui_context ()); + plugin->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&PlugUIBase::parameter_changed, this, _1, _2), gui_context ()); } PlugUIBase::~PlugUIBase() @@ -434,17 +497,18 @@ PlugUIBase::plugin_going_away () void PlugUIBase::set_latency_label () { - char buf[64]; - nframes_t l = insert->effective_latency (); - nframes_t sr = insert->session().frame_rate(); + framecnt_t const l = insert->effective_latency (); + framecnt_t const sr = insert->session().frame_rate (); + + string t; if (l < sr / 1000) { - snprintf (buf, sizeof (buf), "latency (%d samples)", l); + t = string_compose (_("latency (%1 samples)"), l); } else { - snprintf (buf, sizeof (buf), "latency (%.2f msecs)", (float) l / ((float) sr / 1000.0f)); + t = string_compose (_("latency (%1 ms)"), (float) l / ((float) sr / 1000.0f)); } - latency_label.set_text (buf); + latency_label.set_text (t); } void @@ -471,51 +535,63 @@ PlugUIBase::processor_active_changed (boost::weak_ptr weak_p) } void -PlugUIBase::setting_selected() +PlugUIBase::preset_selected () { - if (no_load_preset) { + 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 (_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); + plugin->load_preset (*pr); } else { warning << string_compose(_("Plugin preset %1 not found"), - preset_combo.get_active_text()) << endmsg; + _preset_combo.get_active_text()) << endmsg; } } } void -PlugUIBase::save_plugin_setting () +PlugUIBase::add_plugin_setting () { - 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); - - prompter.show_all(); - prompter.present (); + NewPluginPresetDialog d (plugin); - switch (prompter.run ()) { + switch (d.run ()) { case Gtk::RESPONSE_ACCEPT: - string name; - prompter.get_result(name); - if (name.length()) { - if (plugin->save_preset(name)) { - update_presets(); - no_load_preset = true; - preset_combo.set_active_text (name); - no_load_preset = false; - } + if (d.name().empty()) { + break; + } + + if (d.replace ()) { + plugin->remove_preset (d.name ()); + } + + Plugin::PresetRecord const r = plugin->save_preset (d.name()); + if (!r.uri.empty ()) { + plugin->load_preset (r); } break; } } +void +PlugUIBase::save_plugin_setting () +{ + string const name = _preset_combo.get_active_text (); + plugin->remove_preset (name); + Plugin::PresetRecord const r = plugin->save_preset (name); + if (!r.uri.empty ()) { + plugin->load_preset (r); + } +} + +void +PlugUIBase::delete_plugin_setting () +{ + plugin->remove_preset (_preset_combo.get_active_text ()); +} + void PlugUIBase::bypass_toggled () { @@ -539,12 +615,14 @@ PlugUIBase::focus_toggled (GdkEventButton*) focus_button.add (*focus_out_image); focus_out_image->show (); ARDOUR_UI::instance()->set_tip (focus_button, string_compose (_("Click to allow the plugin to receive keyboard events that %1 would normally use as a shortcut"), PROGRAM_NAME)); + KeyboardFocused (false); } 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, string_compose (_("Click to allow normal use of %1 keyboard shortcuts"), PROGRAM_NAME)); + KeyboardFocused (true); } return true; @@ -590,18 +668,61 @@ PlugUIBase::toggle_plugin_analysis() } void -PlugUIBase::update_presets () +PlugUIBase::update_preset_list () { vector preset_labels; vector presets = plugin->get_presets(); - no_load_preset = true; + ++_no_load_preset; for (vector::const_iterator i = presets.begin(); i != presets.end(); ++i) { - preset_labels.push_back(i->label); + preset_labels.push_back (i->label); } - set_popdown_strings (preset_combo, preset_labels); + set_popdown_strings (_preset_combo, preset_labels); - no_load_preset = false; + --_no_load_preset; +} + +void +PlugUIBase::update_preset () +{ + Plugin::PresetRecord p = plugin->last_preset(); + + ++_no_load_preset; + _preset_combo.set_active_text (p.label); + --_no_load_preset; + + save_button.set_sensitive (!p.uri.empty() && p.user); + delete_button.set_sensitive (!p.uri.empty() && p.user); + + update_preset_modified (); +} + +void +PlugUIBase::update_preset_modified () +{ + if (plugin->last_preset().uri.empty()) { + _preset_modified.set_text (""); + return; + } + + bool const c = plugin->parameter_changed_since_last_preset (); + if (_preset_modified.get_text().empty() == c) { + _preset_modified.set_text (c ? "*" : ""); + } +} + +void +PlugUIBase::parameter_changed (uint32_t, float) +{ + update_preset_modified (); +} + +void +PlugUIBase::preset_added_or_removed () +{ + /* Update both the list and the currently-displayed preset */ + update_preset_list (); + update_preset (); }