Glib::RefPtr<Gdk::Pixbuf> SendProcessorEntry::_slider;
ProcessorEntry::ProcessorEntry (boost::shared_ptr<Processor> p, Width w)
- : _position (PreFader)
+ : _button (ArdourButton::led_default_elements)
+ , _position (PreFader)
, _processor (p)
, _width (w)
, _visual_state (Gtk::STATE_NORMAL)
_vbox.show ();
if (_processor->active()) {
- _button.set_active_state (CairoWidget::Active);
+ _button.set_active_state (Gtkmm2ext::Active);
}
_button.set_diameter (3);
- _button.signal_clicked.connect (sigc::mem_fun (*this, &ProcessorEntry::led_clicked));
- _button.set_text (name());
+ _button.set_distinct_led_click (true);
_button.set_led_left (true);
+ _button.signal_led_clicked.connect (sigc::mem_fun (*this, &ProcessorEntry::led_clicked));
+ _button.set_text (name (_width));
_button.show ();
_processor->ActiveChanged.connect (active_connection, invalidator (*this), boost::bind (&ProcessorEntry::processor_active_changed, this), gui_context());
_processor->PropertyChanged.connect (name_connection, invalidator (*this), ui_bind (&ProcessorEntry::processor_property_changed, this, _1), gui_context());
+ setup_tooltip ();
setup_visuals ();
}
string
ProcessorEntry::drag_text () const
{
- return name ();
+ return name (Wide);
}
void
}
void
-ProcessorEntry::set_visual_state (Gtk::StateType t)
+ProcessorEntry::set_visual_state (Gtkmm2ext::VisualState s, bool yn)
{
- /* map from GTK state to CairoWidget */
-
- switch (t) {
- case Gtk::STATE_ACTIVE:
- _button.set_active_state (CairoWidget::Active);
- _button.unset_visual_state ();
- break;
-
- case Gtk::STATE_SELECTED:
- _button.set_visual_state (CairoWidget::Selected);
- break;
-
- case Gtk::STATE_NORMAL:
- default:
- _button.unset_visual_state ();
- _button.unset_active_state ();
- break;
+ if (yn) {
+ _button.set_visual_state (Gtkmm2ext::VisualState (_button.visual_state() | s));
+ } else {
+ _button.set_visual_state (Gtkmm2ext::VisualState (_button.visual_state() & ~s));
}
}
void
ProcessorEntry::led_clicked()
{
- if (!_processor->active ()) {
- _processor->activate ();
- } else {
+ if (_button.active_state() == Gtkmm2ext::Active) {
_processor->deactivate ();
+ } else {
+ _processor->activate ();
}
}
ProcessorEntry::processor_active_changed ()
{
if (_processor->active()) {
- _button.set_active_state (CairoWidget::Active);
+ _button.set_active_state (Gtkmm2ext::Active);
} else {
_button.unset_active_state ();
}
ProcessorEntry::processor_property_changed (const PropertyChange& what_changed)
{
if (what_changed.contains (ARDOUR::Properties::name)) {
- _button.set_text (name ());
+ _button.set_text (name (_width));
+ setup_tooltip ();
}
}
+void
+ProcessorEntry::setup_tooltip ()
+{
+ ARDOUR_UI::instance()->set_tip (_button, name (Wide));
+}
+
string
-ProcessorEntry::name () const
+ProcessorEntry::name (Width w) const
{
boost::shared_ptr<Send> send;
string name_display;
lbracket = send->name().find ('[');
rbracket = send->name().find (']');
- switch (_width) {
+ switch (w) {
case Wide:
name_display += send->name().substr (lbracket+1, lbracket-rbracket-1);
break;
} else {
- switch (_width) {
+ switch (w) {
case Wide:
name_display += _processor->display_name();
break;
}
ProcessorBox::ProcessorBox (ARDOUR::Session* sess, boost::function<PluginSelector*()> get_plugin_selector,
- RouteRedirectSelection& rsel, MixerStrip* parent, bool owner_is_mixer)
+ RouteProcessorSelection& rsel, MixerStrip* parent, bool owner_is_mixer)
: _parent_strip (parent)
, _owner_is_mixer (owner_is_mixer)
, ab_direction (true)
_width = Wide;
processor_menu = 0;
- send_action_menu = 0;
no_processor_redisplay = false;
processor_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
processor_display.signal_enter_notify_event().connect (sigc::mem_fun(*this, &ProcessorBox::enter_notify), false);
processor_display.signal_leave_notify_event().connect (sigc::mem_fun(*this, &ProcessorBox::leave_notify), false);
- processor_display.signal_key_press_event().connect (sigc::mem_fun(*this, &ProcessorBox::processor_key_press_event));
- processor_display.signal_key_release_event().connect (sigc::mem_fun(*this, &ProcessorBox::processor_key_release_event));
-
processor_display.ButtonPress.connect (sigc::mem_fun (*this, &ProcessorBox::processor_button_press_event));
processor_display.ButtonRelease.connect (sigc::mem_fun (*this, &ProcessorBox::processor_button_release_event));
processor_display.Reordered.connect (sigc::mem_fun (*this, &ProcessorBox::reordered));
processor_display.DropFromAnotherBox.connect (sigc::mem_fun (*this, &ProcessorBox::object_drop));
- processor_display.SelectionChanged.connect (sigc::mem_fun (*this, &ProcessorBox::selection_changed));
processor_scroller.show ();
processor_display.show ();
ProcessorBox::~ProcessorBox ()
{
+ delete processor_menu;
}
void
if ((context->get_suggested_action() == Gdk::ACTION_MOVE) && source) {
ProcessorBox* other = reinterpret_cast<ProcessorBox*> (source->get_data ("processorbox"));
if (other) {
- cerr << "source was another processor box, delete the selected items\n";
other->delete_dragged_processors (procs);
}
}
redisplay_processors ();
}
-void
-ProcessorBox::build_send_action_menu ()
-{
- using namespace Menu_Helpers;
-
- send_action_menu = new Menu;
- send_action_menu->set_name ("ArdourContextMenu");
- MenuList& items = send_action_menu->items();
-
- items.push_back (MenuElem (_("New send"), sigc::mem_fun(*this, &ProcessorBox::new_send)));
- items.push_back (MenuElem (_("Show send controls"), sigc::mem_fun(*this, &ProcessorBox::show_send_controls)));
-}
-
Gtk::Menu*
ProcessorBox::build_possible_aux_menu ()
{
processor_menu->signal_unmap().connect (sigc::mem_fun (*this, &ProcessorBox::processor_menu_unmapped));
}
+ /* Sort out the plugin submenu */
+
Gtk::MenuItem* plugin_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/newplugin"));
if (plugin_menu_item) {
plugin_menu_item->set_submenu (*_get_plugin_selector()->plugin_menu());
}
+ /* And the aux submenu */
+
Gtk::MenuItem* aux_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/ProcessorMenu/newaux"));
if (aux_menu_item) {
}
}
+ /* Sensitise actions as approprioate */
+
cut_action->set_sensitive (can_cut());
paste_action->set_sensitive (!_rr_selection.processors.empty());
+ const bool sensitive = !processor_display.selection().empty();
+ ActionManager::set_sensitive (ActionManager::plugin_selection_sensitive_actions, sensitive);
+ edit_action->set_sensitive (one_processor_can_be_edited ());
+
+ boost::shared_ptr<Processor> single_selection;
+ if (processor_display.selection().size() == 1) {
+ single_selection = processor_display.selection().front()->processor ();
+ }
+
+ boost::shared_ptr<PluginInsert> pi;
+ if (single_selection) {
+ pi = boost::dynamic_pointer_cast<PluginInsert> (single_selection);
+ }
+
+ /* enable gui for plugin inserts with editors */
+ controls_action->set_sensitive(pi && pi->plugin()->has_editor());
+
+ /* disallow rename for multiple selections, for plugin inserts and for the fader */
+ rename_action->set_sensitive (single_selection && !pi && !boost::dynamic_pointer_cast<Amp> (single_selection));
+
processor_menu->popup (1, arg);
/* Add a placeholder gap to the processor list to indicate where a processor would be
ProcessorBox::enter_notify (GdkEventCrossing*)
{
_current_processor_box = this;
- Keyboard::magic_widget_grab_focus ();
- processor_display.grab_focus ();
-
return false;
}
bool
ProcessorBox::leave_notify (GdkEventCrossing* ev)
{
- switch (ev->detail) {
- case GDK_NOTIFY_INFERIOR:
- break;
- default:
- Keyboard::magic_widget_drop_focus ();
- }
-
return false;
}
-bool
-ProcessorBox::processor_key_press_event (GdkEventKey *)
-{
- /* do real stuff on key release */
- return false;
-}
-
-bool
-ProcessorBox::processor_key_release_event (GdkEventKey *ev)
+void
+ProcessorBox::processor_operation (ProcessorOperation op)
{
- bool ret = false;
ProcSelection targets;
get_selected_processors (targets);
}
}
-
- switch (ev->keyval) {
- case GDK_a:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- processor_display.select_all ();
- ret = true;
- }
+ switch (op) {
+ case ProcessorsSelectAll:
+ processor_display.select_all ();
break;
- case GDK_c:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- copy_processors (targets);
- ret = true;
- }
+ case ProcessorsCopy:
+ copy_processors (targets);
break;
- case GDK_x:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- cut_processors (targets);
- ret = true;
- }
+ case ProcessorsCut:
+ cut_processors (targets);
break;
- case GDK_v:
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- if (targets.empty()) {
- paste_processors ();
- } else {
- paste_processors (targets.front());
- }
- ret = true;
+ case ProcessorsPaste:
+ if (targets.empty()) {
+ paste_processors ();
+ } else {
+ paste_processors (targets.front());
}
break;
- case GDK_Up:
- break;
-
- case GDK_Down:
- break;
-
- case GDK_Delete:
- case GDK_BackSpace:
+ case ProcessorsDelete:
delete_processors (targets);
- ret = true;
break;
- case GDK_Return:
+ case ProcessorsToggleActive:
for (ProcSelection::iterator i = targets.begin(); i != targets.end(); ++i) {
if ((*i)->active()) {
(*i)->deactivate ();
(*i)->activate ();
}
}
- ret = true;
break;
- case GDK_slash:
+ case ProcessorsAB:
ab_plugins ();
- ret = true;
break;
default:
break;
}
-
- return ret;
}
bool
return processor_menu;
}
-void
-ProcessorBox::selection_changed ()
-{
- const bool sensitive = !processor_display.selection().empty();
- ActionManager::set_sensitive(ActionManager::plugin_selection_sensitive_actions,
- sensitive);
- edit_action->set_sensitive(one_processor_can_be_edited());
-
- const bool single_selection = (processor_display.selection().size() == 1);
-
- boost::shared_ptr<PluginInsert> pi;
- if (single_selection) {
- pi = boost::dynamic_pointer_cast<PluginInsert>(
- processor_display.selection().front()->processor());
- }
-
- /* enable gui for plugin inserts with editors */
- controls_action->set_sensitive(pi && pi->plugin()->has_editor());
-
- /* disallow rename for multiple selections and for plugin inserts */
- rename_action->set_sensitive(single_selection && pi);
-}
-
void
ProcessorBox::select_all_processors ()
{
return false;
}
-void
-ProcessorBox::cut_processors ()
-{
- ProcSelection to_be_removed;
-
- get_selected_processors (to_be_removed);
-}
-
void
ProcessorBox::cut_processors (const ProcSelection& to_be_removed)
{
redisplay_processors ();
}
-void
-ProcessorBox::copy_processors ()
-{
- ProcSelection to_be_copied;
- get_selected_processors (to_be_copied);
- copy_processors (to_be_copied);
-}
-
void
ProcessorBox::copy_processors (const ProcSelection& to_be_copied)
{
}
void
-ProcessorBox::delete_processors ()
+ProcessorBox::processors_up ()
+{
+ /* unimplemented */
+}
+
+void
+ProcessorBox::processors_down ()
{
- ProcSelection to_be_deleted;
- get_selected_processors (to_be_deleted);
- delete_processors (to_be_deleted);
+ /* unimplemented */
}
+
void
ProcessorBox::delete_processors (const ProcSelection& targets)
}
void
-ProcessorBox::all_processors_active (bool state)
+ProcessorBox::all_visible_processors_active (bool state)
{
- _route->all_processors_active (PreFader, state);
- _route->all_processors_active (PostFader, state);
+ _route->all_visible_processors_active (state);
}
void
}
if (
- boost::dynamic_pointer_cast<Send> (processor) ||
+ (boost::dynamic_pointer_cast<Send> (processor) && !boost::dynamic_pointer_cast<InternalSend> (processor))||
boost::dynamic_pointer_cast<Return> (processor) ||
boost::dynamic_pointer_cast<PluginInsert> (processor) ||
boost::dynamic_pointer_cast<PortInsert> (processor)
_parent_strip->revert_to_default_display ();
}
- } else if ((internal_send = boost::dynamic_pointer_cast<InternalSend> (processor)) != 0) {
-
- if (!_session->engine().connected()) {
- return;
- }
-
- if (_parent_strip) {
- if (boost::dynamic_pointer_cast<Send> (_parent_strip->current_delivery()) == internal_send) {
- _parent_strip->revert_to_default_display ();
- } else {
- _parent_strip->show_send (internal_send);
- }
- }
-
} else if ((send = boost::dynamic_pointer_cast<Send> (processor)) != 0) {
if (!_session->engine().connected()) {
return;
}
- SendUIWindow* w = new SendUIWindow (send, _session);
- w->show ();
+ if (boost::dynamic_pointer_cast<InternalSend> (processor) == 0) {
+ SendUIWindow* w = new SendUIWindow (send, _session);
+ w->show ();
+ }
} else if ((retrn = boost::dynamic_pointer_cast<Return> (processor)) != 0) {
act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"),
sigc::ptr_fun (ProcessorBox::rb_choose_insert));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New Send ..."),
+ act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New External Send ..."),
sigc::ptr_fun (ProcessorBox::rb_choose_send));
ActionManager::jack_sensitive_actions.push_back (act);
/* activation etc. */
- ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate all"),
+ ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate All"),
sigc::ptr_fun (ProcessorBox::rb_activate_all));
- ActionManager::register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate all"),
+ ActionManager::register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate All"),
sigc::ptr_fun (ProcessorBox::rb_deactivate_all));
ActionManager::register_action (popup_act_grp, X_("ab_plugins"), _("A/B Plugins"),
sigc::ptr_fun (ProcessorBox::rb_ab_plugins));
return;
}
- _current_processor_box->cut_processors ();
+ _current_processor_box->processor_operation (ProcessorsCut);
}
void
return;
}
- _current_processor_box->delete_processors ();
+ _current_processor_box->processor_operation (ProcessorsDelete);
}
void
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->copy_processors ();
+ _current_processor_box->processor_operation (ProcessorsCopy);
}
void
return;
}
- _current_processor_box->paste_processors ();
+ _current_processor_box->processor_operation (ProcessorsPaste);
}
void
return;
}
- _current_processor_box->select_all_processors ();
+ _current_processor_box->processor_operation (ProcessorsSelectAll);
}
void
return;
}
- _current_processor_box->all_processors_active (true);
+ _current_processor_box->all_visible_processors_active (true);
}
void
if (_current_processor_box == 0) {
return;
}
- _current_processor_box->all_processors_active (false);
+ _current_processor_box->all_visible_processors_active (false);
}
void