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