gtk2_ardour/mixer_actor.cc

   1 /*
   2     Copyright (C) 2000-2004 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <boost/foreach.hpp>
  25
  26 #include "pbd/file_utils.h"
  27 #include "pbd/error.h"
  28
  29 #include "ardour/filesystem_paths.h"
  30
  31 #include "actions.h"
  32 #include "mixer_actor.h"
  33 #include "mixer_strip.h"
  34 #include "route_ui.h"
  35
  36 #include "i18n.h"
  37
  38 using namespace ARDOUR;
  39 using namespace Gtk;
  40 using namespace PBD;
  41
  42 MixerActor::MixerActor ()
  43 {
  44         register_actions ();
  45         load_bindings ();
  46 }
  47
  48 MixerActor::~MixerActor ()
  49 {
  50 }
  51
  52 void
  53 MixerActor::register_actions ()
  54 {
  55         myactions.register_action ("Mixer", "solo", _("Toggle Solo on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::solo_action));
  56         myactions.register_action ("Mixer", "mute", _("Toggle Mute on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::mute_action));
  57         myactions.register_action ("Mixer", "recenable", _("Toggle Rec-enable on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::rec_enable_action));
  58         myactions.register_action ("Mixer", "increment-gain", _("Decrease Gain on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::step_gain_up_action));
  59         myactions.register_action ("Mixer", "decrement-gain", _("Increase Gain on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::step_gain_down_action));
  60         myactions.register_action ("Mixer", "unity-gain", _("Set Gain to 0dB on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::unity_gain_action));
  61
  62
  63         myactions.register_action ("Mixer", "copy-processors", _("Copy Selected Processors"), sigc::mem_fun (*this, &MixerActor::copy_processors));
  64         myactions.register_action ("Mixer", "cut-processors", _("Cut Selected Processors"), sigc::mem_fun (*this, &MixerActor::cut_processors));
  65         myactions.register_action ("Mixer", "paste-processors", _("Paste Selected Processors"), sigc::mem_fun (*this, &MixerActor::paste_processors));
  66         myactions.register_action ("Mixer", "delete-processors", _("Delete Selected Processors"), sigc::mem_fun (*this, &MixerActor::delete_processors));
  67         myactions.register_action ("Mixer", "select-all-processors", _("Select All (visible) Processors"), sigc::mem_fun (*this, &MixerActor::select_all_processors));
  68         myactions.register_action ("Mixer", "toggle-processors", _("Toggle Selected Processors"), sigc::mem_fun (*this, &MixerActor::toggle_processors));
  69         myactions.register_action ("Mixer", "ab-plugins", _("Toggle Selected Plugins"), sigc::mem_fun (*this, &MixerActor::ab_plugins));
  70
  71
  72         myactions.register_action ("Mixer", "scroll-left", _("Scroll Mixer Window to the left"), sigc::mem_fun (*this, &MixerActor::scroll_left));
  73         myactions.register_action ("Mixer", "scroll-right", _("Scroll Mixer Window to the left"), sigc::mem_fun (*this, &MixerActor::scroll_right));
  74
  75         myactions.register_action ("Mixer", "toggle-midi-input-active", _("Toggle MIDI Input Active for Mixer-Selected Tracks/Busses"),
  76                                    sigc::bind (sigc::mem_fun (*this, &MixerActor::toggle_midi_input_active), false));
  77 }
  78
  79 void
  80 MixerActor::load_bindings ()
  81 {
  82         /* XXX move this to a better place */
  83
  84         bindings.set_action_map (myactions);
  85
  86         std::string binding_file;
  87
  88         if (find_file_in_search_path (ardour_config_search_path(), "mixer.bindings", binding_file)) {
  89                 bindings.load (binding_file);
  90                 info << string_compose (_("Loaded mixer bindings from %1"), binding_file) << endmsg;
  91         } else {
  92                 error << string_compose (_("Could not find mixer.bindings in search path %1"), ardour_config_search_path().to_string()) << endmsg;
  93         }
  94 }
  95
  96 void
  97 MixerActor::solo_action ()
  98 {
  99         GdkEventButton ev;
 100
 101         ev.type = GDK_BUTTON_PRESS;
 102         ev.button = 1;
 103         ev.state = 0;
 104
 105         set_route_targets_for_operation ();
 106
 107         BOOST_FOREACH(RouteUI* r, _route_targets) {
 108                 r->solo_press (&ev);
 109         }
 110 }
 111
 112 void
 113 MixerActor::mute_action ()
 114 {
 115         GdkEventButton ev;
 116
 117         ev.type = GDK_BUTTON_PRESS;
 118         ev.button = 1;
 119         ev.state = 0;
 120
 121         set_route_targets_for_operation ();
 122
 123         BOOST_FOREACH(RouteUI* r, _route_targets) {
 124                 r->mute_press (&ev);
 125         }
 126 }
 127
 128 void
 129 MixerActor::rec_enable_action ()
 130 {
 131         GdkEventButton ev;
 132
 133         ev.type = GDK_BUTTON_PRESS;
 134         ev.button = 1;
 135         ev.state = 0;
 136
 137         set_route_targets_for_operation ();
 138
 139         BOOST_FOREACH(RouteUI* r, _route_targets) {
 140                 r->rec_enable_press (&ev);
 141         }
 142 }
 143
 144 void
 145 MixerActor::step_gain_up_action ()
 146 {
 147         set_route_targets_for_operation ();
 148
 149         BOOST_FOREACH(RouteUI* r, _route_targets) {
 150                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 151                 if (ms) {
 152                         ms->step_gain_up ();
 153                 }
 154         }
 155 }
 156
 157 void
 158 MixerActor::step_gain_down_action ()
 159 {
 160         set_route_targets_for_operation ();
 161
 162         BOOST_FOREACH(RouteUI* r, _route_targets) {
 163                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 164                 if (ms) {
 165                         ms->step_gain_down ();
 166                 }
 167         }
 168 }
 169
 170 void
 171 MixerActor::unity_gain_action ()
 172 {
 173         set_route_targets_for_operation ();
 174
 175         BOOST_FOREACH(RouteUI* r, _route_targets) {
 176                 boost::shared_ptr<Route> rp = r->route();
 177                 if (rp) {
 178                         rp->set_gain (1.0, this);
 179                 }
 180         }
 181 }
 182
 183 void
 184 MixerActor::copy_processors ()
 185 {
 186         set_route_targets_for_operation ();
 187
 188         BOOST_FOREACH(RouteUI* r, _route_targets) {
 189                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 190                 if (ms) {
 191                         ms->copy_processors ();
 192                 }
 193         }
 194 }
 195 void
 196 MixerActor::cut_processors ()
 197 {
 198         set_route_targets_for_operation ();
 199
 200         BOOST_FOREACH(RouteUI* r, _route_targets) {
 201                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 202                 if (ms) {
 203                         ms->cut_processors ();
 204                 }
 205         }
 206 }
 207 void
 208 MixerActor::paste_processors ()
 209 {
 210         set_route_targets_for_operation ();
 211
 212         BOOST_FOREACH(RouteUI* r, _route_targets) {
 213                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 214                 if (ms) {
 215                         ms->paste_processors ();
 216                 }
 217         }
 218 }
 219 void
 220 MixerActor::select_all_processors ()
 221 {
 222         set_route_targets_for_operation ();
 223
 224         BOOST_FOREACH(RouteUI* r, _route_targets) {
 225                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 226                 if (ms) {
 227                         ms->select_all_processors ();
 228                 }
 229         }
 230 }
 231 void
 232 MixerActor::delete_processors ()
 233 {
 234         set_route_targets_for_operation ();
 235
 236         BOOST_FOREACH(RouteUI* r, _route_targets) {
 237                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 238                 if (ms) {
 239                         ms->delete_processors ();
 240                 }
 241         }
 242 }
 243 void
 244 MixerActor::toggle_processors ()
 245 {
 246         set_route_targets_for_operation ();
 247
 248         BOOST_FOREACH(RouteUI* r, _route_targets) {
 249                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 250                 if (ms) {
 251                         ms->toggle_processors ();
 252                 }
 253         }
 254 }
 255 void
 256 MixerActor::ab_plugins ()
 257 {
 258         set_route_targets_for_operation ();
 259
 260         BOOST_FOREACH(RouteUI* r, _route_targets) {
 261                 MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 262                 if (ms) {
 263                         ms->ab_plugins ();
 264                 }
 265         }
 266 }
 267