diff --git a/gtk2_ardour/luainstance.cc b/gtk2_ardour/luainstance.cc index 7e38443e78..6d853ebeb8 100644 --- a/gtk2_ardour/luainstance.cc +++ b/gtk2_ardour/luainstance.cc @@ -826,6 +826,8 @@ LuaInstance::register_classes (lua_State* L, bool sandbox) .endClass () .deriveClass ("RegionView") + .addFunction ("show_region_editor", &RegionView::show_region_editor) + .addFunction ("hide_region_editor", &RegionView::hide_region_editor) .endClass () .deriveClass ("RouteUI") diff --git a/gtk2_ardour/region_editor.cc b/gtk2_ardour/region_editor.cc index ba5fb5a52f..9869e5e547 100644 --- a/gtk2_ardour/region_editor.cc +++ b/gtk2_ardour/region_editor.cc @@ -28,18 +28,31 @@ #include "pbd/memento_command.h" #include "pbd/stateful_diff_command.h" +#include "pbd/unwind.h" + +#include "gtkmm2ext/dndtreeview.h" #include "widgets/tooltips.h" +#include "ardour/plugin_manager.h" #include "ardour/region.h" +#include "ardour/region_fx_plugin.h" #include "ardour/session.h" #include "ardour/source.h" +#include "ardour_message.h" #include "ardour_ui.h" #include "clock_group.h" -#include "main_clock.h" +#include "context_menu_helper.h" #include "gui_thread.h" +#include "keyboard.h" +#include "main_clock.h" +#include "mixer_ui.h" +#include "new_plugin_preset_dialog.h" #include "region_editor.h" +#include "region_view.h" +#include "plugin_selector.h" +#include "plugin_window_proxy.h" #include "public_editor.h" #include "pbd/i18n.h" @@ -51,7 +64,7 @@ using namespace Gtkmm2ext; RegionEditor::RegionEditor (Session* s, std::shared_ptr r) : ArdourDialog (_("Region")) - , _table (9, 2) + , _table (9, 3) , _table_row (0) , _region (r) , name_label (_("Name:")) @@ -64,6 +77,7 @@ RegionEditor::RegionEditor (Session* s, std::shared_ptr r) , sync_offset_absolute_clock (X_("regionsyncoffsetabsolute"), true, "", true, false) /* XXX cannot file start yet */ , start_clock (X_("regionstart"), true, "", false, false) + , _region_fx_box (r) , _sources (1) { set_session (s); @@ -113,6 +127,8 @@ RegionEditor::RegionEditor (Session* s, std::shared_ptr r) start_label.set_name ("RegionEditorLabel"); start_label.set_text (_("File start:")); _sources_label.set_name ("RegionEditorLabel"); + region_fx_label.set_text (_("Region Effects")); + region_fx_label.set_name ("RegionEditorLabel"); if (_region->sources().size() > 1) { _sources_label.set_text (_("Sources:")); @@ -170,6 +186,9 @@ RegionEditor::RegionEditor (Session* s, std::shared_ptr r) _table.attach (_sources, 1, 2, _table_row, _table_row + 1, Gtk::FILL | Gtk::EXPAND, Gtk::FILL); ++_table_row; + _table.attach (region_fx_label, 2, 3, 0, 1, Gtk::FILL, Gtk::FILL); + _table.attach (_region_fx_box, 2, 3, 1, _table_row + 2, Gtk::FILL, Gtk::FILL); + get_vbox()->pack_start (_table, true, true); add_button (Gtk::Stock::CLOSE, Gtk::RESPONSE_ACCEPT); @@ -190,6 +209,9 @@ RegionEditor::RegionEditor (Session* s, std::shared_ptr r) assert (t); t->property_ellipsize() = Pango::ELLIPSIZE_END; + region_fx_label.set_no_show_all (); + _region_fx_box.set_no_show_all (); + show_all(); name_changed (); @@ -203,9 +225,16 @@ RegionEditor::RegionEditor (Session* s, std::shared_ptr r) bounds_changed (change); _region->PropertyChanged.connect (state_connection, invalidator (*this), boost::bind (&RegionEditor::region_changed, this, _1), gui_context()); + _region->RegionFxChanged.connect (region_connection, invalidator (*this), boost::bind (&RegionEditor::region_fx_changed, this), gui_context ()); spin_arrow_grab = false; + /* for now only audio region effects are supported */ + if (std::dynamic_pointer_cast (_region)) { + region_fx_label.show (); + _region_fx_box.show (); + } + connect_editor_events (); } @@ -238,6 +267,12 @@ RegionEditor::region_changed (const PBD::PropertyChange& what_changed) } } +void +RegionEditor::region_fx_changed () +{ + _region_fx_box.redisplay_plugins (); +} + gint RegionEditor::bpressed (GdkEventButton* ev, Gtk::SpinButton* /*but*/, void (RegionEditor::*/*pmf*/)()) { @@ -469,3 +504,541 @@ RegionEditor::handle_response (int) { hide (); } + +/* ****************************************************************************/ + +static std::list +drop_targets () +{ + std::list tmp; + tmp.push_back (Gtk::TargetEntry ("x-ardour/region-fx", Gtk::TARGET_SAME_APP)); // re-order + tmp.push_back (Gtk::TargetEntry ("x-ardour/plugin.info", Gtk::TARGET_SAME_APP)); // from plugin-manager + tmp.push_back (Gtk::TargetEntry ("x-ardour/plugin.favorite", Gtk::TARGET_SAME_APP)); // from sidebar + return tmp; +} + +static std::list +drag_targets () +{ + std::list tmp; + tmp.push_back (Gtk::TargetEntry ("x-ardour/region-fx", Gtk::TARGET_SAME_APP)); // re-order + tmp.push_back (Gtk::TargetEntry ("x-ardour/plugin.preset", Gtk::TARGET_SAME_APP)); // to sidebar (optional preset) + return tmp; +} + +RegionEditor::RegionFxBox::RegionFxBox (std::shared_ptr r) + : _region (r) + , _display (drop_targets ()) + , _no_redisplay (false) + , _placement (-1) +{ + _scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC); + _scroller.set_name ("ProcessorScroller"); + _scroller.add (_display); + pack_start (_scroller, true, true); + + _display.set_can_focus (); + _display.set_name ("ProcessorList"); + _display.set_data ("regionfxbox", this); + _display.set_size_request (104, -1); // TODO UI scale + _display.set_spacing (0); + + _display.ButtonPress.connect (sigc::mem_fun (*this, &RegionFxBox::fxe_button_press_event)); + _display.ButtonRelease.connect (sigc::mem_fun (*this, &RegionFxBox::fxe_button_release_event)); + + _display.Reordered.connect (sigc::mem_fun (*this, &RegionFxBox::reordered)); + _display.DropFromAnotherBox.connect (sigc::mem_fun (*this, &RegionFxBox::object_drop)); + _display.DropFromExternal.connect (sigc::mem_fun (*this, &RegionFxBox::plugin_drop)); + + _display.signal_key_press_event ().connect (sigc::mem_fun (*this, &RegionFxBox::on_key_press), false); + + _scroller.show (); + _display.show (); + + redisplay_plugins (); +} + +bool +RegionEditor::RegionFxBox::use_plugins (SelectedPlugins const& plugins) +{ + int errors = 0; + { + PBD::Unwinder uw (_no_redisplay, true); + for (auto const& p : plugins) { + std::shared_ptr pos; + if (_placement >= 0) { + pos = _region->nth_plugin (_placement++); + } + if (!_region->add_plugin (std::shared_ptr (new RegionFxPlugin (_region->session (), _region->time_domain (), p)), pos)) { + ++errors; + } + } + } + redisplay_plugins (); + if (errors) { + notify_plugin_load_fail (errors); + } + return false; +} + +void +RegionEditor::RegionFxBox::redisplay_plugins () +{ + if (_no_redisplay) { + return; + } + _display.clear (); + _region->foreach_plugin (sigc::mem_fun (*this, &RegionFxBox::add_fx_to_display)); +} + +void +RegionEditor::RegionFxBox::add_fx_to_display (std::weak_ptr wfx) +{ + std::shared_ptr fx (wfx.lock ()); + if (!fx) { + return; + } + RegionFxEntry* e = new RegionFxEntry (fx); + _display.add_child (e, drag_targets ()); +} + +bool +RegionEditor::RegionFxBox::fxe_button_press_event (GdkEventButton* ev, RegionFxEntry* child) +{ + if (child) { + std::weak_ptr wfx (std::weak_ptr (child->region_fx_plugin ())); + + if (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS)) { + if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) { + show_plugin_gui (wfx, false); + } else { + show_plugin_gui (wfx, true); + } + return true; + } + + if (Keyboard::is_context_menu_event (ev)) { + using namespace Gtk::Menu_Helpers; + + PluginSelector* ps = Mixer_UI::instance ()->plugin_selector (); + ps->set_interested_object (*this); + + Gtk::Menu* m = ARDOUR_UI_UTILS::shared_popup_menu (); + MenuList& items = m->items (); + + items.push_back (MenuElem (_("New Plugin"))); + Gtk::MenuItem& npm = items.back (); + npm.set_submenu (*ps->plugin_menu ()); + + std::shared_ptr plugin = child->region_fx_plugin ()->plugin (); + + items.push_back (SeparatorElem ()); + items.push_back (MenuElem (_("Edit..."), sigc::bind (sigc::mem_fun (*this, &RegionFxBox::show_plugin_gui), wfx, true))); + items.back ().set_sensitive (plugin->has_editor ()); + items.push_back (MenuElem (_("Edit with generic controls..."), sigc::bind (sigc::mem_fun (*this, &RegionFxBox::show_plugin_gui), wfx, false))); + + Gtk::Menu* automation_menu = manage (new Gtk::Menu); + MenuList& ac_items (automation_menu->items ()); + + for (size_t i = 0; i < plugin->parameter_count (); ++i) { + if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) { + continue; + } + const Evoral::Parameter param (PluginAutomation, 0, i); + std::string label = plugin->describe_parameter (param); + if (label == X_("latency") || label == X_("hidden")) { + continue; + } + std::shared_ptr c (std::dynamic_pointer_cast (child->region_fx_plugin ()->control (param))); + if (c && c->flags () & (Controllable::HiddenControl | Controllable::NotAutomatable)) { + continue; + } + + std::weak_ptr wac (c); + bool play = c->automation_state () == Play; + + ac_items.push_back (CheckMenuElem (label)); + Gtk::CheckMenuItem* cmi = static_cast (&ac_items.back ()); + cmi->set_active (play); + cmi->signal_activate ().connect ([wac, play] () { + std::shared_ptr ac = wac.lock (); + if (ac) { + ac->set_automation_state (play ? ARDOUR::Off : Play); + } + }); + } + + if (!ac_items.empty ()) { + items.push_back (SeparatorElem ()); + items.push_back (MenuElem ("Automation Enable", *automation_menu)); + } else { + delete automation_menu; + } + + items.push_back (SeparatorElem ()); + items.push_back (MenuElem (_("Delete"), sigc::bind (sigc::mem_fun (*this, &RegionFxBox::queue_delete_region_fx), wfx))); + + m->signal_unmap ().connect ([this, &npm] () { npm.remove_submenu (); _display.remove_placeholder (); }); + m->popup (ev->button, ev->time); + + int x, y; + _display.get_pointer (x, y); + _placement = _display.add_placeholder (y); + return true; + } + return false; + } + + if (Keyboard::is_context_menu_event (ev)) { + _placement = -1; + using namespace Gtk::Menu_Helpers; + + PluginSelector* ps = Mixer_UI::instance ()->plugin_selector (); + ps->set_interested_object (*this); + + Gtk::Menu* m = ARDOUR_UI_UTILS::shared_popup_menu (); + MenuList& items = m->items (); + + items.push_back (MenuElem (_("New Plugin"))); + Gtk::MenuItem& npm = items.back (); + npm.set_submenu (*ps->plugin_menu ()); + + m->signal_unmap ().connect ([&npm] () { npm.remove_submenu (); }); + m->popup (ev->button, ev->time); + return true; + } else if (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS) { + _placement = -1; + PluginSelector* ps = Mixer_UI::instance ()->plugin_selector (); + ps->set_interested_object (*this); + ps->show_manager (); + return true; + } + + return false; +} + +bool +RegionEditor::RegionFxBox::fxe_button_release_event (GdkEventButton* ev, RegionFxEntry* child) +{ + if (child && Keyboard::is_delete_event (ev)) { + queue_delete_region_fx (std::weak_ptr (child->region_fx_plugin ())); + } + return false; +} + +bool +RegionEditor::RegionFxBox::on_key_press (GdkEventKey* ev) +{ + switch (ev->keyval) { + case GDK_KEY_Delete: + break; + case GDK_KEY_BackSpace: + break; + default: + return false; + } + for (auto const& i : _display.selection (true)) { + queue_delete_region_fx (std::weak_ptr (i->region_fx_plugin ())); + } + return true; +} + +void +RegionEditor::RegionFxBox::reordered () +{ + Region::RegionFxList fxl; + for (auto const& i : _display.children ()) { + fxl.push_back (i->region_fx_plugin ()); + } + _region->reorder_plugins (fxl); +} + +void +RegionEditor::RegionFxBox::queue_delete_region_fx (std::weak_ptr wfx) +{ + Glib::signal_idle ().connect (sigc::bind (sigc::mem_fun (*this, &RegionFxBox::idle_delete_region_fx), wfx)); +} + +bool +RegionEditor::RegionFxBox::idle_delete_region_fx (std::weak_ptr wfx) +{ + std::shared_ptr fx (wfx.lock ()); + if (!fx) { + return false; + } + _region->remove_plugin (fx); + return false; +} + +void +RegionEditor::RegionFxBox::notify_plugin_load_fail (uint32_t cnt) +{ + assert (cnt > 0); + ArdourMessageDialog (_("Failed to load Region Effect Plugin"), false, Gtk::MESSAGE_ERROR).run (); +} + +std::shared_ptr +RegionEditor::RegionFxBox::find_drop_position (RegionFxEntry* pos) +{ + std::shared_ptr rv; + if (pos) { + rv = pos->region_fx_plugin (); + if (!rv) { + rv = _display.children ().front ()->region_fx_plugin (); + } + } + return rv; +} + +void +RegionEditor::RegionFxBox::plugin_drop (Gtk::SelectionData const& data, RegionFxEntry* pos, Glib::RefPtr const& context) +{ + uint32_t errors = 0; + std::shared_ptr at = find_drop_position (pos); + if (data.get_target () == "x-ardour/plugin.info") { + const void* d = data.get_data (); + const Gtkmm2ext::DnDTreeView* tv = reinterpret_cast*> (d); + PluginInfoList nfos; + Gtk::TreeView* source; + tv->get_object_drag_data (nfos, &source); + for (auto const& i : nfos) { + PluginPtr p = (i)->load (_region->session ()); + if (!_region->add_plugin (std::shared_ptr (new RegionFxPlugin (_region->session (), _region->time_domain (), p)), at)) { + ++errors; + } + } + } else if (data.get_target () == "x-ardour/plugin.favorite") { + const void* d = data.get_data (); + const Gtkmm2ext::DnDTreeView* tv = reinterpret_cast*> (d); + + PluginPresetList nfos; + Gtk::TreeView* source; + tv->get_object_drag_data (nfos, &source); + for (auto const& i : nfos) { + PluginPresetPtr ppp (i); + PluginInfoPtr pip = ppp->_pip; + PluginPtr p = pip->load (_region->session ()); + if (!p) { + continue; + } + if (ppp->_preset.valid) { + p->load_preset (ppp->_preset); + } + if (!_region->add_plugin (std::shared_ptr (new RegionFxPlugin (_region->session (), _region->time_domain (), p)), at)) { + ++errors; + } + } + } + if (errors) { + notify_plugin_load_fail (errors); + } +} + +void +RegionEditor::RegionFxBox::delete_dragged_plugins (Region::RegionFxList const& fxl) +{ + { + PBD::Unwinder uw (_no_redisplay, true); + for (auto const& fx : fxl) { + _region->remove_plugin (fx); + } + } + redisplay_plugins (); +} + +void +RegionEditor::RegionFxBox::object_drop (Gtkmm2ext::DnDVBox* source, RegionFxEntry* pos, Glib::RefPtr const& context) +{ + if (Gdk::ACTION_LINK == context->get_selected_action ()) { + std::list children = source->selection (); + assert (children.size () == 1); + RegionFxEntry* other = *children.begin (); + assert (other->can_copy_state (pos)); + std::shared_ptr othr = other->region_fx_plugin (); + std::shared_ptr self = pos->region_fx_plugin (); + + PBD::ID id = self->id (); + XMLNode& state = othr->get_state (); + state.remove_property ("count"); + + /* Controllable and automation IDs should not be copied */ + PBD::Stateful::ForceIDRegeneration force_ids; + self->set_state (state, Stateful::current_state_version); + self->update_id (id); + return; + } + + std::shared_ptr at = find_drop_position (pos); + uint32_t errors = 0; + + Region::RegionFxList fxl; + for (auto const& i : source->selection (true)) { + fxl.push_back (i->region_fx_plugin ()); + } + + for (auto const& i : fxl) { + XMLNode& state = i->get_state (); + state.remove_property ("count"); + PBD::Stateful::ForceIDRegeneration force_ids; + std::shared_ptr rfx (new RegionFxPlugin (_region->session (), _region->time_domain ())); + rfx->set_state (state, Stateful::current_state_version); + if (!_region->add_plugin (rfx, at)) { + ++errors; + } + delete &state; + } + + if ((context->get_suggested_action () == Gdk::ACTION_MOVE) && source) { + RegionFxBox* other = reinterpret_cast (source->get_data ("regionfxbox")); + if (other) { + other->delete_dragged_plugins (fxl); + } + } + if (errors) { + notify_plugin_load_fail (errors); + } +} + +void +RegionEditor::RegionFxBox::show_plugin_gui (std::weak_ptr wfx, bool custom_ui) +{ + std::shared_ptr rfx (wfx.lock ()); + if (!rfx) { + return; + } + + PluginWindowProxy* pwp; + + if (rfx->window_proxy ()) { + pwp = dynamic_cast (rfx->window_proxy ()); + } else { + pwp = new PluginWindowProxy (string_compose ("RFX-%1", rfx->id ()), _region->name (), rfx); + + const XMLNode* ui_xml = rfx->session ().extra_xml (X_("UI")); + if (ui_xml) { + pwp->set_state (*ui_xml, 0); + } + + rfx->set_window_proxy (pwp); + WM::Manager::instance ().register_window (pwp); + RegionView* rv = PublicEditor::instance ().regionview_from_region (_region); + rv->RegionViewGoingAway.connect_same_thread (*pwp, [pwp] (RegionView*) { pwp->hide (); }); + } + + pwp->set_custom_ui_mode (custom_ui); + pwp->show_the_right_window (); + + Gtk::Window* tlw = PublicEditor::instance ().current_toplevel (); + if (tlw) { + pwp->set_transient_for (*tlw); + } +} + +/* ****************************************************************************/ + +RegionEditor::RegionFxEntry::RegionFxEntry (std::shared_ptr rfx) + : _fx_btn (ArdourWidgets::ArdourButton::default_elements) + , _rfx (rfx) +{ + _box.pack_start (_fx_btn, true, true); + + _plugin_preset_pointer = PluginPresetPtr (new PluginPreset (rfx->plugin ()->get_info ())); + + _fx_btn.set_fallthrough_to_parent (true); + _fx_btn.set_text (name ()); + _fx_btn.set_active (true); + _fx_btn.set_name ("processor postfader"); + + if (rfx->plugin ()->has_editor ()) { + set_tooltip (_fx_btn, string_compose (_("%1\nDouble-click to show GUI.\n%2+double-click to show generic GUI."), name (), Keyboard::secondary_modifier_name ())); + } else { + set_tooltip (_fx_btn, string_compose (_("%1\nDouble-click to show generic GUI."), name ())); + } + + _box.show (); + _fx_btn.show (); +} + +std::string +RegionEditor::RegionFxEntry::name () const +{ + return _rfx->name (); +} + +bool +RegionEditor::RegionFxEntry::can_copy_state (Gtkmm2ext::DnDVBoxChild* o) const +{ + RegionFxEntry* other = dynamic_cast (o); + if (!other) { + return false; + } + std::shared_ptr othr = other->region_fx_plugin (); + std::shared_ptr self = region_fx_plugin (); + + if (self->type () != othr->type ()) { + return false; + } + std::shared_ptr my_p = self->plugin (); + std::shared_ptr ot_p = othr->plugin (); + return my_p->unique_id () == ot_p->unique_id (); +} + +void +RegionEditor::RegionFxEntry::set_visual_state (Gtkmm2ext::VisualState s, bool yn) +{ + if (yn) { + _fx_btn.set_visual_state (Gtkmm2ext::VisualState (_fx_btn.visual_state () | s)); + } else { + _fx_btn.set_visual_state (Gtkmm2ext::VisualState (_fx_btn.visual_state () & ~s)); + } +} + +bool +RegionEditor::RegionFxEntry::drag_data_get (Glib::RefPtr const, Gtk::SelectionData& data) +{ + /* compare to ProcessorEntry::drag_data_get */ + if (data.get_target () != "x-ardour/plugin.preset") { + return false; + } + + std::shared_ptr plugin = _rfx->plugin (); + assert (plugin); + + PluginManager& manager (PluginManager::instance ()); + bool fav = manager.get_status (_plugin_preset_pointer->_pip) == PluginManager::Favorite; + + NewPluginPresetDialog d (plugin, string_compose (_("New Favorite Preset for \"%1\""), _plugin_preset_pointer->_pip->name), !fav); + + _plugin_preset_pointer->_preset.valid = false; + + switch (d.run ()) { + default: + case Gtk::RESPONSE_CANCEL: + data.set (data.get_target (), 8, NULL, 0); + return true; + break; + + case Gtk::RESPONSE_NO: + break; + + case Gtk::RESPONSE_ACCEPT: + 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_preset_pointer->_preset.uri = r.uri; + _plugin_preset_pointer->_preset.label = r.label; + _plugin_preset_pointer->_preset.user = r.user; + _plugin_preset_pointer->_preset.valid = r.valid; + } + } + data.set (data.get_target (), 8, (const guchar*)&_plugin_preset_pointer, sizeof (PluginPresetPtr)); + return true; +} diff --git a/gtk2_ardour/region_editor.h b/gtk2_ardour/region_editor.h index 6c19797c8c..2e422bfc39 100644 --- a/gtk2_ardour/region_editor.h +++ b/gtk2_ardour/region_editor.h @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -36,17 +37,22 @@ #include #include #include +#include +#include "gtkmm2ext/dndtreeview.h" +#include "gtkmm2ext/dndvbox.h" #include "pbd/signals.h" #include "audio_clock.h" #include "ardour_dialog.h" +#include "plugin_interest.h" #include "region_editor.h" namespace ARDOUR { class Region; class Session; + class RegionFxPlugin; } class ClockGroup; @@ -59,11 +65,71 @@ public: protected: virtual void region_changed (const PBD::PropertyChange&); + virtual void region_fx_changed (); Gtk::Table _table; int _table_row; private: + class RegionFxEntry : public Gtkmm2ext::DnDVBoxChild, public sigc::trackable + { + public: + RegionFxEntry (std::shared_ptr); + + Gtk::EventBox& action_widget () { return _fx_btn; } + Gtk::Widget& widget () { return _box; } + std::string drag_text () const { return name (); } + bool is_selectable() const { return true; } + bool can_copy_state (Gtkmm2ext::DnDVBoxChild*) const; + void set_visual_state (Gtkmm2ext::VisualState, bool); + bool drag_data_get (Glib::RefPtr const, Gtk::SelectionData &); + std::shared_ptr region_fx_plugin () const { return _rfx; } + + private: + std::string name () const; + + Gtk::VBox _box; + ArdourWidgets::ArdourButton _fx_btn; + std::shared_ptr _rfx; + ARDOUR::PluginPresetPtr _plugin_preset_pointer; + }; + + class RegionFxBox : public Gtk::VBox, public PluginInterestedObject //, public ARDOUR::SessionHandlePtr + { + public: + RegionFxBox (std::shared_ptr); + void redisplay_plugins (); + + private: + void add_fx_to_display (std::weak_ptr); + void show_plugin_gui (std::weak_ptr, bool custom_ui = true); + void queue_delete_region_fx (std::weak_ptr); + bool idle_delete_region_fx (std::weak_ptr); + void notify_plugin_load_fail (uint32_t cnt = 1); + bool on_key_press (GdkEventKey*); + + /* PluginInterestedObject */ + bool use_plugins (SelectedPlugins const&); + + /* DNDVbox signal handlers */ + bool fxe_button_press_event (GdkEventButton*, RegionFxEntry*); + bool fxe_button_release_event (GdkEventButton*, RegionFxEntry*); + + void reordered (); + void plugin_drop (Gtk::SelectionData const&, RegionFxEntry*, Glib::RefPtr const&); + void object_drop (Gtkmm2ext::DnDVBox*, RegionFxEntry*, Glib::RefPtr const&); + void delete_dragged_plugins (std::list> const&); + + std::shared_ptr find_drop_position (RegionFxEntry*); + + std::shared_ptr _region; + Gtkmm2ext::DnDVBox _display; + Gtk::ScrolledWindow _scroller; + Gtk::EventBox _base; + bool _no_redisplay; + int _placement; + }; + std::shared_ptr _region; void connect_editor_events (); @@ -78,6 +144,7 @@ private: Gtk::Label sync_relative_label; Gtk::Label sync_absolute_label; Gtk::Label start_label; + Gtk::Label region_fx_label; ClockGroup* _clock_group; @@ -88,8 +155,11 @@ private: AudioClock sync_offset_absolute_clock; ///< sync offset relative to the start of the timeline AudioClock start_clock; + RegionFxBox _region_fx_box; + PBD::ScopedConnection state_connection; PBD::ScopedConnection audition_connection; + PBD::ScopedConnection region_connection; void bounds_changed (const PBD::PropertyChange&); void name_changed (); diff --git a/gtk2_ardour/region_view.cc b/gtk2_ardour/region_view.cc index f0e43bf43a..41687de03f 100644 --- a/gtk2_ardour/region_view.cc +++ b/gtk2_ardour/region_view.cc @@ -237,6 +237,7 @@ RegionView::init (bool wfd) //set_height (trackview.current_height()); _region->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&RegionView::region_changed, this, _1), gui_context()); + _region->RegionFxChanged.connect (*this, invalidator (*this), boost::bind (&RegionView::region_renamed, this), gui_context()); /* derived class calls set_colors () including RegionView::set_colors() in ::init() */ //set_colors (); @@ -791,6 +792,9 @@ RegionView::make_name () const if (_region->muted()) { str = std::string(u8"\U0001F507") + str; // SPEAKER WITH CANCELLATION STROKE } + if (_region->has_region_fx()) { + str = str + " (Fx)"; + } return str; }