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