gtk2_ardour/plugin_selector.cc

   1 /*
   2     Copyright (C) 2000-2006 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 #ifdef WAF_BUILD
  20 #include "gtk2ardour-config.h"
  21 #endif
  22
  23 #include <cstdio>
  24 #include <map>
  25
  26 #include <algorithm>
  27
  28 #include <gtkmm/table.h>
  29 #include <gtkmm/stock.h>
  30 #include <gtkmm/button.h>
  31 #include <gtkmm/notebook.h>
  32
  33 #include <gtkmm2ext/utils.h>
  34
  35 #include "pbd/convert.h"
  36
  37 #include "ardour/plugin_manager.h"
  38 #include "ardour/plugin.h"
  39 #include "ardour/utils.h"
  40
  41 #include "plugin_selector.h"
  42 #include "gui_thread.h"
  43 #include "tooltips.h"
  44
  45 #include "i18n.h"
  46
  47 using namespace ARDOUR;
  48 using namespace PBD;
  49 using namespace Gtk;
  50 using namespace std;
  51 using namespace ARDOUR_UI_UTILS;
  52
  53 static const char* _filter_mode_strings[] = {
  54         N_("Name contains"),
  55         N_("Type contains"),
  56         N_("Category contains"),
  57         N_("Author contains"),
  58         N_("Library contains"),
  59         N_("Favorites only"),
  60         N_("Hidden only"),
  61         0
  62 };
  63
  64 PluginSelector::PluginSelector (PluginManager& mgr)
  65         : ArdourDialog (_("Plugin Manager"), true, false)
  66         , filter_button (Stock::CLEAR)
  67         , fil_hidden_button (ArdourButton::led_default_elements)
  68         , fil_instruments_button (ArdourButton::default_elements)
  69         , fil_analysis_button (ArdourButton::default_elements)
  70         , fil_utils_button (ArdourButton::default_elements)
  71         , manager (mgr)
  72         , _show_hidden (false)
  73         , _show_instruments (Gtkmm2ext::ImplicitActive)
  74         , _show_analysers (Gtkmm2ext::Off)
  75         , _show_utils (Gtkmm2ext::Off)
  76
  77 {
  78         set_name ("PluginSelectorWindow");
  79         add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
  80
  81         _plugin_menu = 0;
  82         in_row_change = false;
  83
  84         manager.PluginListChanged.connect (plugin_list_changed_connection, invalidator (*this), boost::bind (&PluginSelector::build_plugin_menu, this), gui_context());
  85         manager.PluginListChanged.connect (plugin_list_changed_connection, invalidator (*this), boost::bind (&PluginSelector::refill, this), gui_context());
  86         build_plugin_menu ();
  87
  88         plugin_model = Gtk::ListStore::create (plugin_columns);
  89         plugin_display.set_model (plugin_model);
  90         /* XXX translators: try to convert "Fav" into a short term
  91            related to "favorite" and "Hid" into a short term
  92            related to "hidden"
  93         */
  94         plugin_display.append_column (_("Fav"), plugin_columns.favorite);
  95         plugin_display.append_column (_("Hide"), plugin_columns.hidden);
  96         plugin_display.append_column (_("Available Plugins"), plugin_columns.name);
  97         plugin_display.append_column (_("Type"), plugin_columns.type_name);
  98         plugin_display.append_column (_("Category"), plugin_columns.category);
  99         plugin_display.append_column (_("Creator"), plugin_columns.creator);
 100         plugin_display.append_column (_("# Audio In"),plugin_columns.audio_ins);
 101         plugin_display.append_column (_("# Audio Out"), plugin_columns.audio_outs);
 102         plugin_display.append_column (_("# MIDI In"),plugin_columns.midi_ins);
 103         plugin_display.append_column (_("# MIDI Out"), plugin_columns.midi_outs);
 104         plugin_display.set_headers_visible (true);
 105         plugin_display.set_headers_clickable (true);
 106         plugin_display.set_reorderable (false);
 107         plugin_display.set_rules_hint (true);
 108         plugin_display.add_object_drag (plugin_columns.plugin.index(), "PluginInfoPtr");
 109
 110         // setting a sort-column prevents re-ordering via Drag/Drop
 111         plugin_model->set_sort_column (plugin_columns.name.index(), Gtk::SORT_ASCENDING);
 112
 113         CellRendererToggle* fav_cell = dynamic_cast<CellRendererToggle*>(plugin_display.get_column_cell_renderer (0));
 114         fav_cell->property_activatable() = true;
 115         fav_cell->property_radio() = true;
 116         fav_cell->signal_toggled().connect (sigc::mem_fun (*this, &PluginSelector::favorite_changed));
 117
 118         CellRendererToggle* hidden_cell = dynamic_cast<CellRendererToggle*>(plugin_display.get_column_cell_renderer (1));
 119         hidden_cell->property_activatable() = true;
 120         hidden_cell->property_radio() = true;
 121         hidden_cell->signal_toggled().connect (sigc::mem_fun (*this, &PluginSelector::hidden_changed));
 122
 123         scroller.set_border_width(10);
 124         scroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 125         scroller.add(plugin_display);
 126
 127         amodel = Gtk::ListStore::create(acols);
 128         added_list.set_model (amodel);
 129         added_list.append_column (_("Plugins to be connected"), acols.text);
 130         added_list.set_headers_visible (true);
 131         added_list.set_reorderable (false);
 132
 133         for (int i = 0; i <=8; i++) {
 134                 Gtk::TreeView::Column* column = plugin_display.get_column(i);
 135                 column->set_sort_column(i);
 136         }
 137
 138         ascroller.set_border_width(10);
 139         ascroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 140         ascroller.add(added_list);
 141         btn_add = manage(new Gtk::Button(Stock::ADD));
 142         set_tooltip(*btn_add, _("Add a plugin to the effect list"));
 143         btn_add->set_sensitive (false);
 144         btn_remove = manage(new Gtk::Button(Stock::REMOVE));
 145         btn_remove->set_sensitive (false);
 146         set_tooltip(*btn_remove, _("Remove a plugin from the effect list"));
 147
 148         btn_add->set_name("PluginSelectorButton");
 149         btn_remove->set_name("PluginSelectorButton");
 150
 151
 152         Gtk::Table* table = manage(new Gtk::Table(7, 11));
 153         table->set_size_request(750, 500);
 154
 155         Gtk::Table* filter_table = manage(new Gtk::Table(2, 5));
 156
 157         fil_hidden_button.set_name ("pluginlist hide button");
 158         fil_hidden_button.set_text (_("Show Hidden"));
 159         fil_hidden_button.set_active (_show_hidden);
 160         set_tooltip (fil_hidden_button, _("Include hidden plugins in list."));
 161
 162         fil_instruments_button.set_name ("pluginlist filter button");
 163         fil_instruments_button.set_text (_("Instruments"));
 164         fil_instruments_button.set_active_state (_show_instruments);
 165         set_tooltip (fil_instruments_button, _("Cycle display of instrument plugins (if any)."));
 166
 167         fil_analysis_button.set_name ("pluginlist filter button");
 168         fil_analysis_button.set_text (_("Analyzers"));
 169         fil_analysis_button.set_active_state (_show_analysers);
 170         set_tooltip (fil_analysis_button, _("Cycle display of analysis plugins (if any)."));
 171
 172         fil_utils_button.set_name ("pluginlist filter button");
 173         fil_utils_button.set_text (_("Utils"));
 174         fil_utils_button.set_active_state (_show_utils);
 175         set_tooltip (fil_utils_button, _("Cycle display of utility plugins (if any)."));
 176
 177         vector<string> filter_strings = I18N (_filter_mode_strings);
 178         Gtkmm2ext::set_popdown_strings (filter_mode, filter_strings);
 179         filter_mode.set_active_text (filter_strings.front());
 180
 181         fil_hidden_button.signal_button_release_event().connect (sigc::mem_fun(*this, &PluginSelector::fil_hidden_button_release), false);
 182         fil_instruments_button.signal_button_release_event().connect (sigc::mem_fun(*this, &PluginSelector::fil_instruments_button_release), false);
 183         fil_analysis_button.signal_button_release_event().connect (sigc::mem_fun(*this, &PluginSelector::fil_analysis_button_release), false);
 184         fil_utils_button.signal_button_release_event().connect (sigc::mem_fun(*this, &PluginSelector::fil_utils_button_release), false);
 185
 186         filter_entry.signal_changed().connect (sigc::mem_fun (*this, &PluginSelector::filter_entry_changed));
 187         filter_button.signal_clicked().connect (sigc::mem_fun (*this, &PluginSelector::filter_button_clicked));
 188         filter_mode.signal_changed().connect (sigc::mem_fun (*this, &PluginSelector::filter_mode_changed));
 189
 190         filter_table->attach (filter_mode,            0, 1, 0, 1, FILL, FILL);
 191         filter_table->attach (filter_entry,           1, 4, 0, 1, FILL|EXPAND, FILL);
 192         filter_table->attach (filter_button,          4, 5, 0, 1, FILL, FILL);
 193
 194         filter_table->attach (fil_hidden_button,      1, 2, 1, 2, FILL, FILL);
 195         filter_table->attach (fil_instruments_button, 2, 3, 1, 2, FILL, FILL);
 196         filter_table->attach (fil_analysis_button,    3, 4, 1, 2, FILL, FILL);
 197         filter_table->attach (fil_utils_button,       4, 5, 1, 2, FILL, FILL);
 198
 199         filter_table->set_border_width (4);
 200         filter_table->set_col_spacings (2);
 201         filter_table->set_row_spacings (4);
 202
 203         Frame* filter_frame = manage (new Frame);
 204         filter_frame->set_name ("BaseFrame");
 205         filter_frame->set_label (_("Filter"));
 206         filter_frame->add (*filter_table);
 207
 208         filter_frame->show_all ();
 209
 210         table->attach (scroller, 0, 7, 0, 5);
 211         table->attach (*filter_frame, 0, 7, 6, 7, FILL|EXPAND, FILL, 5, 5);
 212         table->attach(*btn_add, 1, 2, 7, 8, FILL, FILL, 5, 5);
 213         table->attach(*btn_remove, 5, 6, 7, 8, FILL, FILL, 5, 5);
 214
 215         table->attach(ascroller, 0, 7, 8, 10);
 216
 217         add_button (Stock::CLOSE, RESPONSE_CLOSE);
 218         add_button (_("Insert Plugin(s)"), RESPONSE_APPLY);
 219         set_default_response (RESPONSE_APPLY);
 220         set_response_sensitive (RESPONSE_APPLY, false);
 221         get_vbox()->pack_start (*table);
 222
 223         table->set_name("PluginSelectorTable");
 224         plugin_display.set_name("PluginSelectorDisplay");
 225         //plugin_display.set_name("PluginSelectorList");
 226         added_list.set_name("PluginSelectorList");
 227
 228         plugin_display.signal_row_activated().connect_notify (sigc::mem_fun(*this, &PluginSelector::row_activated));
 229         plugin_display.get_selection()->signal_changed().connect (sigc::mem_fun(*this, &PluginSelector::display_selection_changed));
 230         plugin_display.grab_focus();
 231
 232         btn_add->signal_clicked().connect(sigc::mem_fun(*this, &PluginSelector::btn_add_clicked));
 233         btn_remove->signal_clicked().connect(sigc::mem_fun(*this, &PluginSelector::btn_remove_clicked));
 234         added_list.get_selection()->signal_changed().connect (sigc::mem_fun(*this, &PluginSelector::added_list_selection_changed));
 235         added_list.signal_button_press_event().connect_notify (mem_fun(*this, &PluginSelector::added_row_clicked));
 236
 237         refill ();
 238 }
 239
 240 PluginSelector::~PluginSelector ()
 241 {
 242         delete _plugin_menu;
 243 }
 244
 245 void
 246 PluginSelector::row_activated(Gtk::TreeModel::Path, Gtk::TreeViewColumn*)
 247 {
 248         btn_add_clicked();
 249 }
 250
 251 void
 252 PluginSelector::added_row_clicked(GdkEventButton* event)
 253 {
 254         if (event->type == GDK_2BUTTON_PRESS)
 255                 btn_remove_clicked();
 256 }
 257
 258 bool
 259 PluginSelector::show_this_plugin (const PluginInfoPtr& info, const std::string& filterstr)
 260 {
 261         std::string compstr;
 262         std::string mode = filter_mode.get_active_text ();
 263
 264         if (mode == _("Favorites only")) {
 265                 return manager.get_status (info) == PluginManager::Favorite;
 266         }
 267
 268         if (mode == _("Hidden only")) {
 269                 return manager.get_status (info) == PluginManager::Hidden;
 270         }
 271
 272         if (!_show_hidden && manager.get_status (info) == PluginManager::Hidden) {
 273                 return false;
 274         }
 275
 276         if (_show_instruments == Gtkmm2ext::Off && info->is_instrument()) {
 277                 return false;
 278         }
 279         if (_show_analysers == Gtkmm2ext::Off && info->in_category ("Analyser")) {
 280                 return false;
 281         }
 282         if (_show_utils == Gtkmm2ext::Off && info->in_category ("Utility")) {
 283                 return false;
 284         }
 285
 286         /* NB once lilv_node_as_string() does honor translation AND
 287          * the lv2 onthology provides localized class name,
 288          * PluginInfo will need methods for Util & Analysis.
 289          */
 290         bool exp_ok = false;
 291         if (_show_instruments == Gtkmm2ext::ExplicitActive && info->is_instrument()) {
 292                 exp_ok = true;
 293         }
 294         if (_show_analysers == Gtkmm2ext::ExplicitActive && info->in_category ("Analyser")) {
 295                 exp_ok = true;
 296         }
 297         if (_show_utils == Gtkmm2ext::ExplicitActive && info->in_category ("Utility")) {
 298                 exp_ok = true;
 299         }
 300         if (_show_instruments == Gtkmm2ext::ExplicitActive  || _show_analysers == Gtkmm2ext::ExplicitActive || _show_utils == Gtkmm2ext::ExplicitActive) {
 301                 if (!exp_ok) {
 302                         return false;
 303                 }
 304         }
 305
 306         if (!filterstr.empty()) {
 307
 308                 if (mode == _("Name contains")) {
 309                         compstr = info->name;
 310                 } else if (mode == _("Category contains")) {
 311                         compstr = info->category;
 312                 } else if (mode == _("Type contains")) {
 313
 314                         switch (info->type) {
 315                         case LADSPA:
 316                                 compstr = X_("LADSPA");
 317                                 break;
 318                         case AudioUnit:
 319                                 compstr = X_("AudioUnit");
 320                                 break;
 321                         case LV2:
 322                                 compstr = X_("LV2");
 323                                 break;
 324                         case Windows_VST:
 325                                 compstr = X_("VST");
 326                                 break;
 327                         case LXVST:
 328                                 compstr = X_("LXVST");
 329                                 break;
 330                         }
 331
 332                 } else if (mode == _("Author contains")) {
 333                         compstr = info->creator;
 334                 } else if (mode == _("Library contains")) {
 335                         compstr = info->path;
 336                 }
 337
 338                 if (compstr.empty()) {
 339                         return false;
 340                 }
 341
 342                 transform (compstr.begin(), compstr.end(), compstr.begin(), ::toupper);
 343
 344                 if (compstr.find (filterstr) != string::npos) {
 345                         return true;
 346                 } else {
 347                         return false;
 348                 }
 349         }
 350
 351         return true;
 352 }
 353
 354 void
 355 PluginSelector::setup_filter_string (string& filterstr)
 356 {
 357         filterstr = filter_entry.get_text ();
 358         transform (filterstr.begin(), filterstr.end(), filterstr.begin(), ::toupper);
 359 }
 360
 361 void
 362 PluginSelector::refill ()
 363 {
 364         std::string filterstr;
 365
 366         in_row_change = true;
 367
 368         plugin_model->clear ();
 369
 370         setup_filter_string (filterstr);
 371
 372         ladspa_refiller (filterstr);
 373         lv2_refiller (filterstr);
 374         vst_refiller (filterstr);
 375         lxvst_refiller (filterstr);
 376         au_refiller (filterstr);
 377
 378         in_row_change = false;
 379 }
 380
 381 void
 382 PluginSelector::refiller (const PluginInfoList& plugs, const::std::string& filterstr, const char* type)
 383 {
 384         char buf[16];
 385
 386         for (PluginInfoList::const_iterator i = plugs.begin(); i != plugs.end(); ++i) {
 387
 388                 if (show_this_plugin (*i, filterstr)) {
 389
 390                         TreeModel::Row newrow = *(plugin_model->append());
 391                         newrow[plugin_columns.favorite] = (manager.get_status (*i) == PluginManager::Favorite);
 392                         newrow[plugin_columns.hidden] = (manager.get_status (*i) == PluginManager::Hidden);
 393                         newrow[plugin_columns.name] = (*i)->name;
 394                         newrow[plugin_columns.type_name] = type;
 395                         newrow[plugin_columns.category] = (*i)->category;
 396
 397                         string creator = (*i)->creator;
 398                         string::size_type pos = 0;
 399
 400                         /* stupid LADSPA creator strings */
 401 #ifdef PLATFORM_WINDOWS
 402                         while (pos < creator.length() && creator[pos] > -2 && creator[pos] < 256 && (isalnum (creator[pos]) || isspace (creator[pos]))) ++pos;
 403 #else
 404                         while (pos < creator.length() && (isalnum (creator[pos]) || isspace (creator[pos]))) ++pos;
 405 #endif
 406                         // If there were too few characters to create a
 407                         // meaningful name, mark this creator as 'Unknown'
 408                         if (creator.length()<2 || pos<3)
 409                                 creator = "Unknown";
 410                         else
 411                                 creator = creator.substr (0, pos);
 412
 413                         newrow[plugin_columns.creator] = creator;
 414
 415                         if ((*i)->reconfigurable_io ()) {
 416                                 newrow[plugin_columns.audio_ins] = _("variable");
 417                                 newrow[plugin_columns.midi_ins] = _("variable");
 418                                 newrow[plugin_columns.audio_outs] = _("variable");
 419                                 newrow[plugin_columns.midi_outs] = _("variable");
 420                         } else {
 421                                 snprintf (buf, sizeof(buf), "%d", (*i)->n_inputs.n_audio());
 422                                 newrow[plugin_columns.audio_ins] = buf;
 423                                 snprintf (buf, sizeof(buf), "%d", (*i)->n_inputs.n_midi());
 424                                 newrow[plugin_columns.midi_ins] = buf;
 425
 426                                 snprintf (buf, sizeof(buf), "%d", (*i)->n_outputs.n_audio());
 427                                 newrow[plugin_columns.audio_outs] = buf;
 428                                 snprintf (buf, sizeof(buf), "%d", (*i)->n_outputs.n_midi());
 429                                 newrow[plugin_columns.midi_outs] = buf;
 430                         }
 431
 432                         newrow[plugin_columns.plugin] = *i;
 433                 }
 434         }
 435 }
 436
 437 void
 438 PluginSelector::ladspa_refiller (const std::string& filterstr)
 439 {
 440         refiller (manager.ladspa_plugin_info(), filterstr, "LADSPA");
 441 }
 442
 443 void
 444 PluginSelector::lv2_refiller (const std::string& filterstr)
 445 {
 446 #ifdef LV2_SUPPORT
 447         refiller (manager.lv2_plugin_info(), filterstr, "LV2");
 448 #endif
 449 }
 450
 451 void
 452 #ifdef WINDOWS_VST_SUPPORT
 453 PluginSelector::vst_refiller (const std::string& filterstr)
 454 #else
 455 PluginSelector::vst_refiller (const std::string&)
 456 #endif
 457 {
 458 #ifdef WINDOWS_VST_SUPPORT
 459         refiller (manager.windows_vst_plugin_info(), filterstr, "VST");
 460 #endif
 461 }
 462
 463 void
 464 #ifdef LXVST_SUPPORT
 465 PluginSelector::lxvst_refiller (const std::string& filterstr)
 466 #else
 467 PluginSelector::lxvst_refiller (const std::string&)
 468 #endif
 469 {
 470 #ifdef LXVST_SUPPORT
 471         refiller (manager.lxvst_plugin_info(), filterstr, "LXVST");
 472 #endif
 473 }
 474
 475 void
 476 #ifdef AUDIOUNIT_SUPPORT
 477 PluginSelector::au_refiller (const std::string& filterstr)
 478 #else
 479 PluginSelector::au_refiller (const std::string&)
 480 #endif
 481 {
 482 #ifdef AUDIOUNIT_SUPPORT
 483         refiller (manager.au_plugin_info(), filterstr, "AU");
 484 #endif
 485 }
 486
 487 PluginPtr
 488 PluginSelector::load_plugin (PluginInfoPtr pi)
 489 {
 490         if (_session == 0) {
 491                 return PluginPtr();
 492         }
 493
 494         return pi->load (*_session);
 495 }
 496
 497 void
 498 PluginSelector::btn_add_clicked()
 499 {
 500         std::string name;
 501         PluginInfoPtr pi;
 502         TreeModel::Row newrow = *(amodel->append());
 503         TreeModel::Row row;
 504
 505         row = *(plugin_display.get_selection()->get_selected());
 506         name = row[plugin_columns.name];
 507         pi = row[plugin_columns.plugin];
 508
 509         newrow[acols.text] = name;
 510         newrow[acols.plugin] = pi;
 511
 512         if (!amodel->children().empty()) {
 513                 set_response_sensitive (RESPONSE_APPLY, true);
 514         }
 515 }
 516
 517 void
 518 PluginSelector::btn_remove_clicked()
 519 {
 520         TreeModel::iterator iter = added_list.get_selection()->get_selected();
 521
 522         amodel->erase(iter);
 523         if (amodel->children().empty()) {
 524                 set_response_sensitive (RESPONSE_APPLY, false);
 525         }
 526 }
 527
 528 void
 529 PluginSelector::display_selection_changed()
 530 {
 531         if (plugin_display.get_selection()->count_selected_rows() != 0) {
 532                 btn_add->set_sensitive (true);
 533         } else {
 534                 btn_add->set_sensitive (false);
 535         }
 536 }
 537
 538 void
 539 PluginSelector::added_list_selection_changed()
 540 {
 541         if (added_list.get_selection()->count_selected_rows() != 0) {
 542                 btn_remove->set_sensitive (true);
 543         } else {
 544                 btn_remove->set_sensitive (false);
 545         }
 546 }
 547
 548 int
 549 PluginSelector::run ()
 550 {
 551         ResponseType r;
 552         TreeModel::Children::iterator i;
 553
 554         bool finish = false;
 555
 556         while (!finish) {
 557
 558                 SelectedPlugins plugins;
 559                 r = (ResponseType) Dialog::run ();
 560
 561                 switch (r) {
 562                 case RESPONSE_APPLY:
 563                         for (i = amodel->children().begin(); i != amodel->children().end(); ++i) {
 564                                 PluginInfoPtr pp = (*i)[acols.plugin];
 565                                 PluginPtr p = load_plugin (pp);
 566                                 if (p) {
 567                                         plugins.push_back (p);
 568                                 } else {
 569                                         MessageDialog msg (string_compose (_("The plugin \"%1\" could not be loaded\n\nSee the Log window for more details (maybe)"), pp->name));
 570                                         msg.run ();
 571                                 }
 572                         }
 573                         if (interested_object && !plugins.empty()) {
 574                                 finish = !interested_object->use_plugins (plugins);
 575                         }
 576
 577                         break;
 578
 579                 default:
 580                         finish = true;
 581                         break;
 582                 }
 583         }
 584
 585
 586         hide();
 587         amodel->clear();
 588         interested_object = 0;
 589
 590         return (int) r;
 591 }
 592
 593 void
 594 PluginSelector::filter_button_clicked ()
 595 {
 596         filter_entry.set_text ("");
 597 }
 598
 599 void
 600 PluginSelector::filter_entry_changed ()
 601 {
 602         refill ();
 603 }
 604
 605 void
 606 PluginSelector::filter_mode_changed ()
 607 {
 608         std::string mode = filter_mode.get_active_text ();
 609
 610         if (mode == _("Favorites only") || mode == _("Hidden only")) {
 611                 filter_entry.set_sensitive (false);
 612                 filter_button.set_sensitive (false);
 613                 fil_hidden_button.set_sensitive (false);
 614                 fil_instruments_button.set_sensitive (false);
 615                 fil_analysis_button.set_sensitive (false);
 616                 fil_utils_button.set_sensitive (false);
 617         } else {
 618                 filter_entry.set_sensitive (true);
 619                 filter_button.set_sensitive (true);
 620                 fil_hidden_button.set_sensitive (true);
 621                 fil_instruments_button.set_sensitive (true);
 622                 fil_analysis_button.set_sensitive (true);
 623                 fil_utils_button.set_sensitive (true);
 624         }
 625
 626         refill ();
 627 }
 628
 629 void
 630 PluginSelector::on_show ()
 631 {
 632         ArdourDialog::on_show ();
 633         filter_entry.grab_focus ();
 634 }
 635
 636 struct PluginMenuCompareByCreator {
 637     bool operator() (PluginInfoPtr a, PluginInfoPtr b) const {
 638             int cmp;
 639
 640             cmp = cmp_nocase_utf8 (a->creator, b->creator);
 641
 642             if (cmp < 0) {
 643                     return true;
 644             } else if (cmp == 0) {
 645                     /* same creator ... compare names */
 646                     if (cmp_nocase_utf8 (a->name, b->name) < 0) {
 647                             return true;
 648                     }
 649             }
 650             return false;
 651     }
 652 };
 653
 654 struct PluginMenuCompareByName {
 655     bool operator() (PluginInfoPtr a, PluginInfoPtr b) const {
 656             int cmp;
 657
 658             cmp = cmp_nocase_utf8 (a->name, b->name);
 659
 660             if (cmp < 0) {
 661                     return true;
 662             } else if (cmp == 0) {
 663                     /* same name ... compare type */
 664                     if (a->type < b->type) {
 665                             return true;
 666                     }
 667             }
 668             return false;
 669     }
 670 };
 671
 672 struct PluginMenuCompareByCategory {
 673     bool operator() (PluginInfoPtr a, PluginInfoPtr b) const {
 674             int cmp;
 675
 676             cmp = cmp_nocase_utf8 (a->category, b->category);
 677
 678             if (cmp < 0) {
 679                     return true;
 680             } else if (cmp == 0) {
 681                     /* same category ... compare names */
 682                     if (cmp_nocase_utf8 (a->name, b->name) < 0) {
 683                             return true;
 684                     }
 685             }
 686             return false;
 687     }
 688 };
 689
 690 /** @return Plugin menu. The caller should not delete it */
 691 Gtk::Menu*
 692 PluginSelector::plugin_menu()
 693 {
 694         return _plugin_menu;
 695 }
 696
 697 void
 698 PluginSelector::build_plugin_menu ()
 699 {
 700         PluginInfoList all_plugs;
 701
 702         all_plugs.insert (all_plugs.end(), manager.ladspa_plugin_info().begin(), manager.ladspa_plugin_info().end());
 703 #ifdef WINDOWS_VST_SUPPORT
 704         all_plugs.insert (all_plugs.end(), manager.windows_vst_plugin_info().begin(), manager.windows_vst_plugin_info().end());
 705 #endif
 706 #ifdef LXVST_SUPPORT
 707         all_plugs.insert (all_plugs.end(), manager.lxvst_plugin_info().begin(), manager.lxvst_plugin_info().end());
 708 #endif
 709 #ifdef AUDIOUNIT_SUPPORT
 710         all_plugs.insert (all_plugs.end(), manager.au_plugin_info().begin(), manager.au_plugin_info().end());
 711 #endif
 712 #ifdef LV2_SUPPORT
 713         all_plugs.insert (all_plugs.end(), manager.lv2_plugin_info().begin(), manager.lv2_plugin_info().end());
 714 #endif
 715
 716         using namespace Menu_Helpers;
 717
 718         delete _plugin_menu;
 719
 720         _plugin_menu = manage (new Menu);
 721         _plugin_menu->set_name("ArdourContextMenu");
 722
 723         MenuList& items = _plugin_menu->items();
 724         items.clear ();
 725
 726         Gtk::Menu* favs = create_favs_menu(all_plugs);
 727         items.push_back (MenuElem (_("Favorites"), *manage (favs)));
 728
 729         items.push_back (MenuElem (_("Plugin Manager..."), sigc::mem_fun (*this, &PluginSelector::show_manager)));
 730         items.push_back (SeparatorElem ());
 731
 732         Menu* by_creator = create_by_creator_menu(all_plugs);
 733         items.push_back (MenuElem (_("By Creator"), *manage (by_creator)));
 734
 735         Menu* by_category = create_by_category_menu(all_plugs);
 736         items.push_back (MenuElem (_("By Category"), *manage (by_category)));
 737 }
 738
 739 Gtk::Menu*
 740 PluginSelector::create_favs_menu (PluginInfoList& all_plugs)
 741 {
 742         using namespace Menu_Helpers;
 743
 744         Menu* favs = new Menu();
 745         favs->set_name("ArdourContextMenu");
 746
 747         PluginMenuCompareByName cmp_by_name;
 748         all_plugs.sort (cmp_by_name);
 749
 750         for (PluginInfoList::const_iterator i = all_plugs.begin(); i != all_plugs.end(); ++i) {
 751                 if (manager.get_status (*i) == PluginManager::Favorite) {
 752                         MenuElem elem ((*i)->name, (sigc::bind (sigc::mem_fun (*this, &PluginSelector::plugin_chosen_from_menu), *i)));
 753                         elem.get_child()->set_use_underline (false);
 754                         favs->items().push_back (elem);
 755                 }
 756         }
 757         return favs;
 758 }
 759
 760 Gtk::Menu*
 761 PluginSelector::create_by_creator_menu (ARDOUR::PluginInfoList& all_plugs)
 762 {
 763         using namespace Menu_Helpers;
 764
 765         typedef std::map<std::string,Gtk::Menu*> SubmenuMap;
 766         SubmenuMap creator_submenu_map;
 767
 768         Menu* by_creator = new Menu();
 769         by_creator->set_name("ArdourContextMenu");
 770
 771         MenuList& by_creator_items = by_creator->items();
 772         PluginMenuCompareByCreator cmp_by_creator;
 773         all_plugs.sort (cmp_by_creator);
 774
 775         for (PluginInfoList::const_iterator i = all_plugs.begin(); i != all_plugs.end(); ++i) {
 776
 777                 if (manager.get_status (*i) == PluginManager::Hidden) continue;
 778
 779                 string creator = (*i)->creator;
 780
 781                 /* stupid LADSPA creator strings */
 782                 string::size_type pos = 0;
 783 #ifdef PLATFORM_WINDOWS
 784                 while (pos < creator.length() && creator[pos]>(-2) && creator[pos]<256 && (isprint (creator[pos]))) ++pos;
 785 #else
 786                 while (pos < creator.length() && (isalnum (creator[pos]) || isspace (creator[pos]))) ++pos;
 787 #endif
 788
 789                 // Check to see if we found any invalid characters.
 790                 if (creator.length() != pos) {
 791                         // If there were too few characters to create a
 792                         // meaningful name, mark this creator as 'Unknown'
 793                         if (pos<3)
 794                                 creator = "Unknown?";
 795                         else
 796                                 creator = creator.substr (0, pos);
 797                 }
 798
 799                 SubmenuMap::iterator x;
 800                 Gtk::Menu* submenu;
 801                 if ((x = creator_submenu_map.find (creator)) != creator_submenu_map.end()) {
 802                         submenu = x->second;
 803                 } else {
 804                         submenu = new Gtk::Menu;
 805                         by_creator_items.push_back (MenuElem (creator, *manage (submenu)));
 806                         creator_submenu_map.insert (pair<std::string,Menu*> (creator, submenu));
 807                         submenu->set_name("ArdourContextMenu");
 808                 }
 809                 MenuElem elem ((*i)->name, (sigc::bind (sigc::mem_fun (*this, &PluginSelector::plugin_chosen_from_menu), *i)));
 810                 elem.get_child()->set_use_underline (false);
 811                 submenu->items().push_back (elem);
 812         }
 813         return by_creator;
 814 }
 815
 816 Gtk::Menu*
 817 PluginSelector::create_by_category_menu (ARDOUR::PluginInfoList& all_plugs)
 818 {
 819         using namespace Menu_Helpers;
 820
 821         typedef std::map<std::string,Gtk::Menu*> SubmenuMap;
 822         SubmenuMap category_submenu_map;
 823
 824         Menu* by_category = new Menu();
 825         by_category->set_name("ArdourContextMenu");
 826
 827         MenuList& by_category_items = by_category->items();
 828         PluginMenuCompareByCategory cmp_by_category;
 829         all_plugs.sort (cmp_by_category);
 830
 831         for (PluginInfoList::const_iterator i = all_plugs.begin(); i != all_plugs.end(); ++i) {
 832
 833                 if (manager.get_status (*i) == PluginManager::Hidden) continue;
 834
 835                 string category = (*i)->category;
 836
 837                 SubmenuMap::iterator x;
 838                 Gtk::Menu* submenu;
 839                 if ((x = category_submenu_map.find (category)) != category_submenu_map.end()) {
 840                         submenu = x->second;
 841                 } else {
 842                         submenu = new Gtk::Menu;
 843                         by_category_items.push_back (MenuElem (category, *manage (submenu)));
 844                         category_submenu_map.insert (pair<std::string,Menu*> (category, submenu));
 845                         submenu->set_name("ArdourContextMenu");
 846                 }
 847                 MenuElem elem ((*i)->name, (sigc::bind (sigc::mem_fun (*this, &PluginSelector::plugin_chosen_from_menu), *i)));
 848                 elem.get_child()->set_use_underline (false);
 849                 submenu->items().push_back (elem);
 850         }
 851         return by_category;
 852 }
 853
 854 void
 855 PluginSelector::plugin_chosen_from_menu (const PluginInfoPtr& pi)
 856 {
 857         PluginPtr p = load_plugin (pi);
 858
 859         if (p && interested_object) {
 860                 SelectedPlugins plugins;
 861                 plugins.push_back (p);
 862                 interested_object->use_plugins (plugins);
 863         }
 864
 865         interested_object = 0;
 866 }
 867
 868 void
 869 PluginSelector::favorite_changed (const std::string& path)
 870 {
 871         PluginInfoPtr pi;
 872
 873         if (in_row_change) {
 874                 return;
 875         }
 876
 877         in_row_change = true;
 878
 879         TreeModel::iterator iter = plugin_model->get_iter (path);
 880
 881         if (iter) {
 882
 883                 bool favorite = !(*iter)[plugin_columns.favorite];
 884
 885                 /* change state */
 886
 887                 (*iter)[plugin_columns.favorite] = favorite;
 888                 (*iter)[plugin_columns.hidden] = false;
 889                 PluginManager::PluginStatusType status = (favorite ? PluginManager::Favorite : PluginManager::Normal);
 890
 891                 /* save new statuses list */
 892
 893                 pi = (*iter)[plugin_columns.plugin];
 894
 895                 manager.set_status (pi->type, pi->unique_id, status);
 896
 897                 manager.save_statuses ();
 898
 899                 build_plugin_menu ();
 900         }
 901         in_row_change = false;
 902 }
 903
 904 void
 905 PluginSelector::hidden_changed (const std::string& path)
 906 {
 907         PluginInfoPtr pi;
 908
 909         if (in_row_change) {
 910                 return;
 911         }
 912
 913         in_row_change = true;
 914
 915         TreeModel::iterator iter = plugin_model->get_iter (path);
 916
 917         if (iter) {
 918
 919                 bool hidden = !(*iter)[plugin_columns.hidden];
 920
 921                 /* change state */
 922
 923                 (*iter)[plugin_columns.favorite] = false;
 924                 (*iter)[plugin_columns.hidden] = hidden;
 925                 PluginManager::PluginStatusType status = (hidden ? PluginManager::Hidden : PluginManager::Normal);
 926
 927                 /* save new statuses list */
 928
 929                 pi = (*iter)[plugin_columns.plugin];
 930
 931                 manager.set_status (pi->type, pi->unique_id, status);
 932
 933                 manager.save_statuses ();
 934
 935                 build_plugin_menu ();
 936         }
 937         in_row_change = false;
 938 }
 939
 940 bool
 941 PluginSelector::fil_hidden_button_release (GdkEventButton*)
 942 {
 943         _show_hidden = (fil_hidden_button.active_state() == 0);
 944         fil_hidden_button.set_active (_show_hidden);
 945         refill ();
 946         return false;
 947 }
 948
 949 static Gtkmm2ext::ActiveState next_state (Gtkmm2ext::ActiveState s){
 950         switch (s) {
 951                 case Gtkmm2ext::Off:
 952                         return Gtkmm2ext::ImplicitActive;
 953                         break;
 954                 case Gtkmm2ext::ImplicitActive:
 955                         return Gtkmm2ext::ExplicitActive;
 956                         break;
 957                 case Gtkmm2ext::ExplicitActive:
 958                         return Gtkmm2ext::Off;
 959                         break;
 960                 default: assert(0); break; // not reached
 961         }
 962 }
 963
 964 static Gtkmm2ext::ActiveState prev_state (Gtkmm2ext::ActiveState s){
 965         switch (s) {
 966                 case Gtkmm2ext::Off:
 967                         return Gtkmm2ext::ExplicitActive;
 968                         break;
 969                 case Gtkmm2ext::ImplicitActive:
 970                         return Gtkmm2ext::Off;
 971                         break;
 972                 case Gtkmm2ext::ExplicitActive:
 973                         return Gtkmm2ext::ImplicitActive;
 974                         break;
 975                 default: assert(0); break; // not reached
 976         }
 977 }
 978
 979 bool
 980 PluginSelector::fil_instruments_button_release (GdkEventButton* ev)
 981 {
 982         if (ev->button == 3) {
 983                 _show_instruments = prev_state (fil_instruments_button.active_state());
 984         } else {
 985                 _show_instruments = next_state (fil_instruments_button.active_state());
 986         }
 987         fil_instruments_button.set_active_state (_show_instruments);
 988         refill ();
 989         return false;
 990 }
 991
 992 bool
 993 PluginSelector::fil_analysis_button_release (GdkEventButton* ev)
 994 {
 995         if (ev->button == 3) {
 996                 _show_analysers = prev_state (fil_analysis_button.active_state());
 997         } else {
 998                 _show_analysers = next_state (fil_analysis_button.active_state());
 999         }
1000         fil_analysis_button.set_active_state (_show_analysers);
1001         refill ();
1002         return false;
1003 }
1004
1005 bool
1006 PluginSelector::fil_utils_button_release (GdkEventButton* ev)
1007 {
1008         if (ev->button == 3) {
1009                 _show_utils = prev_state (fil_utils_button.active_state());
1010         } else {
1011                 _show_utils = next_state (fil_utils_button.active_state());
1012         }
1013         fil_utils_button.set_active_state (_show_utils);
1014         refill ();
1015         return false;
1016 }
1017
1018 void
1019 PluginSelector::show_manager ()
1020 {
1021         show_all();
1022         run ();
1023 }
1024
1025 void
1026 PluginSelector::set_interested_object (PluginInterestedObject& obj)
1027 {
1028         interested_object = &obj;
1029 }