/*
- Copyright (C) 2000 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
+ * Copyright (C) 2008-2009 Sampo Savolainen <v2@iki.fi>
+ * Copyright (C) 2008-2015 David Robillard <d@drobilla.net>
+ * Copyright (C) 2008-2017 Paul Davis <paul@linuxaudiosystems.com>
+ * Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
+ * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
+ * Copyright (C) 2013 John Emmas <john@creativepost.co.uk>
+ * Copyright (C) 2014-2015 Tim Mayberry <mojofunk@gmail.com>
+ * Copyright (C) 2014 Ben Loftis <ben@harrisonconsoles.com>
+ * Copyright (C) 2016-2017 Julien "_FrnchFrgg_" RIVAUD <frnchfrgg@free.fr>
+ * Copyright (C) 2017-2018 Johannes Mueller <github@johannes-mueller.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
#ifdef WAF_BUILD
#include "gtk2ardour-config.h"
#include "pbd/failed_constructor.h"
#include "evoral/midi_events.h"
-#include "evoral/PatchChange.hpp"
+#include "evoral/PatchChange.h"
#include "midi++/midnam_patch.h"
#include "gtkmm2ext/doi.h"
#include "widgets/ardour_knob.h"
-#include "widgets/click_box.h"
#include "widgets/fastmeter.h"
#include "widgets/slider_controller.h"
#include "widgets/tooltips.h"
#include "plugin_ui.h"
+#include "plugin_presets_ui.h"
#include "plugin_display.h"
#include "gui_thread.h"
#include "automation_controller.h"
, is_scrollable(scrollable)
, _plugin_pianokeyboard_expander (_("MIDI Keyboard"))
, _piano (0)
- , _pianomm (0)
, _piano_velocity (*manage (new Adjustment (100, 1, 127, 1, 16)))
, _piano_channel (*manage (new Adjustment (0, 1, 16, 1, 1)))
{
smaller_hbox->pack_start (latency_button, false, false, 4);
smaller_hbox->pack_start (pin_management_button, false, false, 4);
- smaller_hbox->pack_start (_preset_combo, false, false);
smaller_hbox->pack_start (_preset_modified, false, false);
+ smaller_hbox->pack_start (_preset_combo, false, false);
smaller_hbox->pack_start (add_button, false, false);
smaller_hbox->pack_start (save_button, false, false);
smaller_hbox->pack_start (delete_button, false, false);
+ if (pi->controls().size() > 0 && has_descriptive_presets ()) {
+ smaller_hbox->pack_start (preset_browser_button, false, false);
+ }
if (pi->controls().size() > 0) {
smaller_hbox->pack_start (reset_button, false, false, 4);
}
smaller_hbox->pack_start (bypass_button, false, true, 4);
- automation_manual_all_button.set_text(_("Manual"));
+ automation_manual_all_button.set_text (GainMeterBase::astate_string (ARDOUR::Off));
automation_manual_all_button.set_name (X_("generic button"));
- automation_play_all_button.set_text(_("Play"));
+ automation_play_all_button.set_text (GainMeterBase::astate_string (ARDOUR::Play));
automation_play_all_button.set_name (X_("generic button"));
- automation_write_all_button.set_text(_("Write"));
+ automation_write_all_button.set_text (GainMeterBase::astate_string (ARDOUR::Write));
automation_write_all_button.set_name (X_("generic button"));
- automation_touch_all_button.set_text(_("Touch"));
+ automation_touch_all_button.set_text (GainMeterBase::astate_string (ARDOUR::Touch));
automation_touch_all_button.set_name (X_("generic button"));
+ automation_latch_all_button.set_text (GainMeterBase::astate_string (ARDOUR::Latch));
+ automation_latch_all_button.set_name (X_("generic button"));
constraint_hbox->set_spacing (5);
constraint_hbox->set_homogeneous (false);
VBox* v1_box = manage (new VBox);
VBox* v2_box = manage (new VBox);
if (pi->is_instrument ()) {
- _piano = (PianoKeyboard*)piano_keyboard_new();
- _pianomm = Glib::wrap((GtkWidget*)_piano);
- _pianomm->set_flags(Gtk::CAN_FOCUS);
- _pianomm->add_events(Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
+ _piano = new APianoKeyboard ();
+ _piano->set_flags(Gtk::CAN_FOCUS);
- g_signal_connect (G_OBJECT (_piano), "note-on", G_CALLBACK (GenericPluginUI::_note_on_event_handler), this);
- g_signal_connect (G_OBJECT (_piano), "note-off", G_CALLBACK (GenericPluginUI::_note_off_event_handler), this);
+ _piano->NoteOn.connect (sigc::mem_fun (*this, &GenericPluginUI::note_on_event_handler));
+ _piano->NoteOff.connect (sigc::mem_fun (*this, &GenericPluginUI::note_off_event_handler));
HBox* box = manage (new HBox);
box->pack_start (*manage (new Label (_("Channel:"))), false, false);
_pianobox.set_spacing (4);
_pianobox.pack_start (*box2, true, true);
- _pianobox.pack_start (*_pianomm, true, true);
+ _pianobox.pack_start (*_piano, true, true);
_plugin_pianokeyboard_expander.set_expanded(false);
_plugin_pianokeyboard_expander.property_expanded().signal_changed().connect( sigc::mem_fun(*this, &GenericPluginUI::toggle_pianokeyboard));
} else {
pack_end (plugin_analysis_expander, false, false);
}
+
+ if (insert->provides_stats ()) {
+ pack_end (cpuload_expander, false, false);
+ }
+
if (!plugin->get_docs().empty()) {
pack_end (description_expander, false, false);
}
main_contents.pack_start (scroller, true, true);
- prefheight = 0;
+ prefheight = -1;
build ();
if (insert->plugin()->has_midnam() && insert->plugin()->knows_bank_patch()) {
scroller.set_name ("PluginEditor");
} else {
scroller.signal_size_request().connect (sigc::mem_fun(*this, &GenericPluginUI::scroller_size_request));
+ scroller.signal_realize().connect (sigc::mem_fun(scroller, &Widget::queue_resize));
scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
}
if (output_controls.size() > 0) {
screen_update_connection.disconnect();
}
- delete _pianomm;
+ delete automation_menu;
+ delete _piano;
}
void
GenericPluginUI::scroller_size_request (Gtk::Requisition* a)
{
- Glib::RefPtr<Gdk::Screen> screen = get_screen();
- if (!screen)
- screen = Gdk::Screen::get_default();
-
- int maximum_width;
- {
- Gdk::Rectangle monitor;
- const int monitor_num = screen->get_monitor_at_window (get_window ());
- screen->get_monitor_geometry (
- (monitor_num < 0) ? 0 : monitor_num,
- monitor);
-
- maximum_width = monitor.get_width() * 0.9;
+ GtkRequisition request = hpacker.size_request();
+
+ Glib::RefPtr<Gdk::Window> window (scroller.get_window());
+ Glib::RefPtr<Gdk::Screen> screen;
+
+ if (window) {
+ screen = window->get_screen();
}
- GtkRequisition request = hpacker.size_request();
+ if (!screen) {
+ a->width = min(1024, request.width);
+ return;
+ }
+
+ Gdk::Rectangle monitor;
+ const int monitor_num = screen->get_monitor_at_window (window);
+ screen->get_monitor_geometry (
+ (monitor_num < 0) ? 0 : monitor_num,
+ monitor);
+
+ const int maximum_width = monitor.get_width() * 0.9;
if (request.width > maximum_width) {
for (vector<ControlUI*>::const_iterator cuip = input_controls.begin();
s1pos = s1.length();
s2pos = s2.length();
while (s1pos-- > 0 && s2pos-- > 0) {
- if (!match_or_digit(s1[s1pos], s2[s2pos]) )
+ if (!match_or_digit(s1[s1pos], s2[s2pos])) {
break;
+ }
n++;
}
return n;
GenericPluginUI::build ()
{
std::vector<ControlUI *> control_uis;
- bool grid = plugin->parameter_count() > 0;
+ bool grid_avail = false;
+ bool grid_veto = false;
// Build a ControlUI for each control port
for (size_t i = 0; i < plugin->parameter_count(); ++i) {
ControlUI* cui;
Plugin::UILayoutHint hint;
- if (!plugin->get_layout(i, hint)) {
- grid = false;
+ if (plugin->get_layout(i, hint)) {
+ grid_avail = true;
+ } else {
+ grid_veto = true;
}
boost::shared_ptr<ARDOUR::AutomationControl> c
continue;
}
- if (grid) {
+ if (grid_avail && !grid_veto) {
cui->x0 = hint.x0;
cui->x1 = hint.x1;
cui->y0 = hint.y0;
}
}
+ bool grid = grid_avail && !grid_veto;
+
// Build a ControlUI for each property
const Plugin::PropertyDescriptors& descs = plugin->get_supported_properties();
for (Plugin::PropertyDescriptors::const_iterator d = descs.begin(); d != descs.end(); ++d) {
plugin->announce_property_values();
}
- if (grid) {
+ if (control_uis.empty ()) {
+ if (has_descriptive_presets ()) {
+ preset_gui = new PluginPresetsUI (insert);
+ hpacker.pack_start (*preset_gui, true, true);
+ }
+ } else if (grid) {
custom_layout (control_uis);
} else {
automatic_layout (control_uis);
automation_play_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Play));
automation_write_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Write));
automation_touch_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Touch));
+ automation_latch_all_button.signal_clicked.connect(sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::set_all_automation), ARDOUR::Latch));
/* XXX This is a workaround for AutomationControl not knowing about preset loads */
plugin->PresetLoaded.connect (*this, invalidator (*this), boost::bind (&GenericPluginUI::update_input_displays, this), gui_context ());
FILL|EXPAND, FILL);
button_row++;
- } else if (cui->controller || cui->clickbox || cui->combo) {
+ } else if (cui->controller || cui->combo) {
// Get all of the controls into a list, so that
// we can lay them out a bit more nicely later.
cui_controls_list.push_back(cui);
box->pack_start (*cui, false, false);
}
- if (is_scrollable) {
+ if (is_scrollable && i > 0) {
prefheight = 30 * i;
}
Frame* frame = manage (new Frame);
frame->set_name ("BaseFrame");
if (dynamic_cast<MidiTrack*> (insert->owner())) {
- frame->set_label (_("MIDI Progams (sent to track)"));
+ frame->set_label (_("MIDI Programs (sent to track)"));
} else {
- frame->set_label (_("MIDI Progams (volatile)"));
+ frame->set_label (_("MIDI Programs (volatile)"));
}
frame->add (*pgm_table);
hpacker.pack_start (*frame, false, false);
for (MIDI::Name::PatchNameList::const_iterator j = patches.begin(); j != patches.end(); ++j) {
const std::string pgm = (*j)->name ();
MIDI::Name::PatchPrimaryKey const& key = (*j)->patch_primary_key ();
- assert ((*i)->number () == key.bank());
const uint32_t bp = (key.bank() << 7) | key.program();
midi_pgmsel[chn]->AddMenuElem (MenuElemNoMnemonic (pgm, sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::midi_bank_patch_select), chn, bp)));
pgm_names[bp] = pgm;
: param(p)
, automate_button (X_("")) // force creation of a label
, combo (0)
- , clickbox (0)
, file_button (0)
, spin_box (0)
, display (0)
cui->automate_button.set_active((state != ARDOUR::Off));
if (cui->short_autostate) {
- cui->automate_button.set_text (
- GainMeterBase::astate_string (state));
- return;
- }
-
- switch (state & (ARDOUR::Off|Play|Touch|Write)) {
- case ARDOUR::Off:
- cui->automate_button.set_text (S_("Automation|Manual"));
- break;
- case Play:
- cui->automate_button.set_text (_("Play"));
- break;
- case Write:
- cui->automate_button.set_text (_("Write"));
- break;
- case Touch:
- cui->automate_button.set_text (_("Touch"));
- break;
- default:
- cui->automate_button.set_text (_("???"));
- break;
+ cui->automate_button.set_text (GainMeterBase::short_astate_string (state));
+ } else {
+ cui->automate_button.set_text (GainMeterBase::astate_string (state));
}
}
-bool
-GenericPluginUI::integer_printer (char buf[32], Adjustment &adj, ControlUI* cui)
-{
- float const v = cui->control->interface_to_internal(adj.get_value ());
- const std::string& str = ARDOUR::value_as_string(cui->control->desc(), Variant(v));
- const size_t len = str.copy(buf, 31);
- buf[len] = '\0';
- return true;
-}
-
-bool
-GenericPluginUI::midinote_printer (char buf[32], Adjustment &adj, ControlUI* cui)
-{
- float const v = cui->control->interface_to_internal(adj.get_value ());
- const std::string& str = ARDOUR::value_as_string(cui->control->desc(), Variant(v));
- const size_t len = str.copy(buf, 31);
- buf[len] = '\0';
- return true;
-}
-
-void
-GenericPluginUI::print_parameter (char *buf, uint32_t len, uint32_t param)
-{
- plugin->print_parameter (param, buf, len);
-}
-
/** Build a ControlUI for a parameter/property.
* Note that mcontrol may be NULL for outputs.
*/
// Create/add controller
control_ui->file_button = manage(new Gtk::FileChooserButton(Gtk::FILE_CHOOSER_ACTION_OPEN));
control_ui->file_button->set_title(desc.label);
+ Gtkmm2ext::add_volume_shortcuts (*control_ui->file_button);
if (use_knob) {
control_ui->knobtable = manage (new Table());
Adjustment* adj = control_ui->controller->adjustment();
- if (desc.integer_step && !desc.toggled) {
- control_ui->clickbox = new ArdourWidgets::ClickBox (adj, "PluginUIClickBox", true);
- Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
- if (desc.unit == ParameterDescriptor::MIDI_NOTE) {
- control_ui->clickbox->set_printer (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::midinote_printer), control_ui));
- } else {
- control_ui->clickbox->set_printer (sigc::bind (sigc::mem_fun (*this, &GenericPluginUI::integer_printer), control_ui));
- }
- control_ui->clickbox->set_controllable (mcontrol);
- } else if (desc.toggled) {
+ if (desc.toggled) {
ArdourButton* but = dynamic_cast<ArdourButton*> (control_ui->controller->widget());
assert(but);
but->set_tweaks(ArdourButton::Square);
} else {
control_ui->controller->set_size_request (200, -1);
control_ui->controller->set_name (X_("ProcessorControlSlider"));
+ if (desc.integer_step) {
+ AutomationBarController* abc = dynamic_cast <AutomationBarController*> (control_ui->controller->widget ());
+ assert (abc);
+ abc->set_digits (0);
+ }
}
if (!desc.integer_step && !desc.toggled && use_knob) {
if (control_ui->combo) {
control_ui->knobtable->attach (control_ui->label, 0, 1, 0, 1);
control_ui->knobtable->attach (*control_ui->combo, 0, 1, 1, 2);
- } else if (control_ui->clickbox) {
- control_ui->knobtable->attach (*control_ui->clickbox, 0, 2, 0, 1);
- control_ui->knobtable->attach (control_ui->label, 0, 1, 1, 2, FILL, SHRINK);
- control_ui->knobtable->attach (control_ui->automate_button, 1, 2, 1, 2, SHRINK, SHRINK, 2, 0);
} else if (control_ui->spin_box) {
ArdourKnob* knob = dynamic_cast<ArdourKnob*>(control_ui->controller->widget ());
knob->set_tooltip_prefix (desc.label + ": ");
control_ui->pack_start (control_ui->label, true, true);
if (control_ui->combo) {
control_ui->pack_start(*control_ui->combo, false, true);
- } else if (control_ui->clickbox) {
- control_ui->pack_start (*control_ui->clickbox, false, false);
} else if (control_ui->spin_box) {
control_ui->pack_start (*control_ui->spin_box, false, false);
control_ui->pack_start (*control_ui->controller, false, false);
MenuList& items (automation_menu->items());
items.clear ();
- items.push_back (MenuElem (S_("Automation|Manual"),
+ items.push_back (MenuElem (GainMeterBase::astate_string (ARDOUR::Off),
sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) ARDOUR::Off, cui)));
- items.push_back (MenuElem (_("Play"),
+ items.push_back (MenuElem (GainMeterBase::astate_string (Play),
sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Play, cui)));
- items.push_back (MenuElem (_("Write"),
+ items.push_back (MenuElem (GainMeterBase::astate_string (Write),
sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Write, cui)));
- items.push_back (MenuElem (_("Touch"),
+ items.push_back (MenuElem (GainMeterBase::astate_string (Touch),
sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Touch, cui)));
+ items.push_back (MenuElem (GainMeterBase::astate_string (Latch),
+ sigc::bind (sigc::mem_fun(*this, &GenericPluginUI::set_automation_state), (AutoState) Latch, cui)));
- anchored_menu_popup(automation_menu, &cui->automate_button, cui->automate_button.get_text(),
- 1, ev->time);
+ anchored_menu_popup (automation_menu, &cui->automate_button,
+ GainMeterBase::astate_string (insert->get_parameter_automation_state (cui->parameter())),
+ 1, ev->time);
return true;
}
}
void
-GenericPluginUI::_note_on_event_handler(GtkWidget*, int note, gpointer arg)
-{
- ((GenericPluginUI*)arg)->note_on_event_handler(note);
-}
-
-void
-GenericPluginUI::_note_off_event_handler(GtkWidget*, int note, gpointer arg)
-{
- ((GenericPluginUI*)arg)->note_off_event_handler(note);
-}
-
-void
-GenericPluginUI::note_on_event_handler (int note)
+GenericPluginUI::note_on_event_handler (int note, int)
{
MidiTrack* mt = dynamic_cast<MidiTrack*> (insert->owner());
- _pianomm->grab_focus ();
+ _piano->grab_focus ();
uint8_t channel = _piano_channel.get_value_as_int () - 1;
uint8_t event[3];
event[0] = (MIDI_CMD_NOTE_ON | channel);
projects / ardour.git / blobdiff