gtk2_ardour/redirect_box.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 #include <cmath>
  21 #include <iostream>
  22
  23 #include <sigc++/bind.h>
  24
  25 #include <pbd/convert.h>
  26
  27 #include <glibmm/miscutils.h>
  28
  29 #include <gtkmm/messagedialog.h>
  30
  31 #include <gtkmm2ext/gtk_ui.h>
  32 #include <gtkmm2ext/utils.h>
  33 #include <gtkmm2ext/choice.h>
  34 #include <gtkmm2ext/utils.h>
  35 #include <gtkmm2ext/stop_signal.h>
  36 #include <gtkmm2ext/doi.h>
  37 #include <gtkmm2ext/window_title.h>
  38
  39 #include <ardour/ardour.h>
  40 #include <ardour/session.h>
  41 #include <ardour/audioengine.h>
  42 #include <ardour/route.h>
  43 #include <ardour/audio_track.h>
  44 #include <ardour/audio_diskstream.h>
  45 #include <ardour/send.h>
  46 #include <ardour/insert.h>
  47 #include <ardour/ladspa_plugin.h>
  48 #include <ardour/connection.h>
  49 #include <ardour/session_connection.h>
  50 #include <ardour/profile.h>
  51
  52 #include "ardour_ui.h"
  53 #include "ardour_dialog.h"
  54 #include "public_editor.h"
  55 #include "redirect_box.h"
  56 #include "keyboard.h"
  57 #include "plugin_selector.h"
  58 #include "route_redirect_selection.h"
  59 #include "mixer_ui.h"
  60 #include "actions.h"
  61 #include "plugin_ui.h"
  62 #include "send_ui.h"
  63 #include "io_selector.h"
  64 #include "utils.h"
  65 #include "gui_thread.h"
  66
  67 #include "i18n.h"
  68
  69 #ifdef HAVE_AUDIOUNITS
  70 class AUPluginUI;
  71 #endif
  72
  73 using namespace sigc;
  74 using namespace ARDOUR;
  75 using namespace PBD;
  76 using namespace Gtk;
  77 using namespace Glib;
  78 using namespace Gtkmm2ext;
  79
  80 RedirectBox* RedirectBox::_current_redirect_box = 0;
  81 RefPtr<Action> RedirectBox::paste_action;
  82 bool RedirectBox::get_colors = true;
  83 Gdk::Color* RedirectBox::active_redirect_color;
  84 Gdk::Color* RedirectBox::inactive_redirect_color;
  85
  86 RedirectBox::RedirectBox (Placement pcmnt, Session& sess, boost::shared_ptr<Route> rt, PluginSelector &plugsel,
  87                           RouteRedirectSelection & rsel, bool owner_is_mixer)
  88         : _route(rt),
  89           _session(sess),
  90           _owner_is_mixer (owner_is_mixer),
  91           _placement(pcmnt),
  92           _plugin_selector(plugsel),
  93           _rr_selection(rsel)
  94 {
  95         if (get_colors) {
  96                 active_redirect_color = new Gdk::Color;
  97                 inactive_redirect_color = new Gdk::Color;
  98                 set_color (*active_redirect_color, rgba_from_style ("RedirectSelector", 0xff, 0, 0, 0, "fg", Gtk::STATE_ACTIVE, false ));
  99                 set_color (*inactive_redirect_color, rgba_from_style ("RedirectSelector", 0xff, 0, 0, 0, "fg", Gtk::STATE_NORMAL, false ));
 100                 get_colors = false;
 101         }
 102
 103         _width = Wide;
 104         redirect_menu = 0;
 105         send_action_menu = 0;
 106         redirect_drag_in_progress = false;
 107         no_redirect_redisplay = false;
 108         ignore_delete = false;
 109
 110         model = ListStore::create(columns);
 111
 112         RefPtr<TreeSelection> selection = redirect_display.get_selection();
 113         selection->set_mode (Gtk::SELECTION_MULTIPLE);
 114         selection->signal_changed().connect (mem_fun (*this, &RedirectBox::selection_changed));
 115
 116         redirect_display.set_model (model);
 117         redirect_display.append_column (X_("notshown"), columns.text);
 118         redirect_display.set_name ("RedirectSelector");
 119         redirect_display.set_headers_visible (false);
 120         redirect_display.set_reorderable (true);
 121         redirect_display.set_size_request (-1, 40);
 122         redirect_display.get_column(0)->set_sizing(TREE_VIEW_COLUMN_FIXED);
 123         redirect_display.get_column(0)->set_fixed_width(48);
 124         redirect_display.add_object_drag (columns.redirect.index(), "redirects");
 125         redirect_display.signal_object_drop.connect (mem_fun (*this, &RedirectBox::object_drop));
 126
 127         TreeViewColumn* name_col = redirect_display.get_column(0);
 128         CellRendererText* renderer = dynamic_cast<CellRendererText*>(redirect_display.get_column_cell_renderer (0));
 129         name_col->add_attribute(renderer->property_foreground_gdk(), columns.color);
 130
 131         redirect_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 132
 133         model->signal_row_deleted().connect (mem_fun (*this, &RedirectBox::row_deleted));
 134
 135         redirect_scroller.add (redirect_display);
 136         redirect_eventbox.add (redirect_scroller);
 137
 138         redirect_scroller.set_size_request (-1, 40);
 139
 140         pack_start (redirect_eventbox, true, true);
 141
 142         _route->redirects_changed.connect (mem_fun(*this, &RedirectBox::redisplay_redirects));
 143         _route->GoingAway.connect (mem_fun (*this, &RedirectBox::route_going_away));
 144
 145         redirect_eventbox.signal_enter_notify_event().connect (bind (sigc::ptr_fun (RedirectBox::enter_box), this));
 146
 147         redirect_display.signal_button_press_event().connect (mem_fun(*this, &RedirectBox::redirect_button_press_event), false);
 148         redirect_display.signal_button_release_event().connect (mem_fun(*this, &RedirectBox::redirect_button_release_event));
 149
 150         using_plugin_selector = false;
 151         _plugin_selector.signal_hide().connect (mem_fun (*this, &RedirectBox::plugin_selector_hidden));
 152         _plugin_selector.signal_show().connect (mem_fun (*this, &RedirectBox::plugin_selector_shown));
 153
 154         /* start off as a passthru strip. we'll correct this, if necessary,
 155            in update_diskstream_display().
 156         */
 157
 158         /* now force an update of all the various elements */
 159
 160         redisplay_redirects (0);
 161 }
 162
 163 RedirectBox::~RedirectBox ()
 164 {
 165 }
 166
 167 void
 168 RedirectBox::route_going_away ()
 169 {
 170         /* don't keep updating display as redirects are deleted */
 171         no_redirect_redisplay = true;
 172 }
 173
 174 void
 175 RedirectBox::object_drop (string type, uint32_t cnt, const boost::shared_ptr<Redirect>* ptr)
 176 {
 177         if (type != "redirects" || cnt == 0 || !ptr) {
 178                 return;
 179         }
 180
 181         /* do something with the dropped redirects */
 182
 183         list<boost::shared_ptr<Redirect> > redirects;
 184
 185         for (uint32_t n = 0; n < cnt; ++n) {
 186                 redirects.push_back (ptr[n]);
 187         }
 188
 189         paste_redirect_list (redirects);
 190 }
 191
 192 void
 193 RedirectBox::update()
 194 {
 195         redisplay_redirects (0);
 196 }
 197
 198
 199 void
 200 RedirectBox::set_width (Width w)
 201 {
 202         if (_width == w) {
 203                 return;
 204         }
 205         _width = w;
 206
 207         redisplay_redirects (0);
 208 }
 209
 210 void
 211 RedirectBox::remove_redirect_gui (boost::shared_ptr<Redirect> redirect)
 212 {
 213         boost::shared_ptr<Insert> insert;
 214         boost::shared_ptr<Send> send;
 215         boost::shared_ptr<PortInsert> port_insert;
 216
 217         if ((insert = boost::dynamic_pointer_cast<Insert> (redirect)) != 0) {
 218
 219                 if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (insert)) != 0) {
 220                         PortInsertUI *io_selector = reinterpret_cast<PortInsertUI *> (port_insert->get_gui());
 221                         port_insert->set_gui (0);
 222                         delete io_selector;
 223                 }
 224
 225         } else if ((send = boost::dynamic_pointer_cast<Send> (insert)) != 0) {
 226                 SendUIWindow *sui = reinterpret_cast<SendUIWindow*> (send->get_gui());
 227                 send->set_gui (0);
 228                 delete sui;
 229         }
 230 }
 231
 232 void
 233 RedirectBox::build_send_action_menu ()
 234
 235 {
 236         using namespace Menu_Helpers;
 237
 238         send_action_menu = new Menu;
 239         send_action_menu->set_name ("ArdourContextMenu");
 240         MenuList& items = send_action_menu->items();
 241
 242         items.push_back (MenuElem (_("New send"), mem_fun(*this, &RedirectBox::new_send)));
 243         items.push_back (MenuElem (_("Show send controls"), mem_fun(*this, &RedirectBox::show_send_controls)));
 244 }
 245
 246 void
 247 RedirectBox::show_send_controls ()
 248
 249 {
 250 }
 251
 252 void
 253 RedirectBox::new_send ()
 254
 255 {
 256 }
 257
 258 void
 259 RedirectBox::show_redirect_menu (gint arg)
 260 {
 261         if (redirect_menu == 0) {
 262                 redirect_menu = build_redirect_menu ();
 263         }
 264
 265         Gtk::MenuItem* plugin_menu_item = dynamic_cast<Gtk::MenuItem*>(ActionManager::get_widget("/redirectmenu/newplugin"));
 266
 267         if (plugin_menu_item) {
 268                 plugin_menu_item->set_submenu (_plugin_selector.plugin_menu());
 269         }
 270
 271         paste_action->set_sensitive (!_rr_selection.redirects.empty());
 272
 273         redirect_menu->popup (1, arg);
 274 }
 275
 276 void
 277 RedirectBox::redirect_drag_begin (GdkDragContext *context)
 278 {
 279         redirect_drag_in_progress = true;
 280 }
 281
 282 void
 283 RedirectBox::redirect_drag_end (GdkDragContext *context)
 284 {
 285         redirect_drag_in_progress = false;
 286 }
 287
 288 bool
 289 RedirectBox::redirect_button_press_event (GdkEventButton *ev)
 290 {
 291         TreeIter iter;
 292         TreeModel::Path path;
 293         TreeViewColumn* column;
 294         int cellx;
 295         int celly;
 296         boost::shared_ptr<Redirect> redirect;
 297         int ret = false;
 298         bool selected = false;
 299
 300         if (redirect_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
 301                 if ((iter = model->get_iter (path))) {
 302                         redirect = (*iter)[columns.redirect];
 303                         selected = redirect_display.get_selection()->is_selected (iter);
 304                 }
 305
 306         }
 307
 308         if (redirect && (Keyboard::is_edit_event (ev) || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS))) {
 309
 310                 if (_session.engine().connected()) {
 311                         /* XXX giving an error message here is hard, because we may be in the midst of a button press */
 312                         edit_redirect (redirect);
 313                 }
 314                 ret = true;
 315
 316         } else if (redirect && ev->button == 1 && selected) {
 317
 318                 // this is purely informational but necessary
 319                 RedirectSelected (redirect); // emit
 320         }
 321
 322         return ret;
 323 }
 324
 325 bool
 326 RedirectBox::redirect_button_release_event (GdkEventButton *ev)
 327 {
 328         TreeIter iter;
 329         TreeModel::Path path;
 330         TreeViewColumn* column;
 331         int cellx;
 332         int celly;
 333         boost::shared_ptr<Redirect> redirect;
 334         int ret = false;
 335
 336
 337         if (redirect_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
 338                 if ((iter = model->get_iter (path))) {
 339                         redirect = (*iter)[columns.redirect];
 340                 }
 341         }
 342
 343         if (redirect && Keyboard::is_delete_event (ev)) {
 344
 345                 Glib::signal_idle().connect (bind (mem_fun(*this, &RedirectBox::idle_delete_redirect), boost::weak_ptr<Redirect>(redirect)));
 346                 ret = true;
 347
 348         } else if (Keyboard::is_context_menu_event (ev)) {
 349
 350                 show_redirect_menu(ev->time);
 351                 ret = true;
 352
 353         } else if (redirect && (ev->button == 2) && (Keyboard::no_modifier_keys_pressed (ev) && ((ev->state & Gdk::BUTTON2_MASK) == Gdk::BUTTON2_MASK))) {
 354
 355                 /* button2-click with no modifiers */
 356
 357                 redirect->set_active (!redirect->active(), this);
 358                 ret = true;
 359
 360         }
 361
 362         return ret;
 363 }
 364
 365 Menu *
 366 RedirectBox::build_redirect_menu ()
 367 {
 368         redirect_menu = dynamic_cast<Gtk::Menu*>(ActionManager::get_widget("/redirectmenu") );
 369         redirect_menu->set_name ("ArdourContextMenu");
 370
 371         show_all_children();
 372
 373         return redirect_menu;
 374 }
 375
 376 void
 377 RedirectBox::selection_changed ()
 378 {
 379         bool sensitive = (redirect_display.get_selection()->count_selected_rows()) ? true : false;
 380         ActionManager::set_sensitive (ActionManager::plugin_selection_sensitive_actions, sensitive);
 381 }
 382
 383 void
 384 RedirectBox::select_all_redirects ()
 385 {
 386         redirect_display.get_selection()->select_all();
 387 }
 388
 389 void
 390 RedirectBox::deselect_all_redirects ()
 391 {
 392         redirect_display.get_selection()->unselect_all();
 393 }
 394
 395 void
 396 RedirectBox::choose_plugin ()
 397 {
 398         newplug_connection = _plugin_selector.PluginCreated.connect (mem_fun(*this,&RedirectBox::insert_plugin_chosen));
 399         // Gtk::Menu& m = _plugin_selector.plugin_menu();
 400         // m.popup (1, 0);
 401 }
 402
 403 void
 404 RedirectBox::insert_plugin_chosen (boost::shared_ptr<Plugin> plugin)
 405 {
 406         if (plugin) {
 407
 408                 boost::shared_ptr<Redirect> redirect (new PluginInsert (_session, plugin, _placement));
 409
 410                 uint32_t err_streams;
 411
 412                 if (_route->add_redirect (redirect, this, &err_streams)) {
 413                         weird_plugin_dialog (*plugin, err_streams, _route);
 414                 } else {
 415                         if (Profile->get_sae()) {
 416                                 redirect->set_active (true, 0);
 417                         }
 418                         redirect->active_changed.connect (bind (mem_fun (*this, &RedirectBox::show_redirect_active_r), boost::weak_ptr<Redirect>(redirect)));
 419                 }
 420         }
 421
 422         if (!using_plugin_selector) {
 423                 newplug_connection.disconnect();
 424         }
 425 }
 426
 427 void
 428 RedirectBox::weird_plugin_dialog (Plugin& p, uint32_t streams, boost::shared_ptr<IO> io)
 429 {
 430         ArdourDialog dialog (_("ardour: weird plugin dialog"));
 431         Label label;
 432
 433         /* i hate this kind of code */
 434
 435         if (streams > (unsigned)p.get_info()->n_inputs) {
 436                 label.set_text (string_compose (_(
 437 "You attempted to add a plugin (%1).\n"
 438 "The plugin has %2 inputs\n"
 439 "but at the insertion point, there are\n"
 440 "%3 active signal streams.\n"
 441 "\n"
 442 "This makes no sense - you are throwing away\n"
 443 "part of the signal."),
 444                                          p.name(),
 445                                          p.get_info()->n_inputs,
 446                                          streams));
 447         } else if (streams < (unsigned)p.get_info()->n_inputs) {
 448                 label.set_text (string_compose (_(
 449 "You attempted to add a plugin (%1).\n"
 450 "The plugin has %2 inputs\n"
 451 "but at the insertion point there are\n"
 452 "only %3 active signal streams.\n"
 453 "\n"
 454 "This makes no sense - unless the plugin supports\n"
 455 "side-chain inputs. A future version of Ardour will\n"
 456 "support this type of configuration."),
 457                                          p.name(),
 458                                          p.get_info()->n_inputs,
 459                                          streams));
 460         } else {
 461                 label.set_text (string_compose (_(
 462 "You attempted to add a plugin (%1).\n"
 463 "\n"
 464 "The I/O configuration doesn't make sense:\n"
 465 "\n"
 466 "The plugin has %2 inputs and %3 outputs.\n"
 467 "The track/bus has %4 inputs and %5 outputs.\n"
 468 "The insertion point, has %6 active signals.\n"
 469 "\n"
 470 "Ardour does not understand what to do in such situations.\n"),
 471                                          p.name(),
 472                                          p.get_info()->n_inputs,
 473                                          p.get_info()->n_outputs,
 474                                          io->n_inputs(),
 475                                          io->n_outputs(),
 476                                          streams));
 477         }
 478
 479         dialog.get_vbox()->pack_start (label);
 480         dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
 481
 482         dialog.set_name (X_("PluginIODialog"));
 483         dialog.set_position (Gtk::WIN_POS_MOUSE);
 484         dialog.set_modal (true);
 485         dialog.show_all ();
 486
 487         dialog.run ();
 488 }
 489
 490 void
 491 RedirectBox::choose_insert ()
 492 {
 493         boost::shared_ptr<Redirect> redirect (new PortInsert (_session, _placement));
 494         redirect->active_changed.connect (bind (mem_fun(*this, &RedirectBox::show_redirect_active_r), boost::weak_ptr<Redirect>(redirect)));
 495         _route->add_redirect (redirect, this);
 496 }
 497
 498 void
 499 RedirectBox::choose_send ()
 500 {
 501         boost::shared_ptr<Send> send (new Send (_session, _placement));
 502
 503         /* XXX need redirect lock on route */
 504
 505         send->ensure_io (0, _route->max_redirect_outs(), false, this);
 506
 507         IOSelectorWindow *ios = new IOSelectorWindow (_session, send, false, true);
 508
 509         ios->show_all ();
 510
 511         boost::shared_ptr<Redirect> r = boost::static_pointer_cast<Redirect>(send);
 512
 513         ios->selector().Finished.connect (bind (mem_fun(*this, &RedirectBox::send_io_finished), boost::weak_ptr<Redirect>(r), ios));
 514 }
 515
 516 void
 517 RedirectBox::send_io_finished (IOSelector::Result r, boost::weak_ptr<Redirect> weak_redirect, IOSelectorWindow* ios)
 518 {
 519         boost::shared_ptr<Redirect> redirect (weak_redirect.lock());
 520
 521         if (!redirect) {
 522                 return;
 523         }
 524
 525         switch (r) {
 526         case IOSelector::Cancelled:
 527                 // redirect will go away when all shared_ptrs to it vanish
 528                 break;
 529
 530         case IOSelector::Accepted:
 531                 _route->add_redirect (redirect, this);
 532                 break;
 533         }
 534
 535         delete_when_idle (ios);
 536 }
 537
 538 void
 539 RedirectBox::redisplay_redirects (void *src)
 540 {
 541         ENSURE_GUI_THREAD(bind (mem_fun(*this, &RedirectBox::redisplay_redirects), src));
 542
 543         if (no_redirect_redisplay) {
 544                 return;
 545         }
 546
 547         ignore_delete = true;
 548         model->clear ();
 549         ignore_delete = false;
 550
 551         redirect_active_connections.clear ();
 552         redirect_name_connections.clear ();
 553
 554         void (RedirectBox::*pmf)(boost::shared_ptr<Redirect>) = &RedirectBox::add_redirect_to_display;
 555         _route->foreach_redirect (this, pmf);
 556
 557         switch (_placement) {
 558         case PreFader:
 559                 build_redirect_tooltip(redirect_eventbox, _("Pre-fader inserts, sends & plugins:"));
 560                 break;
 561         case PostFader:
 562                 build_redirect_tooltip(redirect_eventbox, _("Post-fader inserts, sends & plugins:"));
 563                 break;
 564         }
 565 }
 566
 567 void
 568 RedirectBox::add_redirect_to_display (boost::shared_ptr<Redirect> redirect)
 569 {
 570         if (redirect->placement() != _placement) {
 571                 return;
 572         }
 573
 574         Gtk::TreeModel::Row row = *(model->append());
 575         row[columns.text] = redirect_name (redirect);
 576         row[columns.redirect] = redirect;
 577
 578         show_redirect_active (redirect);
 579
 580         redirect_active_connections.push_back (redirect->active_changed.connect (bind (mem_fun(*this, &RedirectBox::show_redirect_active_r), boost::weak_ptr<Redirect>(redirect))));
 581         redirect_name_connections.push_back (redirect->name_changed.connect (bind (mem_fun(*this, &RedirectBox::show_redirect_name), boost::weak_ptr<Redirect>(redirect))));
 582 }
 583
 584 string
 585 RedirectBox::redirect_name (boost::weak_ptr<Redirect> weak_redirect)
 586 {
 587         boost::shared_ptr<Redirect> redirect (weak_redirect.lock());
 588
 589         if (!redirect) {
 590                 return string();
 591         }
 592
 593         boost::shared_ptr<Send> send;
 594         string name_display;
 595
 596         if (!redirect->active()) {
 597                 name_display = " (";
 598         }
 599
 600         if ((send = boost::dynamic_pointer_cast<Send> (redirect)) != 0) {
 601
 602                 name_display += '>';
 603
 604                 /* grab the send name out of its overall name */
 605
 606                 string::size_type lbracket, rbracket;
 607                 lbracket = send->name().find ('[');
 608                 rbracket = send->name().find (']');
 609
 610                 switch (_width) {
 611                 case Wide:
 612                         name_display += send->name().substr (lbracket+1, lbracket-rbracket-1);
 613                         break;
 614                 case Narrow:
 615                         name_display += PBD::short_version (send->name().substr (lbracket+1, lbracket-rbracket-1), 4);
 616                         break;
 617                 }
 618
 619         } else {
 620
 621                 switch (_width) {
 622                 case Wide:
 623                         name_display += redirect->name();
 624                         break;
 625                 case Narrow:
 626                         name_display += PBD::short_version (redirect->name(), 5);
 627                         break;
 628                 }
 629
 630         }
 631
 632         if (!redirect->active()) {
 633                 name_display += ')';
 634         }
 635
 636         return name_display;
 637 }
 638
 639 void
 640 RedirectBox::build_redirect_tooltip (EventBox& box, string start)
 641 {
 642         string tip(start);
 643
 644         Gtk::TreeModel::Children children = model->children();
 645         for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
 646                 Gtk::TreeModel::Row row = *iter;
 647                 tip += '\n';
 648                 tip += row[columns.text];
 649         }
 650         ARDOUR_UI::instance()->tooltips().set_tip (box, tip);
 651 }
 652
 653 void
 654 RedirectBox::show_redirect_name (void* src, boost::weak_ptr<Redirect> redirect)
 655 {
 656         ENSURE_GUI_THREAD(bind (mem_fun(*this, &RedirectBox::show_redirect_name), src, redirect));
 657         show_redirect_active (redirect);
 658 }
 659
 660 void
 661 RedirectBox::show_redirect_active_r (Redirect* r, void *src, boost::weak_ptr<Redirect> weak_redirect)
 662 {
 663         show_redirect_active (weak_redirect);
 664 }
 665
 666 void
 667 RedirectBox::show_redirect_active (boost::weak_ptr<Redirect> weak_redirect)
 668 {
 669         boost::shared_ptr<Redirect> redirect (weak_redirect.lock());
 670
 671         if (!redirect) {
 672                 return;
 673         }
 674
 675         ENSURE_GUI_THREAD(bind (mem_fun(*this, &RedirectBox::show_redirect_active), weak_redirect));
 676
 677         Gtk::TreeModel::Children children = model->children();
 678         Gtk::TreeModel::Children::iterator iter = children.begin();
 679
 680         while (iter != children.end()) {
 681
 682                 boost::shared_ptr<Redirect> r = (*iter)[columns.redirect];
 683
 684                 if (r == redirect) {
 685                         (*iter)[columns.text] = redirect_name (r);
 686
 687                         if (redirect->active()) {
 688                                 (*iter)[columns.color] = *active_redirect_color;
 689                         } else {
 690                                 (*iter)[columns.color] = *inactive_redirect_color;
 691                         }
 692                         break;
 693                 }
 694
 695                 iter++;
 696         }
 697 }
 698
 699 void
 700 RedirectBox::row_deleted (const Gtk::TreeModel::Path& path)
 701 {
 702         if (!ignore_delete) {
 703                 compute_redirect_sort_keys ();
 704         }
 705 }
 706
 707 void
 708 RedirectBox::compute_redirect_sort_keys ()
 709 {
 710         uint32_t sort_key = 0;
 711         Gtk::TreeModel::Children children = model->children();
 712
 713         for (Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
 714                 boost::shared_ptr<Redirect> r = (*iter)[columns.redirect];
 715                 r->set_sort_key (sort_key);
 716                 sort_key++;
 717         }
 718
 719         if (_route->sort_redirects ()) {
 720
 721                 redisplay_redirects (0);
 722
 723                 /* now tell them about the problem */
 724
 725                 ArdourDialog dialog (_("ardour: weird plugin dialog"));
 726                 Label label;
 727
 728                 label.set_text (_("\
 729 You cannot reorder this set of redirects\n\
 730 in that way because the inputs and\n\
 731 outputs do not work correctly."));
 732
 733                 dialog.get_vbox()->pack_start (label);
 734                 dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
 735
 736                 dialog.set_name (X_("PluginIODialog"));
 737                 dialog.set_position (Gtk::WIN_POS_MOUSE);
 738                 dialog.set_modal (true);
 739                 dialog.show_all ();
 740
 741                 dialog.run ();
 742         }
 743 }
 744
 745 void
 746 RedirectBox::rename_redirects ()
 747 {
 748         vector<boost::shared_ptr<Redirect> > to_be_renamed;
 749
 750         get_selected_redirects (to_be_renamed);
 751
 752         if (to_be_renamed.empty()) {
 753                 return;
 754         }
 755
 756         for (vector<boost::shared_ptr<Redirect> >::iterator i = to_be_renamed.begin(); i != to_be_renamed.end(); ++i) {
 757                 rename_redirect (*i);
 758         }
 759 }
 760
 761 void
 762 RedirectBox::cut_redirects ()
 763 {
 764         vector<boost::shared_ptr<Redirect> > to_be_removed;
 765
 766         get_selected_redirects (to_be_removed);
 767
 768         if (to_be_removed.empty()) {
 769                 return;
 770         }
 771
 772         /* this essentially transfers ownership of the redirect
 773            of the redirect from the route to the mixer
 774            selection.
 775         */
 776
 777         _rr_selection.set (to_be_removed);
 778
 779         no_redirect_redisplay = true;
 780         for (vector<boost::shared_ptr<Redirect> >::iterator i = to_be_removed.begin(); i != to_be_removed.end(); ++i) {
 781                 // Do not cut inserts or sends
 782                 if (boost::dynamic_pointer_cast<PluginInsert>((*i)) != 0) {
 783                         void* gui = (*i)->get_gui ();
 784
 785                         if (gui) {
 786                                 static_cast<Gtk::Widget*>(gui)->hide ();
 787                         }
 788
 789                         if (_route->remove_redirect (*i, this)) {
 790                                 /* removal failed */
 791                                 _rr_selection.remove (*i);
 792                         }
 793                 } else {
 794                         _rr_selection.remove (*i);
 795                 }
 796
 797         }
 798         no_redirect_redisplay = false;
 799         redisplay_redirects (this);
 800 }
 801
 802 void
 803 RedirectBox::copy_redirects ()
 804 {
 805         vector<boost::shared_ptr<Redirect> > to_be_copied;
 806         vector<boost::shared_ptr<Redirect> > copies;
 807
 808         get_selected_redirects (to_be_copied);
 809
 810         if (to_be_copied.empty()) {
 811                 return;
 812         }
 813
 814         for (vector<boost::shared_ptr<Redirect> >::iterator i = to_be_copied.begin(); i != to_be_copied.end(); ++i) {
 815                 // Do not copy inserts or sends
 816                 if (boost::dynamic_pointer_cast<PluginInsert>((*i)) != 0) {
 817                         copies.push_back (Redirect::clone (*i));
 818                 }
 819         }
 820
 821         _rr_selection.set (copies);
 822
 823 }
 824
 825 void
 826 RedirectBox::delete_redirects ()
 827 {
 828         vector<boost::shared_ptr<Redirect> > to_be_deleted;
 829
 830         get_selected_redirects (to_be_deleted);
 831
 832         if (to_be_deleted.empty()) {
 833                 return;
 834         }
 835
 836         for (vector<boost::shared_ptr<Redirect> >::iterator i = to_be_deleted.begin(); i != to_be_deleted.end(); ++i) {
 837
 838                 void* gui = (*i)->get_gui ();
 839
 840                 if (gui) {
 841                         static_cast<Gtk::Widget*>(gui)->hide ();
 842                 }
 843
 844                 _route->remove_redirect( *i, this);
 845         }
 846
 847         no_redirect_redisplay = false;
 848         redisplay_redirects (this);
 849 }
 850
 851 gint
 852 RedirectBox::idle_delete_redirect (boost::weak_ptr<Redirect> weak_redirect)
 853 {
 854         boost::shared_ptr<Redirect> redirect (weak_redirect.lock());
 855
 856         if (!redirect) {
 857                 return false;
 858         }
 859
 860         /* NOT copied to _mixer.selection() */
 861
 862         no_redirect_redisplay = true;
 863         _route->remove_redirect (redirect, this);
 864         no_redirect_redisplay = false;
 865         redisplay_redirects (this);
 866
 867         return false;
 868 }
 869
 870 void
 871 RedirectBox::rename_redirect (boost::shared_ptr<Redirect> redirect)
 872 {
 873         ArdourPrompter name_prompter (true);
 874         string result;
 875         name_prompter.set_prompt (_("rename redirect"));
 876         name_prompter.set_initial_text (redirect->name());
 877         name_prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
 878         name_prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
 879         name_prompter.show_all ();
 880
 881         switch (name_prompter.run ()) {
 882
 883         case Gtk::RESPONSE_ACCEPT:
 884         name_prompter.get_result (result);
 885         if (result.length()) {
 886                         redirect->set_name (result, this);
 887                 }
 888                 break;
 889         }
 890
 891         return;
 892 }
 893
 894 void
 895 RedirectBox::cut_redirect (boost::shared_ptr<Redirect> redirect)
 896 {
 897         /* this essentially transfers ownership of the redirect
 898            of the redirect from the route to the mixer
 899            selection.
 900         */
 901
 902         _rr_selection.add (redirect);
 903
 904         void* gui = redirect->get_gui ();
 905
 906         if (gui) {
 907                 static_cast<Gtk::Widget*>(gui)->hide ();
 908         }
 909
 910         no_redirect_redisplay = true;
 911         if (_route->remove_redirect (redirect, this)) {
 912                 _rr_selection.remove (redirect);
 913         }
 914         no_redirect_redisplay = false;
 915         redisplay_redirects (this);
 916 }
 917
 918 void
 919 RedirectBox::copy_redirect (boost::shared_ptr<Redirect> redirect)
 920 {
 921         boost::shared_ptr<Redirect> copy = Redirect::clone (redirect);
 922         _rr_selection.add (copy);
 923 }
 924
 925 void
 926 RedirectBox::paste_redirects ()
 927 {
 928         if (_rr_selection.redirects.empty()) {
 929                 return;
 930         }
 931
 932         paste_redirect_list (_rr_selection.redirects);
 933 }
 934
 935 void
 936 RedirectBox::paste_redirect_list (list<boost::shared_ptr<Redirect> >& redirects)
 937 {
 938         list<boost::shared_ptr<Redirect> > copies;
 939
 940         for (list<boost::shared_ptr<Redirect> >::iterator i = redirects.begin(); i != redirects.end(); ++i) {
 941
 942                 boost::shared_ptr<Redirect> copy = Redirect::clone (*i);
 943
 944                 copy->set_placement (_placement, this);
 945                 copies.push_back (copy);
 946         }
 947
 948         if (_route->add_redirects (copies, this)) {
 949
 950                 string msg = _(
 951                         "Copying the set of redirects on the clipboard failed,\n\
 952 probably because the I/O configuration of the plugins\n\
 953 could not match the configuration of this track.");
 954                 MessageDialog am (msg);
 955                 am.run ();
 956         }
 957 }
 958
 959 void
 960 RedirectBox::activate_redirect (boost::shared_ptr<Redirect> r)
 961 {
 962         r->set_active (true, 0);
 963 }
 964
 965 void
 966 RedirectBox::deactivate_redirect (boost::shared_ptr<Redirect> r)
 967 {
 968         r->set_active (false, 0);
 969 }
 970
 971 void
 972 RedirectBox::get_selected_redirects (vector<boost::shared_ptr<Redirect> >& redirects)
 973 {
 974     vector<Gtk::TreeModel::Path> pathlist = redirect_display.get_selection()->get_selected_rows();
 975
 976     for (vector<Gtk::TreeModel::Path>::iterator iter = pathlist.begin(); iter != pathlist.end(); ++iter) {
 977             redirects.push_back ((*(model->get_iter(*iter)))[columns.redirect]);
 978     }
 979 }
 980
 981 void
 982 RedirectBox::for_selected_redirects (void (RedirectBox::*pmf)(boost::shared_ptr<Redirect>))
 983 {
 984     vector<Gtk::TreeModel::Path> pathlist = redirect_display.get_selection()->get_selected_rows();
 985
 986         for (vector<Gtk::TreeModel::Path>::iterator iter = pathlist.begin(); iter != pathlist.end(); ++iter) {
 987                 boost::shared_ptr<Redirect> redirect = (*(model->get_iter(*iter)))[columns.redirect];
 988                 (this->*pmf)(redirect);
 989         }
 990 }
 991
 992 void
 993 RedirectBox::clone_redirects ()
 994 {
 995         RouteSelection& routes (_rr_selection.routes);
 996
 997         if (!routes.empty()) {
 998                 if (_route->copy_redirects (*routes.front(), _placement)) {
 999                         string msg = _(
1000 "Copying the set of redirects on the clipboard failed,\n\
1001 probably because the I/O configuration of the plugins\n\
1002 could not match the configuration of this track.");
1003                         MessageDialog am (msg);
1004                         am.run ();
1005                 }
1006         }
1007 }
1008
1009 void
1010 RedirectBox::all_redirects_active (bool state)
1011 {
1012         _route->all_redirects_active (_placement, state);
1013 }
1014
1015 void
1016 RedirectBox::clear_redirects ()
1017 {
1018         string prompt;
1019         vector<string> choices;
1020
1021         if (boost::dynamic_pointer_cast<AudioTrack>(_route) != 0) {
1022                 if (_placement == PreFader) {
1023                         prompt = _("Do you really want to remove all pre-fader redirects from this track?\n"
1024                                    "(this cannot be undone)");
1025                 } else {
1026                         prompt = _("Do you really want to remove all post-fader redirects from this track?\n"
1027                                    "(this cannot be undone)");
1028                 }
1029         } else {
1030                 if (_placement == PreFader) {
1031                         prompt = _("Do you really want to remove all pre-fader redirects from this bus?\n"
1032                                    "(this cannot be undone)");
1033                 } else {
1034                         prompt = _("Do you really want to remove all post-fader redirects from this bus?\n"
1035                                    "(this cannot be undone)");
1036                 }
1037         }
1038
1039         choices.push_back (_("Cancel"));
1040         choices.push_back (_("Yes, remove them all"));
1041
1042         Gtkmm2ext::Choice prompter (prompt, choices);
1043
1044         if (prompter.run () == 1) {
1045                 _route->clear_redirects (_placement, this);
1046         }
1047 }
1048
1049 void
1050 RedirectBox::edit_redirect (boost::shared_ptr<Redirect> redirect)
1051 {
1052         boost::shared_ptr<Insert> insert;
1053
1054         if (boost::dynamic_pointer_cast<AudioTrack>(_route) != 0) {
1055
1056                 if (boost::dynamic_pointer_cast<AudioTrack> (_route)->freeze_state() == AudioTrack::Frozen) {
1057                         return;
1058                 }
1059         }
1060
1061         if ((insert = boost::dynamic_pointer_cast<Insert> (redirect)) == 0) {
1062
1063                 /* it's a send */
1064
1065                 if (!_session.engine().connected()) {
1066                         return;
1067                 }
1068
1069                 boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (redirect);
1070
1071                 SendUIWindow *send_ui;
1072
1073                 if (send->get_gui() == 0) {
1074
1075                         send_ui = new SendUIWindow (send, _session);
1076
1077                         WindowTitle title(Glib::get_application_name());
1078                         title += send->name();
1079                         send_ui->set_title (title.get_string());
1080
1081                         send->set_gui (send_ui);
1082
1083                 } else {
1084                         send_ui = reinterpret_cast<SendUIWindow *> (send->get_gui());
1085                 }
1086
1087                 if (send_ui->is_visible()) {
1088                         send_ui->get_window()->raise ();
1089                 } else {
1090                         send_ui->show_all ();
1091                         send_ui->present ();
1092                 }
1093
1094         } else {
1095
1096                 /* it's an insert */
1097
1098                 boost::shared_ptr<PluginInsert> plugin_insert;
1099                 boost::shared_ptr<PortInsert> port_insert;
1100
1101                 if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (insert)) != 0) {
1102
1103                         PluginUIWindow *plugin_ui;
1104
1105                         /* these are both allowed to be null */
1106
1107                         Container* toplevel = get_toplevel();
1108                         Window* win = dynamic_cast<Gtk::Window*>(toplevel);
1109
1110                         if (plugin_insert->get_gui() == 0) {
1111
1112                                 plugin_ui = new PluginUIWindow (win, plugin_insert);
1113
1114                                 WindowTitle title(Glib::get_application_name());
1115                                 title += generate_redirect_title (plugin_insert);
1116                                 plugin_ui->set_title (title.get_string());
1117
1118                                 plugin_insert->set_gui (plugin_ui);
1119
1120                                 // change window title when route name is changed
1121                                 _route->name_changed.connect (bind (mem_fun(*this, &RedirectBox::route_name_changed), plugin_ui, boost::weak_ptr<PluginInsert> (plugin_insert)));
1122
1123                         } else {
1124                                 plugin_ui = reinterpret_cast<PluginUIWindow *> (plugin_insert->get_gui());
1125                                 plugin_ui->set_parent (win);
1126                         }
1127
1128                         if (plugin_ui->is_visible()) {
1129                                 plugin_ui->get_window()->raise ();
1130                         } else {
1131                                 plugin_ui->show_all ();
1132                                 plugin_ui->present ();
1133                         }
1134
1135                 } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (insert)) != 0) {
1136
1137                         if (!_session.engine().connected()) {
1138                                 MessageDialog msg ( _("Not connected to JACK - no I/O changes are possible"));
1139                                 msg.run ();
1140                                 return;
1141                         }
1142
1143                         PortInsertWindow *io_selector;
1144
1145                         if (port_insert->get_gui() == 0) {
1146                                 io_selector = new PortInsertWindow (_session, port_insert);
1147                                 port_insert->set_gui (io_selector);
1148
1149                         } else {
1150                                 io_selector = reinterpret_cast<PortInsertWindow *> (port_insert->get_gui());
1151                         }
1152
1153                         if (io_selector->is_visible()) {
1154                                 io_selector->get_window()->raise ();
1155                         } else {
1156                                 io_selector->show_all ();
1157                                 io_selector->present ();
1158                         }
1159                 }
1160         }
1161 }
1162
1163 bool
1164 RedirectBox::enter_box (GdkEventCrossing *ev, RedirectBox* rb)
1165 {
1166         switch (ev->detail) {
1167         case GDK_NOTIFY_INFERIOR:
1168                 break;
1169
1170         case GDK_NOTIFY_VIRTUAL:
1171                 /* fallthru */
1172
1173         default:
1174                 _current_redirect_box = rb;
1175         }
1176
1177         return false;
1178 }
1179
1180 void
1181 RedirectBox::register_actions ()
1182 {
1183         Glib::RefPtr<Gtk::ActionGroup> popup_act_grp = Gtk::ActionGroup::create(X_("redirectmenu"));
1184         Glib::RefPtr<Action> act;
1185
1186         /* new stuff */
1187         ActionManager::register_action (popup_act_grp, X_("newplugin"), _("New Plugin"),  sigc::ptr_fun (RedirectBox::rb_choose_plugin));
1188
1189         act = ActionManager::register_action (popup_act_grp, X_("newinsert"), _("New Insert"),  sigc::ptr_fun (RedirectBox::rb_choose_insert));
1190         ActionManager::jack_sensitive_actions.push_back (act);
1191         act = ActionManager::register_action (popup_act_grp, X_("newsend"), _("New Send ..."),  sigc::ptr_fun (RedirectBox::rb_choose_send));
1192         ActionManager::jack_sensitive_actions.push_back (act);
1193
1194         ActionManager::register_action (popup_act_grp, X_("clear"), _("Clear"),  sigc::ptr_fun (RedirectBox::rb_clear));
1195
1196         /* standard editing stuff */
1197         act = ActionManager::register_action (popup_act_grp, X_("cut"), _("Cut"),  sigc::ptr_fun (RedirectBox::rb_cut));
1198         ActionManager::plugin_selection_sensitive_actions.push_back(act);
1199         act = ActionManager::register_action (popup_act_grp, X_("copy"), _("Copy"),  sigc::ptr_fun (RedirectBox::rb_copy));
1200         ActionManager::plugin_selection_sensitive_actions.push_back(act);
1201
1202         act = ActionManager::register_action (popup_act_grp, X_("delete"), _("Delete"),  sigc::ptr_fun (RedirectBox::rb_delete));
1203         ActionManager::plugin_selection_sensitive_actions.push_back(act); // ??
1204
1205         paste_action = ActionManager::register_action (popup_act_grp, X_("paste"), _("Paste"),  sigc::ptr_fun (RedirectBox::rb_paste));
1206         act = ActionManager::register_action (popup_act_grp, X_("rename"), _("Rename"),  sigc::ptr_fun (RedirectBox::rb_rename));
1207         ActionManager::plugin_selection_sensitive_actions.push_back(act);
1208         ActionManager::register_action (popup_act_grp, X_("selectall"), _("Select All"),  sigc::ptr_fun (RedirectBox::rb_select_all));
1209         ActionManager::register_action (popup_act_grp, X_("deselectall"), _("Deselect All"),  sigc::ptr_fun (RedirectBox::rb_deselect_all));
1210
1211         /* activation */
1212         act = ActionManager::register_action (popup_act_grp, X_("activate"), _("Activate"),  sigc::ptr_fun (RedirectBox::rb_activate));
1213         ActionManager::plugin_selection_sensitive_actions.push_back(act);
1214         act = ActionManager::register_action (popup_act_grp, X_("deactivate"), _("Deactivate"),  sigc::ptr_fun (RedirectBox::rb_deactivate));
1215         ActionManager::plugin_selection_sensitive_actions.push_back(act);
1216         ActionManager::register_action (popup_act_grp, X_("activate_all"), _("Activate all"),  sigc::ptr_fun (RedirectBox::rb_activate_all));
1217         ActionManager::register_action (popup_act_grp, X_("deactivate_all"), _("Deactivate all"),  sigc::ptr_fun (RedirectBox::rb_deactivate_all));
1218
1219         /* show editors */
1220         act = ActionManager::register_action (popup_act_grp, X_("edit"), _("Edit"),  sigc::ptr_fun (RedirectBox::rb_edit));
1221         ActionManager::plugin_selection_sensitive_actions.push_back(act);
1222
1223         ActionManager::add_action_group (popup_act_grp);
1224
1225
1226 }
1227
1228 void
1229 RedirectBox::rb_choose_plugin ()
1230 {
1231         if (_current_redirect_box == 0) {
1232                 return;
1233         }
1234         _current_redirect_box->choose_plugin ();
1235 }
1236
1237 void
1238 RedirectBox::rb_choose_insert ()
1239 {
1240         if (_current_redirect_box == 0) {
1241                 return;
1242         }
1243         _current_redirect_box->choose_insert ();
1244 }
1245
1246 void
1247 RedirectBox::rb_choose_send ()
1248 {
1249         if (_current_redirect_box == 0) {
1250                 return;
1251         }
1252         _current_redirect_box->choose_send ();
1253 }
1254
1255 void
1256 RedirectBox::rb_clear ()
1257 {
1258         if (_current_redirect_box == 0) {
1259                 return;
1260         }
1261
1262         _current_redirect_box->clear_redirects ();
1263 }
1264
1265 void
1266 RedirectBox::rb_cut ()
1267 {
1268         if (_current_redirect_box == 0) {
1269                 return;
1270         }
1271
1272         _current_redirect_box->cut_redirects ();
1273 }
1274
1275 void
1276 RedirectBox::rb_delete ()
1277 {
1278         if (_current_redirect_box == 0) {
1279                 return;
1280         }
1281
1282         _current_redirect_box->delete_redirects ();
1283 }
1284
1285 void
1286 RedirectBox::rb_copy ()
1287 {
1288         if (_current_redirect_box == 0) {
1289                 return;
1290         }
1291         _current_redirect_box->copy_redirects ();
1292 }
1293
1294 void
1295 RedirectBox::rb_paste ()
1296 {
1297         if (_current_redirect_box == 0) {
1298                 return;
1299         }
1300
1301         _current_redirect_box->paste_redirects ();
1302 }
1303
1304 void
1305 RedirectBox::rb_rename ()
1306 {
1307         if (_current_redirect_box == 0) {
1308                 return;
1309         }
1310         _current_redirect_box->rename_redirects ();
1311 }
1312
1313 void
1314 RedirectBox::rb_select_all ()
1315 {
1316         if (_current_redirect_box == 0) {
1317                 return;
1318         }
1319
1320         _current_redirect_box->select_all_redirects ();
1321 }
1322
1323 void
1324 RedirectBox::rb_deselect_all ()
1325 {
1326         if (_current_redirect_box == 0) {
1327                 return;
1328         }
1329
1330         _current_redirect_box->deselect_all_redirects ();
1331 }
1332
1333 void
1334 RedirectBox::rb_activate ()
1335 {
1336         if (_current_redirect_box == 0) {
1337                 return;
1338         }
1339
1340         _current_redirect_box->for_selected_redirects (&RedirectBox::activate_redirect);
1341 }
1342
1343 void
1344 RedirectBox::rb_deactivate ()
1345 {
1346         if (_current_redirect_box == 0) {
1347                 return;
1348         }
1349         _current_redirect_box->for_selected_redirects (&RedirectBox::deactivate_redirect);
1350 }
1351
1352 void
1353 RedirectBox::rb_activate_all ()
1354 {
1355         if (_current_redirect_box == 0) {
1356                 return;
1357         }
1358
1359         _current_redirect_box->all_redirects_active (true);
1360 }
1361
1362 void
1363 RedirectBox::rb_deactivate_all ()
1364 {
1365         if (_current_redirect_box == 0) {
1366                 return;
1367         }
1368         _current_redirect_box->all_redirects_active (false);
1369 }
1370
1371 void
1372 RedirectBox::rb_edit ()
1373 {
1374         if (_current_redirect_box == 0) {
1375                 return;
1376         }
1377
1378         _current_redirect_box->for_selected_redirects (&RedirectBox::edit_redirect);
1379 }
1380
1381 void
1382 RedirectBox::route_name_changed (void* src, PluginUIWindow* plugin_ui, boost::weak_ptr<PluginInsert> wpi)
1383 {
1384         ENSURE_GUI_THREAD(bind (mem_fun (*this, &RedirectBox::route_name_changed), src, plugin_ui, wpi));
1385         boost::shared_ptr<PluginInsert> pi (wpi.lock());
1386
1387
1388         if (pi) {
1389                 WindowTitle title(Glib::get_application_name());
1390                 title += generate_redirect_title (pi);
1391                 plugin_ui->set_title (title.get_string());
1392         }
1393 }
1394
1395 string
1396 RedirectBox::generate_redirect_title (boost::shared_ptr<PluginInsert> pi)
1397 {
1398         string maker = pi->plugin()->maker() ? pi->plugin()->maker() : "";
1399         string::size_type email_pos;
1400
1401         if ((email_pos = maker.find_first_of ('<')) != string::npos) {
1402                 maker = maker.substr (0, email_pos - 1);
1403         }
1404
1405         if (maker.length() > 32) {
1406                 maker = maker.substr (0, 32);
1407                 maker += " ...";
1408         }
1409
1410         return string_compose(_("%1: %2 (by %3)"), _route->name(), pi->name(), maker);
1411 }
1412
1413 void
1414 RedirectBox::plugin_selector_hidden ()
1415 {
1416         newplug_connection.disconnect();
1417         using_plugin_selector = false;
1418 }
1419
1420 void
1421 RedirectBox::plugin_selector_shown ()
1422 {
1423         using_plugin_selector = true;
1424 }