gtk2_ardour/generic_pluginui.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <climits>
  25 #include <cerrno>
  26 #include <cmath>
  27 #include <string>
  28 #include <vector>
  29
  30 #include <gtkmm/separator.h>
  31
  32 #include "pbd/stl_delete.h"
  33 #include "pbd/unwind.h"
  34 #include "pbd/xml++.h"
  35 #include "pbd/failed_constructor.h"
  36
  37 #include "ardour/plugin.h"
  38 #include "ardour/plugin_insert.h"
  39 #include "ardour/session.h"
  40 #include "ardour/value_as_string.h"
  41
  42 #include "gtkmm2ext/utils.h"
  43 #include "gtkmm2ext/doi.h"
  44
  45 #include "widgets/ardour_knob.h"
  46 #include "widgets/click_box.h"
  47 #include "widgets/fastmeter.h"
  48 #include "widgets/slider_controller.h"
  49 #include "widgets/tooltips.h"
  50
  51 #include "plugin_ui.h"
  52 #include "plugin_display.h"
  53 #include "gui_thread.h"
  54 #include "automation_controller.h"
  55 #include "gain_meter.h"
  56 #include "timers.h"
  57 #include "ui_config.h"
  58
  59 #include "pbd/i18n.h"
  60
  61 using namespace std;
  62 using namespace ARDOUR;
  63 using namespace PBD;
  64 using namespace Gtkmm2ext;
  65 using namespace ArdourWidgets;
  66 using namespace Gtk;
  67 using namespace ARDOUR_UI_UTILS;
  68
  69 GenericPluginUI::GenericPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrollable)
  70         : PlugUIBase (pi)
  71         , automation_menu (0)
  72         , is_scrollable(scrollable)
  73 {
  74         set_name ("PluginEditor");
  75         set_border_width (10);
  76         //set_homogeneous (false);
  77
  78         pack_start (main_contents, true, true);
  79         settings_box.set_homogeneous (false);
  80
  81         HBox* constraint_hbox = manage (new HBox);
  82         HBox* smaller_hbox = manage (new HBox);
  83         HBox* automation_hbox = manage (new HBox);
  84         smaller_hbox->set_spacing (4);
  85         automation_hbox->set_spacing (6);
  86         Label* combo_label = manage (new Label (_("<span size=\"large\">Presets</span>")));
  87         combo_label->set_use_markup (true);
  88
  89         latency_button.signal_clicked.connect (sigc::mem_fun (*this, &PlugUIBase::latency_button_clicked));
  90         set_latency_label ();
  91
  92         smaller_hbox->pack_start (latency_button, false, false, 4);
  93         smaller_hbox->pack_start (pin_management_button, false, false, 4);
  94         smaller_hbox->pack_start (_preset_combo, false, false);
  95         smaller_hbox->pack_start (_preset_modified, false, false);
  96         smaller_hbox->pack_start (add_button, false, false);
  97         smaller_hbox->pack_start (save_button, false, false);
  98         smaller_hbox->pack_start (delete_button, false, false);
  99         smaller_hbox->pack_start (reset_button, false, false, 4);
 100         smaller_hbox->pack_start (bypass_button, false, true, 4);
 101
 102         automation_manual_all_button.set_text(_("Manual"));
 103         automation_manual_all_button.set_name (X_("generic button"));
 104         automation_play_all_button.set_text(_("Play"));
 105         automation_play_all_button.set_name (X_("generic button"));
 106         automation_write_all_button.set_text(_("Write"));
 107         automation_write_all_button.set_name (X_("generic button"));
 108         automation_touch_all_button.set_text(_("Touch"));
 109         automation_touch_all_button.set_name (X_("generic button"));
 110
 111         Label* l = manage (new Label (_("All Automation")));
 112         l->set_alignment (1.0, 0.5);
 113         automation_hbox->pack_start (*l, true, true);
 114         automation_hbox->pack_start (automation_manual_all_button, false, false);
 115         automation_hbox->pack_start (automation_play_all_button, false, false);
 116         automation_hbox->pack_start (automation_write_all_button, false, false);
 117         automation_hbox->pack_start (automation_touch_all_button, false, false);
 118
 119         constraint_hbox->set_spacing (5);
 120         constraint_hbox->set_homogeneous (false);
 121
 122         VBox* v1_box = manage (new VBox);
 123         VBox* v2_box = manage (new VBox);
 124         pack_end (plugin_analysis_expander, false, false);
 125         if (!plugin->get_docs().empty()) {
 126                 pack_end (description_expander, false, false);
 127         }
 128
 129         v1_box->set_spacing (6);
 130         v1_box->pack_start (*smaller_hbox, false, true);
 131         v1_box->pack_start (*automation_hbox, false, true);
 132         v2_box->pack_start (focus_button, false, true);
 133
 134         main_contents.pack_start (settings_box, false, false);
 135
 136         constraint_hbox->pack_end (*v2_box, false, false);
 137         constraint_hbox->pack_end (*v1_box, false, false);
 138
 139         main_contents.pack_start (*constraint_hbox, false, false);
 140
 141         pi->ActiveChanged.connect (active_connection, invalidator (*this), boost::bind (&GenericPluginUI::processor_active_changed, this, boost::weak_ptr<Processor>(pi)), gui_context());
 142
 143         bypass_button.set_active (!pi->enabled());
 144
 145         /* ScrolledWindow will wrap hpacker in a Viewport */
 146         scroller.add (hpacker);
 147         Viewport* view = static_cast<Viewport*>(scroller.get_child());
 148         view->set_shadow_type(Gtk::SHADOW_NONE);
 149
 150         main_contents.pack_start (scroller, true, true);
 151
 152         prefheight = 0;
 153         build ();
 154
 155         if (is_scrollable) {
 156                 scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 157                 scroller.set_name ("PluginEditor");
 158         } else {
 159                 scroller.signal_size_request().connect (sigc::mem_fun(*this, &GenericPluginUI::scroller_size_request));
 160                 scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
 161         }
 162
 163
 164         /* Listen for property changes that are not notified normally because
 165          * AutomationControl has only support for numeric values currently.
 166          * The only case is Variant::PATH for now */
 167         plugin->PropertyChanged.connect(*this, invalidator(*this),
 168                                         boost::bind(&GenericPluginUI::path_property_changed, this, _1, _2),
 169                                         gui_context());
 170
 171         main_contents.show ();
 172 }
 173
 174 GenericPluginUI::~GenericPluginUI ()
 175 {
 176         if (output_controls.size() > 0) {
 177                 screen_update_connection.disconnect();
 178         }
 179 }
 180
 181 void
 182 GenericPluginUI::scroller_size_request (Gtk::Requisition* a)
 183 {
 184         Glib::RefPtr<Gdk::Screen> screen = get_screen();
 185         if (!screen)
 186                 screen = Gdk::Screen::get_default();
 187
 188         int maximum_width;
 189         {
 190                 Gdk::Rectangle monitor;
 191                 const int monitor_num = screen->get_monitor_at_window (get_window ());
 192                 screen->get_monitor_geometry (
 193                                 (monitor_num < 0) ? 0 : monitor_num,
 194                                 monitor);
 195
 196                 maximum_width = monitor.get_width() * 0.9;
 197         }
 198
 199         GtkRequisition request = hpacker.size_request();
 200
 201         if (request.width > maximum_width) {
 202                 for (vector<ControlUI*>::const_iterator cuip = input_controls.begin();
 203                                                         cuip != input_controls.end();
 204                                                         ++cuip) {
 205                         if (!(*cuip)->short_autostate)
 206                                 set_short_autostate(*cuip, true);
 207                 }
 208                 request = hpacker.size_request();
 209         }
 210
 211         a->width = min(request.width, maximum_width);
 212 }
 213
 214 // Some functions for calculating the 'similarity' of two plugin
 215 // control labels.
 216
 217 static int get_number(string label) {
 218 static const char *digits = "0123456789";
 219 int value = -1;
 220
 221         std::size_t first_digit_pos = label.find_first_of(digits);
 222         if (first_digit_pos != string::npos) {
 223                 // found some digits: there's a number in there somewhere
 224                 stringstream s;
 225                 s << label.substr(first_digit_pos);
 226                 s >> value;
 227         }
 228         return value;
 229 }
 230
 231 static int match_or_digit(char c1, char c2) {
 232         return c1 == c2 || (isdigit(c1) && isdigit(c2));
 233 }
 234
 235 static std::size_t matching_chars_at_head(const string s1, const string s2) {
 236 std::size_t length, n = 0;
 237
 238         length = min(s1.length(), s2.length());
 239         while (n < length) {
 240                 if (!match_or_digit(s1[n], s2[n]))
 241                         break;
 242                 n++;
 243         }
 244         return n;
 245 }
 246
 247 static std::size_t matching_chars_at_tail(const string s1, const string s2) {
 248 std::size_t s1pos, s2pos, n = 0;
 249
 250         s1pos = s1.length();
 251         s2pos = s2.length();
 252         while (s1pos-- > 0 && s2pos-- > 0) {
 253                 if (!match_or_digit(s1[s1pos], s2[s2pos])       )
 254                         break;
 255                 n++;
 256         }
 257         return n;
 258 }
 259
 260 static const guint32 min_controls_per_column = 17, max_controls_per_column = 24;
 261 static const float default_similarity_threshold = 0.3;
 262
 263 void
 264 GenericPluginUI::build ()
 265 {
 266         std::vector<ControlUI *> control_uis;
 267         bool grid = plugin->parameter_count() > 0;
 268
 269         // Build a ControlUI for each control port
 270         for (size_t i = 0; i < plugin->parameter_count(); ++i) {
 271
 272                 if (plugin->parameter_is_control (i)) {
 273
 274                         /* Don't show latency control ports */
 275
 276                         const Evoral::Parameter param(PluginAutomation, 0, i);
 277                         if (plugin->describe_parameter (param) == X_("latency")) {
 278                                 continue;
 279                         }
 280
 281                         if (plugin->describe_parameter (param) == X_("hidden")) {
 282                                 continue;
 283                         }
 284
 285                         const float value = plugin->get_parameter(i);
 286
 287                         ControlUI* cui;
 288                         Plugin::UILayoutHint hint;
 289
 290                         if (!plugin->get_layout(i, hint)) {
 291                                 grid = false;
 292                         }
 293
 294                         boost::shared_ptr<ARDOUR::AutomationControl> c
 295                                 = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
 296                                         insert->control(param));
 297
 298                         ParameterDescriptor desc;
 299                         plugin->get_parameter_descriptor(i, desc);
 300                         if ((cui = build_control_ui (param, desc, c, value, plugin->parameter_is_input(i), hint.knob)) == 0) {
 301                                 error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
 302                                 continue;
 303                         }
 304
 305                         if (grid) {
 306                                 cui->x0 = hint.x0;
 307                                 cui->x1 = hint.x1;
 308                                 cui->y0 = hint.y0;
 309                                 cui->y1 = hint.y1;
 310                         }
 311
 312                         const std::string param_docs = plugin->get_parameter_docs(i);
 313                         if (!param_docs.empty()) {
 314                                 set_tooltip(cui, param_docs.c_str());
 315                         }
 316
 317                         control_uis.push_back(cui);
 318                 }
 319         }
 320
 321         // Build a ControlUI for each property
 322         const Plugin::PropertyDescriptors& descs = plugin->get_supported_properties();
 323         for (Plugin::PropertyDescriptors::const_iterator d = descs.begin(); d != descs.end(); ++d) {
 324                 const ParameterDescriptor& desc = d->second;
 325                 const Evoral::Parameter    param(PluginPropertyAutomation, 0, desc.key);
 326
 327                 boost::shared_ptr<ARDOUR::AutomationControl> c
 328                         = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
 329                                 insert->control(param));
 330
 331                 if (!c) {
 332                         error << string_compose(_("Plugin Editor: no control for property %1"), desc.key) << endmsg;
 333                         continue;
 334                 }
 335
 336                 ControlUI* cui = build_control_ui(param, desc, c, c->get_value(), true);
 337                 if (!cui) {
 338                         error << string_compose(_("Plugin Editor: could not build control element for property %1"),
 339                                                 desc.key) << endmsg;
 340                         continue;
 341                 }
 342
 343                 control_uis.push_back(cui);
 344         }
 345         if (!descs.empty()) {
 346                 plugin->announce_property_values();
 347         }
 348
 349         if (grid) {
 350                 custom_layout (control_uis);
 351         } else {
 352                 automatic_layout (control_uis);
 353         }
 354
 355         output_update ();
 356
 357         automation_manual_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Off));
 358         automation_play_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Play));
 359         automation_write_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Write));
 360         automation_touch_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Touch));
 361
 362         /* XXX This is a workaround for AutomationControl not knowing about preset loads */
 363         plugin->PresetLoaded.connect (*this, invalidator (*this), boost::bind (&GenericPluginUI::update_input_displays, this), gui_context ());
 364 }
 365
 366
 367 void
 368 GenericPluginUI::automatic_layout (const std::vector<ControlUI*>& control_uis)
 369 {
 370         guint32 x = 0;
 371
 372         static const int32_t initial_button_rows = 12;
 373         static const int32_t initial_button_cols = 1;
 374         static const int32_t initial_output_rows = 1;
 375         static const int32_t initial_output_cols = 4;
 376
 377         Gtk::Table* button_table = manage (new Gtk::Table (initial_button_rows, initial_button_cols));
 378         Gtk::Table* output_table = manage (new Gtk::Table (initial_output_rows, initial_output_cols));
 379
 380         Frame* frame;
 381         Frame* bt_frame;
 382         VBox* box;
 383         int output_row, output_col;
 384         int button_row, button_col;
 385         int output_rows, output_cols;
 386         int button_rows, button_cols;
 387
 388         hpacker.set_spacing (10);
 389         hpacker.set_border_width (10);
 390
 391         output_rows = initial_output_rows;
 392         output_cols = initial_output_cols;
 393         button_rows = initial_button_rows;
 394         button_cols = initial_button_cols;
 395         output_row = 0;
 396         button_row = 0;
 397         output_col = 0;
 398         button_col = 0;
 399
 400         button_table->set_homogeneous (false);
 401         button_table->set_row_spacings (2);
 402         button_table->set_col_spacings (2);
 403         output_table->set_homogeneous (true);
 404         output_table->set_row_spacings (2);
 405         output_table->set_col_spacings (2);
 406         button_table->set_border_width (5);
 407         output_table->set_border_width (5);
 408
 409
 410         bt_frame = manage (new Frame);
 411         bt_frame->set_name ("BaseFrame");
 412         bt_frame->set_label (_("Switches"));
 413         bt_frame->add (*button_table);
 414         hpacker.pack_start(*bt_frame, true, true);
 415
 416         box = manage (new VBox);
 417         box->set_border_width (5);
 418         box->set_spacing (1);
 419
 420         frame = manage (new Frame);
 421         frame->set_name ("BaseFrame");
 422         frame->set_label (_("Controls"));
 423         frame->add (*box);
 424         hpacker.pack_start(*frame, true, true);
 425
 426         // Add special controls to UI, and build list of normal controls to be layed out later
 427         std::vector<ControlUI *> cui_controls_list;
 428         for (size_t i = 0; i < control_uis.size(); ++i) {
 429                 ControlUI* cui = control_uis[i];
 430
 431                 if (cui->button || cui->file_button) {
 432
 433                         if (!is_scrollable && button_row == button_rows) {
 434                                 button_row = 0;
 435                                 if (++button_col == button_cols) {
 436                                         button_cols += 2;
 437                                         button_table->resize (button_rows, button_cols);
 438                                 }
 439                         }
 440
 441                         button_table->attach (*cui, button_col, button_col + 1, button_row, button_row+1,
 442                                              FILL|EXPAND, FILL);
 443                         button_row++;
 444
 445                 } else if (cui->controller || cui->clickbox || cui->combo) {
 446                         // Get all of the controls into a list, so that
 447                         // we can lay them out a bit more nicely later.
 448                         cui_controls_list.push_back(cui);
 449
 450                 } else if (cui->display) {
 451
 452                         output_table->attach (*cui, output_col, output_col + 1, output_row, output_row+1,
 453                                              FILL|EXPAND, FILL);
 454
 455                         // TODO: The meters should be divided into multiple rows
 456
 457                         if (++output_col == output_cols) {
 458                                 output_cols ++;
 459                                 output_table->resize (output_rows, output_cols);
 460                         }
 461                 }
 462         }
 463
 464         // Iterate over the list of controls to find which adjacent controls
 465         // are similar enough to be grouped together.
 466
 467         string label, previous_label = "";
 468         std::vector<int> numbers_in_labels(cui_controls_list.size());
 469
 470         std::vector<float> similarity_scores(cui_controls_list.size());
 471         float most_similar = 0.0, least_similar = 1.0;
 472
 473         size_t i = 0;
 474         for (vector<ControlUI*>::iterator cuip = cui_controls_list.begin(); cuip != cui_controls_list.end(); ++cuip, ++i) {
 475                 label = (*cuip)->label.get_text();
 476                 numbers_in_labels[i] = get_number(label);
 477
 478                 if (i > 0) {
 479                         // A hand-wavy calculation of how similar this control's
 480                         // label is to the previous.
 481                         similarity_scores[i] =
 482                                 (float) (
 483                                         ( matching_chars_at_head(label, previous_label) +
 484                                           matching_chars_at_tail(label, previous_label) +
 485                                           1
 486                                         )
 487                                 ) / (label.length() + previous_label.length());
 488                         if (numbers_in_labels[i] >= 0) {
 489                                 similarity_scores[i] += (numbers_in_labels[i] == numbers_in_labels[i-1]);
 490                         }
 491                         least_similar = min(least_similar, similarity_scores[i]);
 492                         most_similar  = max(most_similar, similarity_scores[i]);
 493                 } else {
 494                         similarity_scores[0] = 1.0;
 495                 }
 496
 497                 // cerr << "label: " << label << " sim: " << fixed << setprecision(3) << similarity_scores[i] << " num: " << numbers_in_labels[i] << endl;
 498                 previous_label = label;
 499         }
 500
 501
 502         // cerr << "most similar: " << most_similar << ", least similar: " << least_similar << endl;
 503         float similarity_threshold;
 504
 505         if (most_similar > 1.0) {
 506                 similarity_threshold = default_similarity_threshold;
 507         } else {
 508                 similarity_threshold = most_similar - (1 - default_similarity_threshold);
 509         }
 510
 511         // Now iterate over the list of controls to display them, placing an
 512         // HSeparator between controls of less than a certain similarity, and
 513         // starting a new column when necessary.
 514
 515         i = 0;
 516         for (vector<ControlUI*>::iterator cuip = cui_controls_list.begin(); cuip != cui_controls_list.end(); ++cuip, ++i) {
 517
 518                 ControlUI* cui = *cuip;
 519
 520                 if (!is_scrollable) {
 521                         x++;
 522                 }
 523
 524                 if (x > max_controls_per_column || similarity_scores[i] <= similarity_threshold) {
 525                         if (x > min_controls_per_column) {
 526                                 frame = manage (new Frame);
 527                                 frame->set_name ("BaseFrame");
 528                                 frame->set_label (_("Controls"));
 529                                 box = manage (new VBox);
 530                                 box->set_border_width (5);
 531                                 box->set_spacing (1);
 532                                 frame->add (*box);
 533                                 hpacker.pack_start(*frame, true, true);
 534                                 x = 0;
 535                         } else {
 536                                 HSeparator *split = new HSeparator();
 537                                 split->set_size_request(-1, 5);
 538                                 box->pack_start(*split, false, false, 0);
 539                         }
 540
 541                 }
 542                 box->pack_start (*cui, false, false);
 543         }
 544
 545         if (is_scrollable) {
 546                 prefheight = 30 * i;
 547         }
 548
 549         if (box->children().empty()) {
 550                 hpacker.remove (*frame);
 551         }
 552
 553         if (button_table->children().empty()) {
 554                 hpacker.remove (*bt_frame);
 555                 delete button_table;
 556         } else {
 557                 button_table->show_all ();
 558         }
 559
 560         if (!output_table->children().empty()) {
 561                 frame = manage (new Frame);
 562                 frame->set_name ("BaseFrame");
 563                 frame->set_label(_("Meters"));
 564                 frame->add (*output_table);
 565                 hpacker.pack_end (*frame, true, true);
 566                 output_table->show_all ();
 567         } else {
 568                 delete output_table;
 569         }
 570
 571         if (plugin->has_inline_display () && plugin->inline_display_in_gui ()) {
 572                 PluginDisplay* pd = manage (new PluginDisplay (plugin, 300));
 573                 hpacker.pack_end (*pd, true, true);
 574         }
 575         show_all();
 576
 577 }
 578
 579 void
 580 GenericPluginUI::custom_layout (const std::vector<ControlUI*>& control_uis)
 581 {
 582         Gtk::Table* layout = manage (new Gtk::Table ());
 583
 584         for (vector<ControlUI*>::const_iterator i = control_uis.begin(); i != control_uis.end(); ++i) {
 585                 ControlUI* cui = *i;
 586                 if (cui->x0 < 0 || cui->y0 < 0) {
 587                         continue;
 588                 }
 589                 layout->attach (*cui, cui->x0, cui->x1, cui->y0, cui->y1, FILL, SHRINK, 2, 2);
 590         }
 591         hpacker.pack_start (*layout, true, true);
 592
 593         if (plugin->has_inline_display () && plugin->inline_display_in_gui ()) {
 594                 PluginDisplay* pd = manage (new PluginDisplay (plugin, 300));
 595                 hpacker.pack_end (*pd, true, true);
 596         }
 597 }
 598
 599 GenericPluginUI::ControlUI::ControlUI (const Evoral::Parameter& p)
 600         : param(p)
 601         , automate_button (X_("")) // force creation of a label
 602         , combo (0)
 603         , clickbox (0)
 604         , file_button (0)
 605         , spin_box (0)
 606         , display (0)
 607         , hbox (0)
 608         , vbox (0)
 609         , meterinfo (0)
 610         , knobtable (0)
 611 {
 612         automate_button.set_name ("plugin automation state button");
 613         set_tooltip (automate_button, _("Automation control"));
 614
 615         ignore_change = false;
 616         update_pending = false;
 617         button = false;
 618
 619         x0 = x1 = y0 = y1 = -1;
 620 }
 621
 622 GenericPluginUI::ControlUI::~ControlUI()
 623 {
 624         if (meterinfo) {
 625                 delete meterinfo->meter;
 626                 delete meterinfo;
 627         }
 628 }
 629
 630 void
 631 GenericPluginUI::set_short_autostate (ControlUI* cui, bool value)
 632 {
 633         cui->short_autostate = value;
 634         if (value) {
 635                 cui->automate_button.set_sizing_text("M");
 636         } else {
 637                 /* XXX translators: use a string here that will be at least as long
 638                    as the longest automation label (see ::automation_state_changed()
 639                    below). be sure to include a descender. */
 640                 cui->automate_button.set_sizing_text(_("Mgnual"));
 641         }
 642         automation_state_changed(cui);
 643 }
 644
 645 void
 646 GenericPluginUI::automation_state_changed (ControlUI* cui)
 647 {
 648         /* update button label */
 649
 650         // don't lock to avoid deadlock because we're triggered by
 651         // AutomationControl::Changed() while the automation lock is taken
 652
 653         AutoState state = insert->get_parameter_automation_state (cui->parameter());
 654
 655         cui->automate_button.set_active((state != ARDOUR::Off));
 656
 657         if (cui->short_autostate) {
 658                 cui->automate_button.set_text (
 659                                 GainMeterBase::astate_string (state));
 660                 return;
 661         }
 662
 663         switch (state & (ARDOUR::Off|Play|Touch|Write)) {
 664         case ARDOUR::Off:
 665                 cui->automate_button.set_text (S_("Automation|Manual"));
 666                 break;
 667         case Play:
 668                 cui->automate_button.set_text (_("Play"));
 669                 break;
 670         case Write:
 671                 cui->automate_button.set_text (_("Write"));
 672                 break;
 673         case Touch:
 674                 cui->automate_button.set_text (_("Touch"));
 675                 break;
 676         default:
 677                 cui->automate_button.set_text (_("???"));
 678                 break;
 679         }
 680 }
 681
 682 bool
 683 GenericPluginUI::integer_printer (char buf[32], Adjustment &adj, ControlUI* cui)
 684 {
 685         float const        v   = cui->control->interface_to_internal(adj.get_value ());
 686         const std::string& str = ARDOUR::value_as_string(cui->control->desc(), Variant(v));
 687         const size_t       len = str.copy(buf, 31);
 688         buf[len] = '\0';
 689         return true;
 690 }
 691
 692 bool
 693 GenericPluginUI::midinote_printer (char buf[32], Adjustment &adj, ControlUI* cui)
 694 {
 695         float const        v   = cui->control->interface_to_internal(adj.get_value ());
 696         const std::string& str = ARDOUR::value_as_string(cui->control->desc(), Variant(v));
 697         const size_t       len = str.copy(buf, 31);
 698         buf[len] = '\0';
 699         return true;
 700 }
 701
 702 void
 703 GenericPluginUI::print_parameter (char *buf, uint32_t len, uint32_t param)
 704 {
 705         plugin->print_parameter (param, buf, len);
 706 }
 707
 708 /** Build a ControlUI for a parameter/property.
 709  * Note that mcontrol may be NULL for outputs.
 710  */
 711 GenericPluginUI::ControlUI*
 712 GenericPluginUI::build_control_ui (const Evoral::Parameter&             param,
 713                                    const ParameterDescriptor&           desc,
 714                                    boost::shared_ptr<AutomationControl> mcontrol,
 715                                    float                                value,
 716                                    bool                                 is_input,
 717                                    bool                                 use_knob)
 718 {
 719         ControlUI* control_ui = 0;
 720
 721         control_ui = manage (new ControlUI (param));
 722         control_ui->combo = 0;
 723         control_ui->control = mcontrol;
 724         control_ui->label.set_text (desc.label);
 725         control_ui->label.set_alignment (0.0, 0.5);
 726         control_ui->label.set_name ("PluginParameterLabel");
 727         control_ui->set_spacing (5);
 728         set_short_autostate(control_ui, false);
 729
 730         if (is_input) {
 731
 732                 if (desc.datatype == Variant::PATH) {
 733
 734                         /* We shouldn't get that type for input ports */
 735                         assert(param.type() == PluginPropertyAutomation);
 736
 737                         /* Build a file selector button */
 738
 739                         // Create/add controller
 740                         control_ui->file_button = manage(new Gtk::FileChooserButton(Gtk::FILE_CHOOSER_ACTION_OPEN));
 741                         control_ui->file_button->set_title(desc.label);
 742
 743                         if (use_knob) {
 744                                 control_ui->knobtable = manage (new Table());
 745                                 control_ui->pack_start(*control_ui->knobtable, true, false);
 746                                 control_ui->knobtable->attach (control_ui->label, 0, 1, 0, 1);
 747                                 control_ui->knobtable->attach (*control_ui->file_button, 0, 1, 1, 2);
 748                         } else {
 749                                 control_ui->pack_start (control_ui->label, false, true);
 750                                 control_ui->pack_start (*control_ui->file_button, true, true);
 751                         }
 752
 753                         // Monitor changes from the user.
 754                         control_ui->file_button->signal_file_set().connect(
 755                                 sigc::bind(sigc::mem_fun(*this, &GenericPluginUI::set_path_property),
 756                                            desc, control_ui->file_button));
 757
 758                         /* Add the filebutton control to a map so that we can update it when
 759                          * the corresponding property changes. This doesn't go through the usual
 760                          * AutomationControls, because they don't support non-numeric values. */
 761                         _filepath_controls.insert(std::make_pair(desc.key, control_ui->file_button));
 762
 763                         return control_ui;
 764                 }
 765
 766                 assert(mcontrol);
 767
 768                 /* See if there any named values for our input value */
 769                 control_ui->scale_points = desc.scale_points;
 770
 771                 /* If this parameter is an integer, work out the number of distinct values
 772                    it can take on (assuming that lower and upper values are allowed).
 773                 */
 774                 int const steps = desc.integer_step ? (desc.upper - desc.lower + 1) / desc.step : 0;
 775
 776                 if (control_ui->scale_points && ((steps && int (control_ui->scale_points->size()) == steps) || desc.enumeration)) {
 777
 778                         /* Either:
 779                          *   a) There is a label for each possible value of this input, or
 780                          *   b) This port is marked as being an enumeration.
 781                          */
 782
 783                         control_ui->combo = new ArdourDropdown();
 784                         for (ARDOUR::ScalePoints::const_iterator i = control_ui->scale_points->begin();
 785                              i != control_ui->scale_points->end();
 786                              ++i) {
 787                                 control_ui->combo->AddMenuElem(Menu_Helpers::MenuElem(
 788                                                 i->first,
 789                                                 sigc::bind(sigc::mem_fun(*this, &GenericPluginUI::control_combo_changed),
 790                                                            control_ui,
 791                                                            i->second)));
 792                         }
 793
 794                         control_ui->combo->set_controllable (mcontrol);
 795
 796                         update_control_display(control_ui);
 797
 798                 } else {
 799
 800                         /* create the controller */
 801
 802                         /* XXX memory leak: SliderController not destroyed by ControlUI
 803                          * destructor, and manage() reports object hierarchy
 804                          * ambiguity.
 805                          */
 806                         control_ui->controller = AutomationController::create(mcontrol->parameter(), desc, mcontrol, use_knob);
 807
 808                         /* Control UI's don't need the rapid timer workaround */
 809                         control_ui->controller->stop_updating ();
 810
 811                         /* XXX this code is not right yet, because it doesn't handle
 812                            the absence of bounds in any sensible fashion.
 813                         */
 814
 815                         Adjustment* adj = control_ui->controller->adjustment();
 816
 817                         if (desc.integer_step && !desc.toggled) {
 818                                 control_ui->clickbox = new ArdourWidgets::ClickBox (adj, "PluginUIClickBox", true);
 819                                 Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
 820                                 if (desc.unit == ParameterDescriptor::MIDI_NOTE) {
 821                                         control_ui->clickbox->set_printer (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::midinote_printer), control_ui));
 822                                 } else {
 823                                         control_ui->clickbox->set_printer (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::integer_printer), control_ui));
 824                                 }
 825                                 control_ui->clickbox->set_controllable (mcontrol);
 826                         } else if (desc.toggled) {
 827                                 ArdourButton* but = dynamic_cast<ArdourButton*> (control_ui->controller->widget());
 828                                 assert(but);
 829                                 but->set_tweaks(ArdourButton::Square);
 830                         } else if (use_knob) {
 831                                 /* Delay size request so that styles are gotten right */
 832                                 control_ui->controller->widget()->signal_size_request().connect(
 833                                                 sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::knob_size_request), control_ui));
 834                         } else {
 835                                 control_ui->controller->set_size_request (200, -1);
 836                                 control_ui->controller->set_name (X_("ProcessorControlSlider"));
 837                         }
 838
 839                         if (!desc.integer_step && !desc.toggled && use_knob) {
 840                                 control_ui->spin_box = manage (new ArdourSpinner (mcontrol, adj));
 841                         }
 842
 843                         adj->set_value (mcontrol->internal_to_interface(value));
 844
 845                 }
 846
 847                 if (use_knob) {
 848                         set_short_autostate(control_ui, true);
 849
 850                         control_ui->label.set_alignment (0.5, 0.5);
 851                         control_ui->knobtable = manage (new Table());
 852                         control_ui->pack_start(*control_ui->knobtable, true, true);
 853
 854                         if (control_ui->combo) {
 855                                 control_ui->knobtable->attach (control_ui->label, 0, 1, 0, 1);
 856                                 control_ui->knobtable->attach (*control_ui->combo, 0, 1, 1, 2);
 857                         } else if (control_ui->clickbox) {
 858                                 control_ui->knobtable->attach (*control_ui->clickbox, 0, 2, 0, 1);
 859                                 control_ui->knobtable->attach (control_ui->label, 0, 1, 1, 2, FILL, SHRINK);
 860                                 control_ui->knobtable->attach (control_ui->automate_button, 1, 2, 1, 2, SHRINK, SHRINK, 2, 0);
 861                         } else if (control_ui->spin_box) {
 862                                 ArdourKnob* knob = dynamic_cast<ArdourKnob*>(control_ui->controller->widget ());
 863                                 knob->set_tooltip_prefix (desc.label + ": ");
 864                                 Alignment *align = manage (new Alignment (.5, .5, 0, 0));
 865                                 align->add (*control_ui->controller);
 866                                 control_ui->knobtable->attach (*align, 0, 1, 0, 1, EXPAND, SHRINK, 1, 2);
 867                                 control_ui->knobtable->attach (*control_ui->spin_box, 0, 2, 1, 2);
 868                                 control_ui->knobtable->attach (control_ui->automate_button, 1, 2, 0, 1, SHRINK, SHRINK, 2, 0);
 869                         } else if (desc.toggled) {
 870                                 Alignment *align = manage (new Alignment (.5, .5, 0, 0));
 871                                 align->add (*control_ui->controller);
 872                                 control_ui->knobtable->attach (*align, 0, 2, 0, 1, EXPAND, SHRINK, 2, 2);
 873                                 control_ui->knobtable->attach (control_ui->label, 0, 1, 1, 2, FILL, SHRINK);
 874                                 control_ui->knobtable->attach (control_ui->automate_button, 1, 2, 1, 2, SHRINK, SHRINK, 2, 0);
 875                         } else {
 876                                 control_ui->knobtable->attach (*control_ui->controller, 0, 2, 0, 1);
 877                                 control_ui->knobtable->attach (control_ui->label, 0, 1, 1, 2, FILL, SHRINK);
 878                                 control_ui->knobtable->attach (control_ui->automate_button, 1, 2, 1, 2, SHRINK, SHRINK, 2, 0);
 879                         }
 880
 881                 } else {
 882
 883                         control_ui->pack_start (control_ui->label, true, true);
 884                         if (control_ui->combo) {
 885                                 control_ui->pack_start(*control_ui->combo, false, true);
 886                         } else if (control_ui->clickbox) {
 887                                 control_ui->pack_start (*control_ui->clickbox, false, false);
 888                         } else if (control_ui->spin_box) {
 889                                 control_ui->pack_start (*control_ui->spin_box, false, false);
 890                                 control_ui->pack_start (*control_ui->controller, false, false);
 891                         } else {
 892                                 control_ui->pack_start (*control_ui->controller, false, false);
 893                         }
 894                         control_ui->pack_start (control_ui->automate_button, false, false);
 895                 }
 896
 897
 898                 if (mcontrol->flags () & Controllable::NotAutomatable) {
 899                         control_ui->automate_button.set_sensitive (false);
 900                         set_tooltip(control_ui->automate_button, _("This control cannot be automated"));
 901                 } else {
 902                         control_ui->automate_button.signal_button_press_event().connect (
 903                                         sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::astate_button_event),
 904                                                     control_ui),
 905                                         false);
 906                         mcontrol->alist()->automation_state_changed.connect (
 907                                         control_connections,
 908                                         invalidator (*this),
 909                                         boost::bind (&GenericPluginUI::automation_state_changed, this, control_ui),
 910                                         gui_context());
 911                         input_controls_with_automation.push_back (control_ui);
 912                 }
 913
 914                 if (desc.toggled && !control_ui->combo) {
 915                         control_ui->button = true;
 916                         ArdourButton* but = dynamic_cast<ArdourButton*>(control_ui->controller->widget ());
 917                         assert (but);
 918                         but->set_name ("pluginui toggle");
 919                         update_control_display(control_ui);
 920                 }
 921
 922                 automation_state_changed (control_ui);
 923
 924                 /* Add to the list of CUIs that need manual update to workaround
 925                  * AutomationControl not knowing about preset loads */
 926                 input_controls.push_back (control_ui);
 927
 928         } else {
 929
 930                 control_ui->display = manage (new EventBox);
 931                 control_ui->display->set_name ("ParameterValueDisplay");
 932
 933                 control_ui->display_label = manage (new Label);
 934
 935                 control_ui->display_label->set_name ("ParameterValueDisplay");
 936
 937                 control_ui->display->add (*control_ui->display_label);
 938                 Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "-888.8g", 2, 6);
 939
 940                 control_ui->display->show_all ();
 941
 942                 control_ui->vbox = manage (new VBox);
 943                 control_ui->vbox->set_spacing(3);
 944
 945                 if (desc.unit == ParameterDescriptor::MIDI_NOTE) {
 946                         control_ui->vbox->pack_end (*control_ui->display, false, false);
 947                         control_ui->vbox->pack_end (control_ui->label, false, false);
 948                 } else if (desc.integer_step || desc.enumeration) {
 949                         control_ui->vbox->pack_end (*control_ui->display, false, false);
 950                         control_ui->vbox->pack_end (control_ui->label, false, false);
 951                 } else {
 952                         /* set up a meter for float ports */
 953
 954                         MeterInfo * info = new MeterInfo();
 955                         control_ui->meterinfo = info;
 956
 957                         info->meter = new FastMeter (
 958                                         5, 5, FastMeter::Vertical, 0,
 959                                         0x0000aaff,
 960                                         0x008800ff, 0x008800ff,
 961                                         0x00ff00ff, 0x00ff00ff,
 962                                         0xcccc00ff, 0xcccc00ff,
 963                                         0xffaa00ff, 0xffaa00ff,
 964                                         0xff0000ff,
 965                                         UIConfiguration::instance().color ("meter background bottom"),
 966                                         UIConfiguration::instance().color ("meter background top")
 967                                         );
 968
 969                         control_ui->label.set_angle(90);
 970
 971                         HBox* center =  manage (new HBox);
 972                         center->set_spacing(1);
 973                         center->pack_start (control_ui->label, false, false);
 974                         center->pack_start (*info->meter, false, false);
 975
 976                         control_ui->hbox = manage (new HBox);
 977                         control_ui->hbox->pack_start (*center, true, false);
 978
 979                         // horizontally center this hbox in the vbox
 980                         control_ui->vbox->pack_start (*control_ui->hbox, false, false);
 981
 982                         control_ui->meterinfo->meter->show_all();
 983                         control_ui->meterinfo->packed = true;
 984                         control_ui->vbox->pack_start (*control_ui->display, false, false);
 985                 }
 986
 987                 control_ui->pack_start (*control_ui->vbox);
 988
 989                 output_controls.push_back (control_ui);
 990         }
 991
 992         if (mcontrol) {
 993                 mcontrol->Changed.connect(control_connections, invalidator(*this),
 994                                           boost::bind(&GenericPluginUI::ui_parameter_changed,
 995                                                       this, control_ui),
 996                                           gui_context());
 997         }
 998
 999         return control_ui;
1000 }
1001
1002 void
1003 GenericPluginUI::knob_size_request(Gtk::Requisition* req, ControlUI* cui) {
1004         Gtk::Requisition astate_req (cui->automate_button.size_request());
1005         const int size = (int) (astate_req.height * 1.5);
1006         req->width = max(req->width, size);
1007         req->height = max(req->height, size);
1008 }
1009
1010
1011 bool
1012 GenericPluginUI::astate_button_event (GdkEventButton* ev, ControlUI* cui)
1013 {
1014         if (ev->button != 1) {
1015                 return true;
1016         }
1017
1018         using namespace Menu_Helpers;
1019
1020         if (automation_menu == 0) {
1021                 automation_menu = manage (new Menu);
1022                 automation_menu->set_name ("ArdourContextMenu");
1023                 automation_menu->set_reserve_toggle_size(false);
1024         }
1025
1026         MenuList& items (automation_menu->items());
1027
1028         items.clear ();
1029         items.push_back (MenuElem (S_("Automation|Manual"),
1030                                    sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) ARDOUR::Off, cui)));
1031         items.push_back (MenuElem (_("Play"),
1032                                    sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Play, cui)));
1033         items.push_back (MenuElem (_("Write"),
1034                                    sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Write, cui)));
1035         items.push_back (MenuElem (_("Touch"),
1036                                    sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Touch, cui)));
1037
1038         anchored_menu_popup(automation_menu, &cui->automate_button, cui->automate_button.get_text(),
1039                             1, ev->time);
1040
1041         return true;
1042 }
1043
1044 void
1045 GenericPluginUI::set_all_automation (AutoState as)
1046 {
1047         for (vector<ControlUI*>::iterator i = input_controls_with_automation.begin(); i != input_controls_with_automation.end(); ++i) {
1048                 set_automation_state (as, (*i));
1049         }
1050 }
1051
1052 void
1053 GenericPluginUI::set_automation_state (AutoState state, ControlUI* cui)
1054 {
1055         insert->set_parameter_automation_state (cui->parameter(), state);
1056 }
1057
1058 void
1059 GenericPluginUI::ui_parameter_changed (ControlUI* cui)
1060 {
1061         if (!cui->update_pending) {
1062                 cui->update_pending = true;
1063                 Gtkmm2ext::UI::instance()->call_slot (MISSING_INVALIDATOR, boost::bind (&GenericPluginUI::update_control_display, this, cui));
1064         }
1065 }
1066
1067 void
1068 GenericPluginUI::update_control_display (ControlUI* cui)
1069 {
1070         /* XXX how do we handle logarithmic stuff here ? */
1071
1072         cui->update_pending = false;
1073
1074         float val = cui->control->get_value();
1075
1076         PBD::Unwinder<bool> (cui->ignore_change, true);
1077
1078         if (cui->combo && cui->scale_points) {
1079                 for (ARDOUR::ScalePoints::iterator it = cui->scale_points->begin(); it != cui->scale_points->end(); ++it) {
1080                         if (it->second == val) {
1081                                 cui->combo->set_text(it->first);
1082                                 break;
1083                         }
1084                 }
1085         } else if (cui->button) {
1086                 // AutomationController handles this
1087         }
1088
1089         if( cui->controller ) {
1090             cui->controller->display_effective_value();
1091         }
1092
1093
1094         /*} else {
1095                 if (cui->logarithmic) {
1096                         val = log(val);
1097                 }
1098                 if (val != cui->adjustment->get_value()) {
1099                         cui->adjustment->set_value (val);
1100                 }
1101         }*/
1102 }
1103
1104 void
1105 GenericPluginUI::update_input_displays ()
1106 {
1107         /* XXX This is a workaround for AutomationControl not knowing about preset loads */
1108         for (vector<ControlUI*>::iterator i = input_controls.begin();
1109              i != input_controls.end();
1110              ++i) {
1111                 update_control_display(*i);
1112         }
1113         return;
1114 }
1115
1116 void
1117 GenericPluginUI::control_combo_changed (ControlUI* cui, float value)
1118 {
1119         if (!cui->ignore_change) {
1120                 insert->automation_control (cui->parameter())->set_value (value, Controllable::NoGroup);
1121         }
1122 }
1123
1124 bool
1125 GenericPluginUI::start_updating (GdkEventAny*)
1126 {
1127         if (output_controls.size() > 0 ) {
1128                 screen_update_connection.disconnect();
1129                 screen_update_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &GenericPluginUI::output_update));
1130         }
1131         return false;
1132 }
1133
1134 bool
1135 GenericPluginUI::stop_updating (GdkEventAny*)
1136 {
1137         if (output_controls.size() > 0 ) {
1138                 screen_update_connection.disconnect();
1139         }
1140         return false;
1141 }
1142
1143 void
1144 GenericPluginUI::output_update ()
1145 {
1146         for (vector<ControlUI*>::iterator i = output_controls.begin(); i != output_controls.end(); ++i) {
1147                 float val = plugin->get_parameter ((*i)->parameter().id());
1148                 char buf[32];
1149                 boost::shared_ptr<ReadOnlyControl> c = insert->control_output ((*i)->parameter().id());
1150                 const std::string& str = ARDOUR::value_as_string(c->desc(), Variant(val));
1151                 size_t len = str.copy(buf, 31);
1152                 buf[len] = '\0';
1153                 (*i)->display_label->set_text (buf);
1154
1155                 if ((*i)->meterinfo && (*i)->meterinfo->packed) {
1156                         (*i)->meterinfo->meter->set (c->desc().to_interface (val));
1157                 }
1158         }
1159 }
1160
1161 void
1162 GenericPluginUI::set_path_property (const ParameterDescriptor& desc,
1163                                     Gtk::FileChooserButton*    widget)
1164 {
1165         plugin->set_property(desc.key, Variant(Variant::PATH, widget->get_filename()));
1166 }
1167
1168 void
1169 GenericPluginUI::path_property_changed (uint32_t key, const Variant& value)
1170 {
1171         FilePathControls::iterator c = _filepath_controls.find(key);
1172         if (c != _filepath_controls.end()) {
1173                 c->second->set_filename(value.get_path());
1174         } else {
1175                 std::cerr << "warning: property change for property with no control" << std::endl;
1176         }
1177 }