#include <pbd/xml++.h>
#include <pbd/failed_constructor.h>
-#include <gtkmmext/click_box.h>
-#include <gtkmmext/fastmeter.h>
-#include <gtkmmext/slider_controller.h>
-#include <gtkmmext/barcontroller.h>
-#include <gtkmmext/utils.h>
-#include <gtkmmext/doi.h>
+#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/fastmeter.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/barcontroller.h>
+#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/doi.h>
#include <midi++/manager.h>
using namespace std;
using namespace ARDOUR;
-using namespace Gtkmmext;
+using namespace Gtkmm2ext;
using namespace Gtk;
-using namespace SigC;
+using namespace sigc;
PluginUIWindow::PluginUIWindow (AudioEngine &engine, PluginInsert& insert, bool scrollable)
: ArdourDialog ("plugin ui")
VSTPluginUI* vpu = new VSTPluginUI (insert, *vp);
_pluginui = vpu;
- add (*vpu);
+ get_vbox()->add (*vpu);
vpu->package (*this);
} else {
PluginUI* pu = new PluginUI (engine, insert, scrollable);
_pluginui = pu;
- add (*pu);
+ get_vbox()->add (*pu);
- map_event.connect (slot (*pu, &PluginUI::start_updating));
- unmap_event.connect (slot (*pu, &PluginUI::stop_updating));
+ signal_map_event().connect (mem_fun (*pu, &PluginUI::start_updating));
+ signal_unmap_event().connect (mem_fun (*pu, &PluginUI::stop_updating));
}
- set_position (GTK_WIN_POS_MOUSE);
+ set_position (Gtk::WIN_POS_MOUSE);
set_name ("PluginEditor");
- add_events (GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
- delete_event.connect (bind (slot (just_hide_it), reinterpret_cast<Window*> (this)));
- insert.GoingAway.connect (slot (*this, &PluginUIWindow::plugin_going_away));
+ signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast<Window*> (this)));
+ insert.GoingAway.connect (mem_fun(*this, &PluginUIWindow::plugin_going_away));
if (scrollable) {
gint h = _pluginui->get_preferred_height ();
engine(engine),
button_table (initial_button_rows, initial_button_cols),
output_table (initial_output_rows, initial_output_cols),
+ hAdjustment(0.0, 0.0, 0.0),
+ vAdjustment(0.0, 0.0, 0.0),
+ scroller_view(hAdjustment, vAdjustment),
automation_menu (0),
is_scrollable(scrollable)
{
HBox* constraint_hbox = manage (new HBox);
HBox* smaller_hbox = manage (new HBox);
+ Label* combo_label = manage (new Label (_("<span size=\"large\">Presets</span>")));
+ combo_label->set_use_markup (true);
+ smaller_hbox->pack_start (*combo_label, false, false, 10);
smaller_hbox->pack_start (combo, false, false);
smaller_hbox->pack_start (save_button, false, false);
- constraint_hbox->set_spacing (10);
+ constraint_hbox->set_spacing (5);
constraint_hbox->pack_start (*smaller_hbox, true, false);
constraint_hbox->pack_end (bypass_button, false, false);
-// name_ebox.add (*text_hbox);
-// info_vbox.pack_start (name_ebox, false, false);
-// info_vbox.pack_start (makerinfo_label, false, false);
-// info_vbox.pack_start (paraminfo_label, false, false, 5);
-
-// settings_box.pack_start (info_vbox, false, false, 10);
settings_box.pack_end (*constraint_hbox, false, false);
pack_start (settings_box, false, false);
if ( is_scrollable ) {
- scroller.set_policy (GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scroller.set_name ("PluginEditor");
scroller_view.set_name("PluginEditor");
scroller_view.add (hpacker);
}
else {
pack_start (hpacker, false, false);
-
- // this is a hack to get the theme right
- name_ebox.set_name ("PluginNameBox");
}
- insert.active_changed.connect (slot (*this, &PluginUI::redirect_active_changed));
+ insert.active_changed.connect (mem_fun(*this, &PluginUI::redirect_active_changed));
bypass_button.set_active (!insert.active());
build (engine);
Frame* frame;
Frame* bt_frame;
VBox* box;
- char info[32];
int output_row, output_col;
int button_row, button_col;
int output_rows, output_cols;
hpacker.pack_start(*bt_frame, true, true);
box = manage (new VBox);
+ box->set_border_width (5);
+ box->set_spacing (1);
+
frame = manage (new Frame);
frame->set_name ("BaseFrame");
+ frame->set_label (_("Controls"));
frame->add (*box);
hpacker.pack_start(*frame, true, true);
- box->set_border_width (5);
- box->set_spacing (1);
-
/* find all ports. build control elements for all appropriate control ports */
for (i = 0; i < plugin.parameter_count(); ++i) {
if (plugin.parameter_is_control (i)) {
+
+ /* Don't show latency control ports */
+
+ if (plugin.describe_parameter (i) == X_("latency")) {
+ continue;
+ }
ControlUI* cui;
-
+
/* if we are scrollable, just use one long column */
if (!is_scrollable) {
}
}
- /* Don't show latency control ports */
-
- if (plugin.describe_parameter (i) == X_("latency")) {
- continue;
- }
-
if ((cui = build_control_ui (engine, i, plugin.get_nth_midi_control (i))) == 0) {
- error << compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
+ error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
continue;
}
}
button_table.attach (*cui, button_col, button_col + 1, button_row, button_row+1,
- GTK_FILL|GTK_EXPAND, 0);
+ FILL|EXPAND, FILL);
button_row++;
} else if (cui->display) {
+ output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
+ FILL|EXPAND, FILL);
+
+ // TODO: The meters should be divided into multiple rows
+
+ if (++output_col == output_cols) {
+ output_cols ++;
+ output_table.resize (output_rows, output_cols);
+ }
+
+ /* old code, which divides meters into
+ * columns first, rows later. New code divides into one row
+
if (output_row == output_rows) {
output_row = 0;
if (++output_col == output_cols) {
}
output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
- GTK_FILL|GTK_EXPAND, 0);
+ FILL|EXPAND, FILL);
output_row++;
+ */
}
/* HACK: ideally the preferred height would be queried from
output_update ();
- string pname = plugin.name();
-
- if (pname.length() > 24) {
- pname = pname.substr (0, 24);
- pname += "...";
- ARDOUR_UI::instance()->tooltips().set_tip(name_ebox, plugin.name());
- }
-
-
- nameinfo_label.set_text (pname);
- nameinfo_label.set_name ("PluginNameInfo");
- nameinfo_label.set_alignment (0.0, 0.0);
-
- string maker = plugin.maker();
- string::size_type email_pos;
-
- if ((email_pos = maker.find_first_of ('<')) != string::npos) {
- maker = maker.substr (0, email_pos - 1);
- }
-
- if (maker.length() > 32) {
- maker = maker.substr (0, 32);
- maker += " ...";
- }
-
- makerinfo_label.set_text (maker);
- makerinfo_label.set_name ("PluginMakerInfo");
- makerinfo_label.set_alignment (0.0, 0.0);
-
- snprintf (info, sizeof(info),"[ %u %s | %u %s ]",
- n_ins, ngettext(_("in"), _("ins"), n_ins),
- n_outs, ngettext(_("out"), _("outs"), n_outs));
- paraminfo_label.set_text (info);
- paraminfo_label.set_name ("PluginParameterInfo");
- paraminfo_label.set_alignment (0.0, 0.0);
-
output_table.show_all ();
button_table.show_all ();
}
{
automate_button.set_name ("PluginAutomateButton");
ARDOUR_UI::instance()->tooltips().set_tip (automate_button,
- _("automation control"));
+ _("Automation control"));
/* don't fix the height, it messes up the bar controllers */
- set_usize_to_display_given_text (automate_button, X_("longenuff"), 2, -1);
+ set_size_request_to_display_given_text (automate_button, X_("lngnuf"), 2, 2);
ignore_change = 0;
display = 0;
switch (insert.get_port_automation_state (cui->port_index) & (Off|Play|Touch|Write)) {
case Off:
- static_cast<Gtk::Label*>(cui->automate_button.get_child())->set_text (_("off"));
+ cui->automate_button.set_label (_("Off"));
break;
case Play:
- static_cast<Gtk::Label*>(cui->automate_button.get_child())->set_text (_("play"));
+ cui->automate_button.set_label (_("Play"));
break;
case Write:
- static_cast<Gtk::Label*>(cui->automate_button.get_child())->set_text (_("write"));
+ cui->automate_button.set_label (_("Write"));
break;
case Touch:
- static_cast<Gtk::Label*>(cui->automate_button.get_child())->set_text (_("touch"));
+ cui->automate_button.set_label (_("Touch"));
break;
default:
- static_cast<Gtk::Label*>(cui->automate_button.get_child())->set_text (_("???"));
+ cui->automate_button.set_label (_("???"));
break;
}
}
if (defaults && defaults->count > 0) {
- control_ui->combo = new Gtk::Combo;
- control_ui->combo->set_value_in_list(true, false);
- control_ui->combo->set_popdown_strings(setup_scale_values(port_index, control_ui));
- control_ui->combo->get_popwin()->unmap_event.connect(bind (slot (*this, &PluginUI::control_combo_changed), control_ui));
- plugin.ParameterChanged.connect (bind (slot (*this, &PluginUI::parameter_changed), control_ui));
+ control_ui->combo = new Gtk::ComboBoxText;
+ //control_ui->combo->set_value_in_list(true, false);
+ set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
+ control_ui->combo->signal_changed().connect (bind (mem_fun(*this, &PluginUI::control_combo_changed), control_ui));
+ plugin.ParameterChanged.connect (bind (mem_fun (*this, &PluginUI::parameter_changed), control_ui));
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
control_ui->button = manage (new ToggleButton ());
control_ui->button->set_name ("PluginEditorButton");
- control_ui->button->set_usize (20, 20);
+ control_ui->button->set_size_request (20, 20);
control_ui->pack_start (control_ui->label, true, true);
control_ui->pack_start (*control_ui->button, false, true);
control_ui->pack_start (control_ui->automate_button, false, false);
- control_ui->button->clicked.connect (bind (slot (*this, &PluginUI::control_port_toggled), control_ui));
+ control_ui->button->signal_clicked().connect (bind (mem_fun(*this, &PluginUI::control_port_toggled), control_ui));
if(plugin.get_parameter (port_index) == 1){
control_ui->button->set_active(true);
if (desc.integer_step) {
control_ui->clickbox = new ClickBox (control_ui->adjustment, "PluginUIClickBox");
- Gtkmmext::set_usize_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
control_ui->clickbox->set_print_func (integer_printer, 0);
} else {
-// control_ui->control = new HSliderController (ARDOUR_UI::instance()->plugin_ui_slider_pix(),
-// control_ui->adjustment,
-// mcontrol);
-
- SigC::Slot2<void,char*,uint32_t> pslot = SigC::bind (slot (*this, &PluginUI::print_parameter), (uint32_t) port_index);
+ sigc::slot<void,char*,uint32_t> pslot = sigc::bind (mem_fun(*this, &PluginUI::print_parameter), (uint32_t) port_index);
control_ui->control = new BarController (*control_ui->adjustment, mcontrol, pslot);
- control_ui->control->set_usize (200, 15);
+ // should really match the height of the text in the automation button+label
+ control_ui->control->set_size_request (200, 22);
control_ui->control->set_name (X_("PluginSlider"));
control_ui->control->set_style (BarController::LeftToRight);
control_ui->control->set_use_parent (true);
- control_ui->control->get_spin_button().focus_in_event.connect (slot (*this, &PluginUI::entry_focus_event));
- control_ui->control->get_spin_button().focus_out_event.connect (slot (*this, &PluginUI::entry_focus_event));
-
- control_ui->control->StartGesture.connect (bind (slot (*this, &PluginUI::start_touch), control_ui));
- control_ui->control->StopGesture.connect (bind (slot (*this, &PluginUI::stop_touch), control_ui));
+ control_ui->control->StartGesture.connect (bind (mem_fun(*this, &PluginUI::start_touch), control_ui));
+ control_ui->control->StopGesture.connect (bind (mem_fun(*this, &PluginUI::stop_touch), control_ui));
}
}
control_ui->pack_start (control_ui->automate_button, false, false);
- control_ui->adjustment->value_changed.connect (bind (slot (*this, &PluginUI::control_adjustment_changed), control_ui));
- control_ui->automate_button.clicked.connect (bind (slot (*this, &PluginUI::astate_clicked), control_ui, (uint32_t) port_index));
+ control_ui->adjustment->signal_value_changed().connect (bind (mem_fun(*this, &PluginUI::control_adjustment_changed), control_ui));
+ control_ui->automate_button.signal_clicked().connect (bind (mem_fun(*this, &PluginUI::astate_clicked), control_ui, (uint32_t) port_index));
automation_state_changed (control_ui);
- plugin.ParameterChanged.connect (bind (slot (*this, &PluginUI::parameter_changed), control_ui));
+ plugin.ParameterChanged.connect (bind (mem_fun(*this, &PluginUI::parameter_changed), control_ui));
insert.automation_list (port_index).automation_state_changed.connect
- (bind (slot (*this, &PluginUI::automation_state_changed), control_ui));
+ (bind (mem_fun(*this, &PluginUI::automation_state_changed), control_ui));
} else if (plugin.parameter_is_output (port_index)) {
control_ui->display->set_name ("ParameterValueDisplay");
control_ui->display_label = manage (new Label);
+
control_ui->display_label->set_name ("ParameterValueDisplay");
control_ui->display->add (*control_ui->display_label);
- Gtkmmext::set_usize_to_display_given_text (*control_ui->display, "g999999", 2, 2);
+ Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "-99,99", 2, 2);
control_ui->display->show_all ();
MeterInfo * info = new MeterInfo(port_index);
control_ui->meterinfo = info;
- info->meter = new FastMeter (100, 5, FastMeter::Horizontal);
+ info->meter = new FastMeter (5, 100, FastMeter::Vertical);
info->min_unbound = desc.min_unbound;
info->max_unbound = desc.max_unbound;
info->max = desc.upper;
control_ui->vbox = manage (new VBox);
+ control_ui->hbox = manage (new HBox);
+
+ control_ui->label.set_angle(90);
+ control_ui->hbox->pack_start (control_ui->label, false, false);
+ control_ui->hbox->pack_start (*info->meter, false, false);
- control_ui->vbox->pack_start (control_ui->label, false, false);
- control_ui->vbox->pack_start (*info->meter, false, false);
+ control_ui->vbox->pack_start (*control_ui->hbox, false, false);
- control_ui->pack_start (*control_ui->vbox, false, false);
- control_ui->pack_start (*control_ui->display, false, false);
+ control_ui->vbox->pack_start (*control_ui->display, false, false);
+
+ control_ui->pack_start (*control_ui->vbox);
control_ui->meterinfo->meter->show_all();
control_ui->meterinfo->packed = true;
output_controls.push_back (control_ui);
}
- plugin.ParameterChanged.connect (bind (slot (*this, &PluginUI::parameter_changed), control_ui));
+ plugin.ParameterChanged.connect (bind (mem_fun(*this, &PluginUI::parameter_changed), control_ui));
return control_ui;
}
MenuList& items (automation_menu->items());
items.clear ();
- items.push_back (MenuElem (_("off"),
- bind (slot (*this, &PluginUI::set_automation_state), (AutoState) Off, cui)));
- items.push_back (MenuElem (_("play"),
- bind (slot (*this, &PluginUI::set_automation_state), (AutoState) Play, cui)));
- items.push_back (MenuElem (_("write"),
- bind (slot (*this, &PluginUI::set_automation_state), (AutoState) Write, cui)));
- items.push_back (MenuElem (_("touch"),
- bind (slot (*this, &PluginUI::set_automation_state), (AutoState) Touch, cui)));
+ items.push_back (MenuElem (_("Off"),
+ bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Off, cui)));
+ items.push_back (MenuElem (_("Play"),
+ bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Play, cui)));
+ items.push_back (MenuElem (_("Write"),
+ bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Write, cui)));
+ items.push_back (MenuElem (_("Touch"),
+ bind (mem_fun(*this, &PluginUI::set_automation_state), (AutoState) Touch, cui)));
automation_menu->popup (1, 0);
}
if (cui->port_index == abs_port_id) {
if (!cui->update_pending) {
cui->update_pending = true;
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &PluginUI::update_control_display), cui));
+ Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &PluginUI::update_control_display), cui));
}
}
}
cui->ignore_change++;
if (cui->combo) {
- map<string,float>::iterator it;
+ std::map<string,float>::iterator it;
for (it = cui->combo_map->begin(); it != cui->combo_map->end(); ++it) {
if (it->second == val) {
- cui->combo->get_entry()->set_text(it->first);
+ cui->combo->set_active_text(it->first);
break;
}
}
}
}
-gint
-PluginUI::control_combo_changed (GdkEventAny* ignored, ControlUI* cui)
+void
+PluginUI::control_combo_changed (ControlUI* cui)
{
if (!cui->ignore_change) {
- string value = cui->combo->get_entry()->get_text();
- map<string,float> mapping = *cui->combo_map;
+ string value = cui->combo->get_active_text();
+ std::map<string,float> mapping = *cui->combo_map;
insert.set_parameter (cui->port_index, mapping[value]);
}
- return FALSE;
}
void
PluginUIWindow::plugin_going_away (ARDOUR::Redirect* ignored)
{
- ENSURE_GUI_THREAD(bind (slot (*this, &PluginUIWindow::plugin_going_away), ignored));
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &PluginUIWindow::plugin_going_away), ignored));
_pluginui->stop_updating(0);
delete_when_idle (this);
}
-gint
-PluginUI::entry_focus_event (GdkEventFocus* ev)
-{
- if (ev->in) {
- ARDOUR_UI::instance()->allow_focus (true);
- } else {
- ARDOUR_UI::instance()->allow_focus (false);
- }
- return TRUE;
-}
-
void
PluginUI::redirect_active_changed (Redirect* r, void* src)
{
- ENSURE_GUI_THREAD(bind (slot (*this, &PluginUI::redirect_active_changed), r, src));
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &PluginUI::redirect_active_changed), r, src));
bypass_button.set_active (!r->active());
}
-gint
-PluginUI::start_updating (GdkEventAny *ev)
+bool
+PluginUI::start_updating (GdkEventAny* ignored)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
screen_update_connection = ARDOUR_UI::instance()->RapidScreenUpdate.connect
- (slot (*this, &PluginUI::output_update));
+ (mem_fun(*this, &PluginUI::output_update));
}
- return FALSE;
+ return false;
}
-gint
-PluginUI::stop_updating (GdkEventAny *ev)
+bool
+PluginUI::stop_updating (GdkEventAny* ignored)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
}
- return FALSE;
+ return false;
}
void
}
}
-list<string>
+vector<string>
PluginUI::setup_scale_values(guint32 port_index, ControlUI* cui)
{
- list<string> enums;
+ vector<string> enums;
LadspaPlugin* lp = dynamic_cast<LadspaPlugin*> (&plugin);
- cui->combo_map = new map<string, float>;
+ cui->combo_map = new std::map<string, float>;
lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index);
if (defaults) {
for (uint32_t i = 0; i < defaults->count; ++i) {
PlugUIBase::PlugUIBase (PluginInsert& pi)
: insert (pi),
plugin (insert.plugin()),
- save_button(_("save")),
- bypass_button (_("bypass"))
+ save_button(_("Add")),
+ bypass_button (_("Bypass"))
{
- combo.set_value_in_list(true,true);
- combo.set_use_arrows(true);
- combo.set_use_arrows_always(true);
- combo.set_popdown_strings(plugin.get_presets());
- combo.get_entry()->set_text("");
- combo.get_popwin()->unmap_event.connect(slot (*this, &PlugUIBase::setting_selected));
+ //combo.set_use_arrows_always(true);
+ set_popdown_strings (combo, plugin.get_presets());
+ combo.set_size_request (100, -1);
+ combo.set_active_text ("");
+ combo.signal_changed().connect(mem_fun(*this, &PlugUIBase::setting_selected));
save_button.set_name ("PluginSaveButton");
- save_button.clicked.connect(slot (*this, &PlugUIBase::save_plugin_setting));
+ save_button.signal_clicked().connect(mem_fun(*this, &PlugUIBase::save_plugin_setting));
bypass_button.set_name ("PluginBypassButton");
- bypass_button.toggled.connect (slot (*this, &PlugUIBase::bypass_toggled));
+ bypass_button.signal_toggled().connect (mem_fun(*this, &PlugUIBase::bypass_toggled));
}
-gint
-PlugUIBase::setting_selected(GdkEventAny* ignored)
+void
+PlugUIBase::setting_selected()
{
- Entry* entry = combo.get_entry();
- if (entry->get_text().length() > 0) {
- if (!plugin.load_preset(entry->get_text())) {
- warning << compose(_("Plugin preset %1 not found"), entry->get_text()) << endmsg;
+ if (combo.get_active_text().length() > 0) {
+ if (!plugin.load_preset(combo.get_active_text())) {
+ warning << string_compose(_("Plugin preset %1 not found"), combo.get_active_text()) << endmsg;
}
}
- return FALSE;
}
void
PlugUIBase::save_plugin_setting ()
{
ArdourPrompter prompter (true);
- prompter.set_prompt(_("Name for plugin settings:"));
+ prompter.set_prompt(_("Name of New Preset:"));
+ prompter.add_button (Gtk::Stock::ADD, Gtk::RESPONSE_ACCEPT);
+ prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
prompter.show_all();
- prompter.done.connect(Main::quit.slot());
- Main::run();
+ switch (prompter.run ()) {
+ case Gtk::RESPONSE_ACCEPT:
- if (prompter.status == Gtkmmext::Prompter::entered) {
string name;
prompter.get_result(name);
if (name.length()) {
if(plugin.save_preset(name)){
- combo.set_popdown_strings(plugin.get_presets());
- combo.get_entry()->set_text(name);
+ set_popdown_strings (combo, plugin.get_presets());
+ combo.set_active_text (name);
}
}
+ break;
}
}