gtk2_ardour/port_group.cc

   1 /*
   2     Copyright (C) 2002-2009 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 #include "port_group.h"
  21 #include "port_matrix.h"
  22 #include "i18n.h"
  23 #include "ardour/session.h"
  24 #include "ardour/audio_track.h"
  25 #include "ardour/midi_track.h"
  26 #include "ardour/audioengine.h"
  27 #include "ardour/port.h"
  28 #include "ardour/bundle.h"
  29 #include <boost/shared_ptr.hpp>
  30 #include <cstring>
  31
  32 using namespace std;
  33 using namespace Gtk;
  34
  35 /** Add a bundle to a group.
  36  *  @param b Bundle.
  37  */
  38 void
  39 PortGroup::add_bundle (boost::shared_ptr<ARDOUR::Bundle> b)
  40 {
  41         bundles.push_back (b);
  42 }
  43
  44 /** Add a port to a group.
  45  *  @param p Port.
  46  */
  47 void
  48 PortGroup::add_port (std::string const &p)
  49 {
  50         ports.push_back (p);
  51 }
  52
  53 void
  54 PortGroup::clear ()
  55 {
  56         bundles.clear ();
  57         ports.clear ();
  58 }
  59
  60 /** PortGroupUI constructor.
  61  *  @param m PortMatrix to work for.
  62  *  @Param g PortGroup to represent.
  63  */
  64
  65 PortGroupUI::PortGroupUI (PortMatrix* m, PortGroup* g)
  66         : _port_matrix (m)
  67         , _port_group (g)
  68         , _visibility_checkbutton (g->name)
  69 {
  70         _port_group->visible = true;
  71         setup_visibility_checkbutton ();
  72
  73         _visibility_checkbutton.signal_toggled().connect (sigc::mem_fun (*this, &PortGroupUI::visibility_checkbutton_toggled));
  74 }
  75
  76 /** The visibility of a PortGroupUI has been toggled */
  77 void
  78 PortGroupUI::visibility_checkbutton_toggled ()
  79 {
  80         _port_group->visible = _visibility_checkbutton.get_active ();
  81         setup_visibility_checkbutton ();
  82         _port_matrix->setup ();
  83 }
  84
  85 /** Set up the visibility checkbutton according to PortGroup::visible */
  86 void
  87 PortGroupUI::setup_visibility_checkbutton ()
  88 {
  89         if (_visibility_checkbutton.get_active () != _port_group->visible) {
  90                 _visibility_checkbutton.set_active (_port_group->visible);
  91         }
  92 }
  93
  94 /** PortGroupList constructor.
  95  *  @param session Session to get bundles from.
  96  *  @param type Type of bundles to offer (audio or MIDI)
  97  *  @param offer_inputs true to offer output bundles, otherwise false.
  98  *  @param mask Mask of groups to make visible by default.
  99  */
 100
 101 PortGroupList::PortGroupList (ARDOUR::Session & session, ARDOUR::DataType type, bool offer_inputs, Mask mask)
 102         : _session (session), _type (type), _offer_inputs (offer_inputs),
 103           _buss (_("Bus"), mask & BUSS),
 104           _track (_("Track"), mask & TRACK),
 105           _system (_("System"), mask & SYSTEM),
 106           _other (_("Other"), mask & OTHER)
 107 {
 108         refresh ();
 109 }
 110
 111 /** Find or re-find all our bundles and set up our lists */
 112 void
 113 PortGroupList::refresh ()
 114 {
 115         clear ();
 116
 117         _buss.clear ();
 118         _track.clear ();
 119         _system.clear ();
 120         _other.clear ();
 121
 122         /* Find the bundles for routes */
 123
 124         boost::shared_ptr<ARDOUR::Session::RouteList> routes = _session.get_routes ();
 125
 126         for (ARDOUR::Session::RouteList::const_iterator i = routes->begin(); i != routes->end(); ++i) {
 127
 128                 PortGroup* g = 0;
 129
 130                 if (_type == ARDOUR::DataType::AUDIO) {
 131
 132                         if (boost::dynamic_pointer_cast<ARDOUR::AudioTrack> (*i)) {
 133                                 g = &_track;
 134                         } else if (!boost::dynamic_pointer_cast<ARDOUR::MidiTrack>(*i)) {
 135                                 g = &_buss;
 136                         }
 137
 138
 139                 } else if (_type == ARDOUR::DataType::MIDI) {
 140
 141                         if (boost::dynamic_pointer_cast<ARDOUR::MidiTrack> (*i)) {
 142                                 g = &_track;
 143                         }
 144
 145                         /* No MIDI busses yet */
 146                 }
 147
 148                 if (g) {
 149                         g->add_bundle (_offer_inputs ? (*i)->bundle_for_inputs() : (*i)->bundle_for_outputs ());
 150                 }
 151         }
 152
 153         /* Bundles created by the session */
 154         _session.foreach_bundle (sigc::mem_fun (*this, &PortGroupList::maybe_add_session_bundle));
 155
 156         /* XXX: inserts, sends, plugin inserts? */
 157
 158         /* Now we need to find the non-ardour ports; we do this by first
 159            finding all the ports that we can connect to.
 160         */
 161
 162         const char **ports = _session.engine().get_ports ("", _type.to_jack_type(), _offer_inputs ?
 163                                                           JackPortIsInput : JackPortIsOutput);
 164         if (ports) {
 165
 166                 int n = 0;
 167                 string client_matching_string;
 168
 169                 client_matching_string = _session.engine().client_name();
 170                 client_matching_string += ':';
 171
 172                 while (ports[n]) {
 173                         std::string const p = ports[n];
 174
 175                         if (p.substr(0, strlen ("system:")) == "system:") {
 176                                 /* system: prefix */
 177                                 _system.add_port (p);
 178                         } else {
 179                                 if (p.substr(0, client_matching_string.length()) != client_matching_string) {
 180                                         /* other (non-ardour) prefix */
 181                                         _other.add_port (p);
 182                                 }
 183                         }
 184
 185                         ++n;
 186                 }
 187
 188                 free (ports);
 189         }
 190
 191         push_back (&_system);
 192         push_back (&_buss);
 193         push_back (&_track);
 194         push_back (&_other);
 195 }
 196
 197 void
 198 PortGroupList::set_type (ARDOUR::DataType t)
 199 {
 200         _type = t;
 201 }
 202
 203 void
 204 PortGroupList::set_offer_inputs (bool i)
 205 {
 206         _offer_inputs = i;
 207 }
 208
 209 void
 210 PortGroupList::maybe_add_session_bundle (boost::shared_ptr<ARDOUR::Bundle> b)
 211 {
 212         if (b->ports_are_inputs () == _offer_inputs && b->type () == _type) {
 213                 _system.bundles.push_back (b);
 214         }
 215 }