gtk2_ardour/io_selector.cc

   1 /*
   2     Copyright (C) 2002-2007 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 <gtkmm/messagedialog.h>
  21 #include <glibmm/objectbase.h>
  22
  23 #include <gtkmm2ext/doi.h>
  24
  25 #include "ardour/port_insert.h"
  26 #include "ardour/session.h"
  27 #include "ardour/io.h"
  28 #include "ardour/audioengine.h"
  29 #include "ardour/track.h"
  30 #include "ardour/audio_track.h"
  31 #include "ardour/midi_track.h"
  32 #include "ardour/data_type.h"
  33 #include "ardour/port.h"
  34 #include "ardour/bundle.h"
  35
  36 #include "io_selector.h"
  37 #include "utils.h"
  38 #include "gui_thread.h"
  39 #include "i18n.h"
  40
  41 using namespace ARDOUR;
  42 using namespace Gtk;
  43
  44 IOSelector::IOSelector (ARDOUR::Session& session, boost::shared_ptr<ARDOUR::IO> io, bool in)
  45         : PortMatrix (session, io->default_type())
  46         , _io (io)
  47         , _find_inputs_for_io_outputs (in)
  48 {
  49         /* signal flow from 0 to 1 */
  50         if (_find_inputs_for_io_outputs) {
  51                 _other = 1;
  52                 _ours = 0;
  53         } else {
  54                 _other = 0;
  55                 _ours = 1;
  56         }
  57
  58         _port_group = boost::shared_ptr<PortGroup> (new PortGroup (""));
  59         _ports[_ours].add_group (_port_group);
  60
  61         setup_all_ports ();
  62 }
  63
  64 void
  65 IOSelector::setup_ports (int dim)
  66 {
  67         _ports[dim].suspend_signals ();
  68
  69         if (dim == _other) {
  70
  71                 _ports[_other].gather (_session, _find_inputs_for_io_outputs);
  72
  73         } else {
  74
  75                 _port_group->clear ();
  76                 _port_group->add_bundle (
  77                         _find_inputs_for_io_outputs ? _io->bundle_for_outputs() : _io->bundle_for_inputs()
  78                         );
  79         }
  80
  81         _ports[dim].resume_signals ();
  82 }
  83
  84 void
  85 IOSelector::set_state (ARDOUR::BundleChannel c[2], bool s)
  86 {
  87         ARDOUR::Bundle::PortList const & our_ports = c[_ours].bundle->channel_ports (c[_ours].channel);
  88         ARDOUR::Bundle::PortList const & other_ports = c[_other].bundle->channel_ports (c[_other].channel);
  89
  90         for (ARDOUR::Bundle::PortList::const_iterator i = our_ports.begin(); i != our_ports.end(); ++i) {
  91                 for (ARDOUR::Bundle::PortList::const_iterator j = other_ports.begin(); j != other_ports.end(); ++j) {
  92
  93                         Port* f = _session.engine().get_port_by_name (*i);
  94                         if (!f) {
  95                                 return;
  96                         }
  97
  98                         if (s) {
  99                                 if (!_find_inputs_for_io_outputs) {
 100                                         _io->connect_input (f, *j, 0);
 101                                 } else {
 102                                         _io->connect_output (f, *j, 0);
 103                                 }
 104                         } else {
 105                                 if (!_find_inputs_for_io_outputs) {
 106                                         _io->disconnect_input (f, *j, 0);
 107                                 } else {
 108                                         _io->disconnect_output (f, *j, 0);
 109                                 }
 110                         }
 111                 }
 112         }
 113 }
 114
 115 PortMatrixNode::State
 116 IOSelector::get_state (ARDOUR::BundleChannel c[2]) const
 117 {
 118         ARDOUR::Bundle::PortList const & our_ports = c[_ours].bundle->channel_ports (c[_ours].channel);
 119         ARDOUR::Bundle::PortList const & other_ports = c[_other].bundle->channel_ports (c[_other].channel);
 120
 121         if (our_ports.empty() || other_ports.empty()) {
 122                 /* we're looking at a bundle with no parts associated with this channel,
 123                    so nothing to connect */
 124                 return PortMatrixNode::UNKNOWN;
 125         }
 126
 127         for (ARDOUR::Bundle::PortList::const_iterator i = our_ports.begin(); i != our_ports.end(); ++i) {
 128                 for (ARDOUR::Bundle::PortList::const_iterator j = other_ports.begin(); j != other_ports.end(); ++j) {
 129
 130                         Port* f = _session.engine().get_port_by_name (*i);
 131
 132                         /* since we are talking about an IO, our ports should all have an associated Port *,
 133                            so the above call should never fail */
 134                         assert (f);
 135
 136                         if (!f->connected_to (*j)) {
 137                                 /* if any one thing is not connected, all bets are off */
 138                                 return PortMatrixNode::NOT_ASSOCIATED;
 139                         }
 140                 }
 141         }
 142
 143         return PortMatrixNode::ASSOCIATED;
 144 }
 145
 146 uint32_t
 147 IOSelector::n_io_ports () const
 148 {
 149         if (!_find_inputs_for_io_outputs) {
 150                 return _io->inputs().num_ports (_io->default_type());
 151         } else {
 152                 return _io->outputs().num_ports (_io->default_type());
 153         }
 154 }
 155
 156 void
 157 IOSelector::add_channel (boost::shared_ptr<ARDOUR::Bundle> b)
 158 {
 159         /* we ignore the bundle parameter, as we know what it is that we're adding to */
 160
 161         // The IO selector only works for single typed IOs
 162         const ARDOUR::DataType t = _io->default_type ();
 163
 164         if (!_find_inputs_for_io_outputs) {
 165
 166                 try {
 167                         _io->add_input_port ("", this);
 168                 }
 169
 170                 catch (AudioEngine::PortRegistrationFailure& err) {
 171                         MessageDialog msg (_("There are no more JACK ports available."));
 172                         msg.run ();
 173                 }
 174
 175         } else {
 176
 177                 try {
 178                         _io->add_output_port ("", this);
 179                 }
 180
 181                 catch (AudioEngine::PortRegistrationFailure& err) {
 182                         MessageDialog msg (_("There are no more JACK ports available."));
 183                         msg.run ();
 184                 }
 185         }
 186 }
 187
 188 void
 189 IOSelector::remove_channel (ARDOUR::BundleChannel bc)
 190 {
 191         Port* f = _session.engine().get_port_by_name (bc.bundle->channel_ports(bc.channel)[0]);
 192         if (!f) {
 193                 return;
 194         }
 195
 196         if (_find_inputs_for_io_outputs) {
 197                 _io->remove_output_port (f, this);
 198         } else {
 199                 _io->remove_input_port (f, this);
 200         }
 201 }
 202
 203 bool
 204 IOSelector::list_is_global (int dim) const
 205 {
 206         return (dim == _other);
 207 }
 208
 209 IOSelectorWindow::IOSelectorWindow (ARDOUR::Session& session, boost::shared_ptr<ARDOUR::IO> io, bool for_input, bool can_cancel)
 210         : ArdourDialog ("I/O selector")
 211         , _selector (session, io, !for_input)
 212         , add_button (_("Add Port"))
 213         , disconnect_button (_("Disconnect All"))
 214         , ok_button (can_cancel ? _("OK"): _("Close"))
 215         , cancel_button (_("Cancel"))
 216         , rescan_button (_("Rescan"))
 217
 218 {
 219         /* XXX: what's this for? */
 220         add_events (Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);
 221
 222         set_name ("IOSelectorWindow2");
 223
 224         /* Disconnect All button */
 225         disconnect_button.set_name ("IOSelectorButton");
 226         disconnect_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::DISCONNECT, Gtk::ICON_SIZE_BUTTON)));
 227         disconnect_button.signal_clicked().connect (sigc::mem_fun (_selector, &IOSelector::disassociate_all));
 228         get_action_area()->pack_start (disconnect_button, false, false);
 229
 230         /* Add Port button */
 231         add_button.set_name ("IOSelectorButton");
 232         add_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::ADD, Gtk::ICON_SIZE_BUTTON)));
 233         get_action_area()->pack_start (add_button, false, false);
 234         add_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (_selector, &IOSelector::add_channel), boost::shared_ptr<Bundle> ()));
 235
 236         /* Rescan button */
 237         rescan_button.set_name ("IOSelectorButton");
 238         rescan_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::REFRESH, Gtk::ICON_SIZE_BUTTON)));
 239         rescan_button.signal_clicked().connect (sigc::mem_fun (*this, &IOSelectorWindow::rescan));
 240         get_action_area()->pack_start (rescan_button, false, false);
 241
 242         io->PortCountChanged.connect (sigc::hide (mem_fun (*this, &IOSelectorWindow::ports_changed)));
 243
 244         /* Cancel button */
 245         if (can_cancel) {
 246                 cancel_button.set_name ("IOSelectorButton");
 247                 cancel_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CANCEL, Gtk::ICON_SIZE_BUTTON)));
 248                 get_action_area()->pack_start (cancel_button, false, false);
 249         } else {
 250                 cancel_button.hide();
 251         }
 252         cancel_button.signal_clicked().connect (mem_fun(*this, &IOSelectorWindow::cancel));
 253
 254         /* OK button */
 255         ok_button.set_name ("IOSelectorButton");
 256         if (!can_cancel) {
 257                 ok_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CLOSE, Gtk::ICON_SIZE_BUTTON)));
 258         }
 259         ok_button.signal_clicked().connect (mem_fun(*this, &IOSelectorWindow::accept));
 260         get_action_area()->pack_start (ok_button, false, false);
 261
 262         get_vbox()->set_spacing (8);
 263
 264         get_vbox()->pack_start (_selector, true, true);
 265
 266         set_position (Gtk::WIN_POS_MOUSE);
 267
 268         io_name_changed (this);
 269         ports_changed ();
 270
 271         show_all ();
 272
 273         signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), this));
 274 }
 275
 276 void
 277 IOSelectorWindow::ports_changed ()
 278 {
 279         /* XXX make this insensitive based on port connectivity, not
 280            port counts.
 281         */
 282
 283         add_button.set_sensitive (true);
 284 }
 285
 286 void
 287 IOSelectorWindow::rescan ()
 288 {
 289         _selector.setup_ports (_selector.other());
 290 }
 291
 292 void
 293 IOSelectorWindow::cancel ()
 294 {
 295         _selector.Finished (IOSelector::Cancelled);
 296         hide ();
 297 }
 298
 299 void
 300 IOSelectorWindow::accept ()
 301 {
 302         _selector.Finished (IOSelector::Accepted);
 303         hide ();
 304 }
 305
 306 void
 307 IOSelectorWindow::on_map ()
 308 {
 309         _selector.setup_all_ports ();
 310         Window::on_map ();
 311 }
 312
 313 void
 314 IOSelectorWindow::io_name_changed (void* src)
 315 {
 316         ENSURE_GUI_THREAD(bind (mem_fun(*this, &IOSelectorWindow::io_name_changed), src));
 317
 318         string title;
 319
 320         if (!_selector.find_inputs_for_io_outputs()) {
 321                 title = string_compose(_("%1 input"), _selector.io()->name());
 322         } else {
 323                 title = string_compose(_("%1 output"), _selector.io()->name());
 324         }
 325
 326         set_title (title);
 327 }
 328
 329 PortInsertUI::PortInsertUI (ARDOUR::Session& sess, boost::shared_ptr<ARDOUR::PortInsert> pi)
 330         : input_selector (sess, pi->io(), true),
 331           output_selector (sess, pi->io(), false)
 332 {
 333         output_selector.set_min_height_divisor (2);
 334         input_selector.set_min_height_divisor (2);
 335
 336         pack_start (output_selector, true, true);
 337         pack_start (input_selector, true, true);
 338 }
 339
 340 void
 341 PortInsertUI::redisplay ()
 342 {
 343         input_selector.setup_ports (input_selector.other());
 344         output_selector.setup_ports (output_selector.other());
 345 }
 346
 347 void
 348 PortInsertUI::finished (IOSelector::Result r)
 349 {
 350         input_selector.Finished (r);
 351         output_selector.Finished (r);
 352 }
 353
 354
 355 PortInsertWindow::PortInsertWindow (ARDOUR::Session& sess, boost::shared_ptr<ARDOUR::PortInsert> pi, bool can_cancel)
 356         : ArdourDialog ("port insert dialog"),
 357           _portinsertui (sess, pi),
 358           ok_button (can_cancel ? _("OK"): _("Close")),
 359           cancel_button (_("Cancel")),
 360           rescan_button (_("Rescan"))
 361 {
 362
 363         set_name ("IOSelectorWindow");
 364         string title = _("ardour: ");
 365         title += pi->name();
 366         set_title (title);
 367
 368         ok_button.set_name ("IOSelectorButton");
 369         if (!can_cancel) {
 370                 ok_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CLOSE, Gtk::ICON_SIZE_BUTTON)));
 371         }
 372         cancel_button.set_name ("IOSelectorButton");
 373         rescan_button.set_name ("IOSelectorButton");
 374         rescan_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::REFRESH, Gtk::ICON_SIZE_BUTTON)));
 375
 376         get_action_area()->pack_start (rescan_button, false, false);
 377         if (can_cancel) {
 378                 cancel_button.set_image (*Gtk::manage (new Gtk::Image (Gtk::Stock::CANCEL, Gtk::ICON_SIZE_BUTTON)));
 379                 get_action_area()->pack_start (cancel_button, false, false);
 380         } else {
 381                 cancel_button.hide();
 382         }
 383         get_action_area()->pack_start (ok_button, false, false);
 384
 385         get_vbox()->pack_start (_portinsertui);
 386
 387         ok_button.signal_clicked().connect (mem_fun (*this, &PortInsertWindow::accept));
 388         cancel_button.signal_clicked().connect (mem_fun (*this, &PortInsertWindow::cancel));
 389
 390         signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast<Window *> (this)));
 391
 392         going_away_connection = pi->GoingAway.connect (mem_fun (*this, &PortInsertWindow::plugin_going_away));
 393 }
 394
 395 void
 396 PortInsertWindow::plugin_going_away ()
 397 {
 398         ENSURE_GUI_THREAD (mem_fun (*this, &PortInsertWindow::plugin_going_away));
 399
 400         going_away_connection.disconnect ();
 401         delete_when_idle (this);
 402 }
 403
 404 void
 405 PortInsertWindow::on_map ()
 406 {
 407         _portinsertui.redisplay ();
 408         Window::on_map ();
 409 }
 410
 411
 412 void
 413 PortInsertWindow::cancel ()
 414 {
 415         _portinsertui.finished (IOSelector::Cancelled);
 416         hide ();
 417 }
 418
 419 void
 420 PortInsertWindow::accept ()
 421 {
 422         _portinsertui.finished (IOSelector::Accepted);
 423         hide ();
 424 }
 425