Guitarix
ladspalist.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 Andreas Degert, Hermann Meyer
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18 
19 #include <lrdf.h>
20 #include <ladspa.h>
21 #include <dlfcn.h>
22 
23 #include "guitarix.h"
24 
25 using Glib::ustring;
29 
30 namespace ladspa {
31 
32 const char *step_type_names[] = { "coarse", "normal", "fine" };
33 const char *display_type_names[] = { "Scale", "Log. Scale", "Toggle", "Enum", "Display", "Led", "Hide", "Int" };
34 
35 
36 /****************************************************************
37  ** class PluginDisplay
38  */
39 
40 static const char *menudef = "\
41 <ui>\n\
42  <menubar name=\"ladspalist\">\n\
43  <menu action=\"FileMenuAction\">\n\
44  <menuitem action=\"SelectAllAction\" />\n\
45  <menuitem action=\"SelectNoneAction\" />\n\
46  <menuitem action=\"SaveAction\" />\n\
47  <menuitem action=\"ApplyAction\" />\n\
48  <menuitem action=\"QuitAction\" />\n\
49  </menu>\n\
50  <menu action=\"ViewMenuAction\">\n\
51  <menuitem action= \"FindAction\" />\n\
52  </menu>\n\
53  </menubar>\n\
54 </ui>\n\
55 ";
56 
57 static void append_displaytype(Glib::RefPtr<Gtk::ListStore> ls, DisplayType tp) {
58  Gtk::TreeIter it = ls->append();
59  it->set_value(0, ustring(display_type_names[tp]));
60  it->set_value(1, tp);
61 }
62 
63 class CellRendererComboDerived : public Gtk::CellRendererCombo {
64 public:
65  CellRendererComboDerived() : Glib::ObjectBase (0), Gtk::CellRendererCombo() { }
66  CellRendererComboDerived(BaseObjectType* castitem) : Glib::ObjectBase (0), Gtk::CellRendererCombo((GtkCellRendererCombo*)(castitem)) { }
68  static CellRendererComboDerived* create_from_builder(BaseObjectType* cobject) {
69  return new CellRendererComboDerived(cobject);
70  }
71 };
72 
73 PluginDisplay::PluginDisplay(gx_engine::GxMachineBase& machine_, Glib::RefPtr<Gdk::Pixbuf> icon, sigc::slot<void, bool, bool> finished_callback_)
74  : machine(machine_), pluginlist(), needs_reload(), current_plugin(0), old_state(0), bld(), change_count(0),
75  actiongroup(Gtk::ActionGroup::create("ladspa_window")), uimanager(),
76  enum_liststore(new EnumListStore), port_liststore(new PortListStore),
77  plugin_liststore(new PluginListStore), masteridx_liststore(new MasterIdxListStore),
78  on_reordered_conn(), display_type_list(), display_type_list_sr(), output_type_list(),
79  finished_callback(finished_callback_), reload_plug(false)
80 {
81  std::vector<std::string> old_not_found;
82  machine.load_ladspalist(old_not_found, pluginlist);
83  bld = gx_gui::GxBuilder::create_from_file(machine.get_options().get_builder_filepath("ladspaliste.glade"));
84  bld->get_toplevel("window1", window);
85  bld->find_widget("treeview1", treeview1);
86  bld->find_widget("treeview2", treeview2);
87  bld->find_widget("treeview3", treeview3);
88  bld->find_widget("ladspa_category", ladspa_category);
89  bld->find_widget("ladspa_maker", ladspa_maker);
90  bld->find_widget("ladspa_uniqueid", ladspa_uniqueid);
91  bld->find_widget("search_entry", search_entry);
92  bld->find_widget("combobox_mono_stereo", combobox_mono_stereo);
93  bld->find_widget("selected_only", selected_only);
94  bld->find_widget("changed_only", changed_only);
95  bld->find_widget("ladspa_only", ladspa_only);
96  bld->find_widget("lv2_only", lv2_only);
97  bld->find_widget("show_all", show_all);
98  bld->find_widget("details_box", details_box);
99  bld->find_widget("plugin_name", plugin_name);
100  bld->find_widget("plugin_category", plugin_category);
101  bld->find_widget("plugin_quirks", plugin_quirks);
102  bld->find_widget("master_slider_idx", master_slider_idx);
103  bld->find_widget("master_slider_name", master_slider_name);
104  bld->find_widget("cellrenderer_master", cellrenderer_master);
105  bld->find_widget("cellrenderer_newrow", cellrenderer_newrow);
106  bld->find_widget("cellrenderer_caption", cellrenderer_caption);
107  bld->find_widget("cellrenderer_active", cellrenderer_active);
108  bld->find_widget("cellrenderer_category", cellrenderer_category);
109  bld->find_widget("cellrenderer_quirks", cellrenderer_quirks);
110 
111  set_title();
112  treeview1->set_name("PresetView");
113  treeview2->set_name("PresetView");
114  treeview3->set_name("PresetView");
115  actiongroup->add(Gtk::Action::create("FileMenuAction",_("_File")));
116  save_action = Gtk::Action::create("SaveAction", _("_Ok"));
117  actiongroup->add(save_action, sigc::mem_fun(this, &PluginDisplay::on_save));
118  apply_action = Gtk::Action::create("ApplyAction", _("_Apply"));
119  actiongroup->add(apply_action, sigc::mem_fun(this, &PluginDisplay::on_apply));
120  quit_action = Gtk::Action::create("QuitAction", _("_Quit"));
121  actiongroup->add(quit_action, sigc::mem_fun(this, &PluginDisplay::on_quit));
122  select_all_action = Gtk::Action::create("SelectAllAction", _("_Select All"));
123  actiongroup->add(select_all_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), true));
124  select_none_action = Gtk::Action::create("SelectNoneAction", _("Select _None"));
125  actiongroup->add(select_none_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), false));
126  actiongroup->add(Gtk::Action::create("ViewMenuAction", _("_View")));
127  Glib::RefPtr<Gtk::Action> act = Gtk::Action::create("FindAction", _("_Find"));
128  actiongroup->add(act, sigc::mem_fun(this, &PluginDisplay::on_find));
129 
130  uimanager = Gtk::UIManager::create();
131  uimanager->insert_action_group(actiongroup, 0);
132  uimanager->add_ui_from_string(menudef);
133  //uimanager->get_widget("/ladspalist");
134  //Gtk::HBox *ww; bld->find_widget("menubox", ww); ww->pack_start(*uimanager->get_widget("/ladspalist"));
135  window->add_accel_group(uimanager->get_accel_group());
136 
137  window->signal_delete_event().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_event));
138  bld->find_widget("show_details", show_details);
139  show_details->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_show_details));
140  treeview3->get_selection()->set_mode(Gtk::SELECTION_BROWSE);
141  treeview3->set_model(enum_liststore);
142  Gtk::CellRendererText *r;
143  bld->find_widget("cellrenderer_label", r);
144  r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_label_edited));
145  Gtk::TreeViewColumn *c;
146  bld->find_widget("treeviewcolumn_label", c);
147  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_label));
148 
149  bld->find_widget("dry_wet_button", dry_wet_button);
150  dry_wet_button->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_add_dry_wet_controller));
151  // dry_wet_button->set_active(current_plugin->add_wet_dry);
152 
153  bld->find_widget("stereo_to_mono_button", stereo_to_mono_button);
154  stereo_to_mono_button->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_stereo_to_mono_controller));
155  // stereo_to_mono_button->set_active(current_plugin->stereo_to_mono);
156 
157  Glib::RefPtr<Gtk::TreeSelection> sel = treeview2->get_selection();
158  sel->set_mode(Gtk::SELECTION_BROWSE);
159  sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_parameter_selection_changed));
160  on_reordered_conn = port_liststore->signal_row_deleted().connect(sigc::mem_fun(this, &PluginDisplay::on_reordered));
161  treeview2->set_model(port_liststore);
162 
164  bld->find_widget_derived("cellrenderer_type", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder));
165  rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_type_edited));
166  bld->find_widget("treeviewcolumn_type", c);
167  c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_type));
168 
169  bld->find_widget_derived("cellrenderer_step", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder));
170  rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_step_edited));
171  bld->find_widget("treeviewcolumn_step", c);
172  c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_step));
173 
174  cellrenderer_newrow->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_newrow_toggled));
175  Gtk::Label *label = new Gtk::Label("N");
176  label->set_tooltip_text(_("start a new row of controls in the rackbox unit"));
177  label->show();
178  bld->find_widget("treeviewcolumn_newrow", c);
179  c->set_widget(*manage(label));
180  c->set_cell_data_func(*cellrenderer_newrow, sigc::mem_fun(this, &PluginDisplay::display_newrow));
181  cellrenderer_caption->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_caption_toggled));
182  label = new Gtk::Label("C");
183  label->set_tooltip_text(_("display the name as caption above the control"));
184  label->show();
185  bld->find_widget("treeviewcolumn_caption", c);
186  c->set_widget(*manage(label));
187  c->set_cell_data_func(*cellrenderer_caption, sigc::mem_fun(this, &PluginDisplay::display_caption));
188 
189  bld->find_widget("cellrenderer_name", r);
190  r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_name_edited));
191  bld->find_widget("treeviewcolumn_name", c);
192  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_name));
193  bld->find_widget("cellrenderer_dflt", r);
194  r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_dflt_edited));
195  bld->find_widget("treeviewcolumn_dflt", c);
196  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_default));
197  bld->find_widget("cellrenderer_low", r);
198  r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_low_edited));
199  bld->find_widget("treeviewcolumn_low", c);
200  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_lower));
201  bld->find_widget("cellrenderer_up", r);
202  r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_up_edited));
203  bld->find_widget("treeviewcolumn_up", c);
204  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_upper));
205  bld->find_widget("cellrenderer_idx", r);
206  bld->find_widget("treeviewcolumn_idx", c);
207  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_idx));
208 
209  bld->find_widget("treeviewcolumn_SR", c);
210  label = new Gtk::Label("SR");
211  label->set_tooltip_text(_("marked rows: range depends on samplerate; using 44100 as fixed value"));
212  label->show();
213  c->set_widget(*manage(label));
214  Gtk::CellRendererToggle *t;
215  bld->find_widget("cellrenderer_SR", t);
216  c->set_cell_data_func(*t, sigc::mem_fun(this, &PluginDisplay::display_SR));
217 
218  Gtk::TreeModelColumnRecord recdef;
219  Gtk::TreeModelColumn<Glib::ustring> strcol;
220  Gtk::TreeModelColumn<DisplayType> intcol;
221  recdef.add(strcol);
222  recdef.add(intcol);
223  display_type_list = Gtk::ListStore::create(recdef);
224  append_displaytype(display_type_list, tp_scale);
225  append_displaytype(display_type_list, tp_scale_log);
226  append_displaytype(display_type_list, tp_toggle);
227  append_displaytype(display_type_list, tp_int);
228  append_displaytype(display_type_list, tp_enum);
229  append_displaytype(display_type_list, tp_none);
230  display_type_list_sr = Gtk::ListStore::create(recdef);
231  append_displaytype(display_type_list_sr, tp_scale);
232  append_displaytype(display_type_list_sr, tp_scale_log);
233  append_displaytype(display_type_list_sr, tp_none);
234  output_type_list = Gtk::ListStore::create(recdef);
235  append_displaytype(output_type_list, tp_display);
236  append_displaytype(output_type_list, tp_display_toggle);
237  append_displaytype(output_type_list, tp_none);
238 
239  treeview1->signal_row_activated().connect(sigc::mem_fun(this, &PluginDisplay::on_row_activated));
240  treeview1->set_search_equal_func(sigc::mem_fun(this,&PluginDisplay::search_equal));
241  Gtk::Entry *e;
242  bld->find_widget("search_entry", e);
243  e->signal_activate().connect(sigc::mem_fun(this, &PluginDisplay::on_search_entry_activate));
244  treeview1->set_search_entry(*e);
245  sel = treeview1->get_selection();
246  sel->set_mode(Gtk::SELECTION_BROWSE);
247  sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::selection_changed));
248  treeview1->set_model(plugin_liststore);
249  cellrenderer_active->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_active_toggled));
250  bld->find_widget("cellrenderer_ladspa", r);
251  bld->find_widget("treeviewcolumn_ladspa", c);
252  c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_ladspa));
253 
254  Gtk::ComboBox *cb;
255  bld->find_widget("plugin_category", cb);
256  cb->set_cell_data_func(*cellrenderer_category, sigc::mem_fun(this, &PluginDisplay::display_category));
257  bld->find_widget("plugin_quirks", cb);
258  cb->set_cell_data_func(*cellrenderer_quirks, sigc::mem_fun(this, &PluginDisplay::display_quirks));
259 
260  master_slider_idx->set_cell_data_func(*cellrenderer_master, sigc::mem_fun(this, &PluginDisplay::display_master_idx));
261  master_slider_idx->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::set_master_text));
262 
263  selected_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), selected_only));
264  changed_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), changed_only));
265  ladspa_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), ladspa_only));
266  lv2_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), lv2_only));
267  show_all->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), show_all));
268 
269  bld->find_widget("combobox_mono_stereo", cb);
270  cb->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_mono_stereo_changed));
271  cb->set_active(0);
272  Gtk::Button *b;
273  bld->find_widget("reset_changes", b);
274  b->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_changes));
275 
276  bld->find_widget("master_slider_idx", cb);
277  cb->set_model(masteridx_liststore);
278 
279  bld->find_widget("button_cancel", b);
280  gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("QuitAction")->gobj());
281  bld->find_widget("button_apply", b);
282  gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("ApplyAction")->gobj());
283  bld->find_widget("button_save", b);
284  gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SaveAction")->gobj());
285  bld->find_widget("select_all", b);
286  gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectAllAction")->gobj());
287  bld->find_widget("select_none", b);
288  gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectNoneAction")->gobj());
289 
290  window->set_icon(icon);
291  window->show();
292 }
293 
295  delete window;
296 }
297 
298 static void split(std::vector<ustring>& strvec, const ustring& str) {
299  size_t start = 0, np = ustring::npos;
300  while (true) {
301  size_t end = str.find_first_of(' ', start);
302  size_t len = (end == np) ? np : end - start;
303  if (len > 0) {
304  strvec.push_back(str.substr(start, len).lowercase());
305  }
306  if (end == np) {
307  return;
308  }
309  start = end + 1;
310  }
311 }
312 
313 bool PluginDisplay::search_equal(const Glib::RefPtr<Gtk::TreeModel>& model, int column, const ustring& key, const Gtk::TreeIter& iter) {
314  PluginDesc *p = iter->get_value(plugin_liststore->col.pdesc);
315  ustring txt(gx_system::to_string(p->UniqueID));
316  if (txt.compare(0, ustring::npos, key, 0, key.size()) == 0) {
317  return false;
318  }
319  txt = iter->get_value(plugin_liststore->col.name).lowercase();
320  std::vector<ustring> keyvec;
321  split(keyvec, key);
322  for (std::vector<ustring>::iterator i = keyvec.begin(); i != keyvec.end(); ++i) {
323  if (txt.find(*i) == ustring::npos) {
324  return true;
325  }
326  }
327  return false;
328 }
329 
330 void PluginDisplay::display_step(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
331  PortDesc *q = it->get_value(port_liststore->col.port);
332  DisplayType tp = q->get_tp();
333  cell->property_visible().set_value(tp == tp_scale || tp == tp_scale_log);
334  if (q->step != stp_normal) {
335  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red");
336  } else {
337  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false);
338  }
339 }
340 
341 void PluginDisplay::display_ladspa(Gtk::CellRenderer *cell, const Gtk::TreeIter& iter) {
342  PluginDesc *p = iter->get_value(plugin_liststore->col.pdesc);
343  if (p->has_settings) {
344  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red");
345  } else {
346  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false);
347  }
348 }
349 
350 void PluginDisplay::display_label(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
351  PortDesc *q = it->get_value(enum_liststore->col.port);
352  if (q->enumkey_changed(int(it->get_value(enum_liststore->col.value)))) {
353  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red");
354  } else {
355  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false);
356  }
357 }
358 
359 void PluginDisplay::display_idx(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
360  PortDesc *q = it->get_value(port_liststore->col.port);
361  if (int(port_liststore->get_path(it)[0]) != q->get_pos()) {
362  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red");
363  } else {
364  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false);
365  }
366 }
367 
368 void PluginDisplay::display_name(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
369  PortDesc *q = it->get_value(port_liststore->col.port);
371  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red");
372  } else {
373  dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false);
374  }
375 }
376 
377 void PluginDisplay::display_default(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
378  PortDesc *q = it->get_value(port_liststore->col.port);
379  Gtk::CellRendererText *tcell = dynamic_cast<Gtk::CellRendererText*>(cell);
380  tcell->property_foreground_set().set_value(false);
381  tcell->property_background_set().set_value(false);
382  DisplayType tp = q->get_tp();
383  if (tp == tp_display || tp == tp_display_toggle || tp == tp_none) {
384  cell->property_visible().set_value(false);
385  return;
386  }
387  cell->property_visible().set_value(true);
389  tcell->property_foreground().set_value("red");
390  } else if (q->fake_dflt) {
391  tcell->property_background().set_value("grey");
392  }
393 }
394 
395 void PluginDisplay::display_lower(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
396  PortDesc *q = it->get_value(port_liststore->col.port);
397  Gtk::CellRendererText *tcell = dynamic_cast<Gtk::CellRendererText*>(cell);
398  tcell->property_foreground_set().set_value(false);
399  tcell->property_background_set().set_value(false);
400  DisplayType tp = q->get_tp();
401  if (tp == tp_toggle || tp == tp_display_toggle || tp == tp_none) {
402  cell->property_visible().set_value(false);
403  return;
404  }
405  cell->property_visible().set_value(true);
407  tcell->property_foreground().set_value("red");
408  } else if (q->fake_low) {
409  tcell->property_background().set_value("grey");
410  }
411 }
412 
413 void PluginDisplay::display_upper(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
414  PortDesc *q = it->get_value(port_liststore->col.port);
415  Gtk::CellRendererText *tcell = dynamic_cast<Gtk::CellRendererText*>(cell);
416  tcell->property_foreground_set().set_value(false);
417  tcell->property_background_set().set_value(false);
418  DisplayType tp = q->get_tp();
419  if (tp == tp_toggle || tp == tp_display_toggle || tp == tp_none) {
420  cell->property_visible().set_value(false);
421  return;
422  }
423  cell->property_visible().set_value(true);
425  tcell->property_foreground().set_value("red");
426  } else if (q->fake_up) {
427  tcell->property_background().set_value("grey");
428  }
429 }
430 
431 void PluginDisplay::display_SR(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
432  cell->property_visible().set_value(it->get_value(port_liststore->col.port)->has_sr);
433 }
434 
435 void PluginDisplay::display_type(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
436  PortDesc *q = it->get_value(port_liststore->col.port);
437  Gtk::CellRendererText *tcell = dynamic_cast<Gtk::CellRendererText*>(cell);
439  tcell->property_foreground().set_value("red");
440  } else {
441  tcell->property_foreground_set().set_value(false);
442  }
443 }
444 
445 void PluginDisplay::display_newrow(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
446  PortDesc *q = it->get_value(port_liststore->col.port);
448  cell->property_cell_background().set_value("red");
449  } else {
450  cell->property_cell_background_set().set_value(false);
451  }
452 }
453 
454 void PluginDisplay::display_caption(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
455  PortDesc *q = it->get_value(port_liststore->col.port);
456  if (!q->has_caption) {
457  cell->property_cell_background().set_value("red");
458  } else {
459  cell->property_cell_background_set().set_value(false);
460  }
461 }
462 
463 void PluginDisplay::on_delete_changes() {
464  if (!current_plugin) {
465  return;
466  }
467  current_plugin->reset();
468  int changed = current_plugin->check_changed();
469  int change_diff = changed - old_state;
470  if (change_diff) {
471  change_count += change_diff;
472  set_title();
473  }
474  if (!changed) {
475  current_plugin->clear_old();
476  }
477  current_plugin = 0;
478  selection_changed();
479 }
480 
481 void PluginDisplay::on_search_entry_activate() {
482  Gtk::TreeIter it = treeview1->get_selection()->get_selected();
483  if (it) {
484  bool v = !it->get_value(plugin_liststore->col.active);
485  it->set_value(plugin_liststore->col.active, v);
486  change_count += it->get_value(plugin_liststore->col.pdesc)->set_active(v);
487  set_title();
488  }
489 }
490 
491 bool PluginDisplay::check_for_changes() {
492  PluginDesc *cur = current_plugin;
493  save_current();
494  bool ret = false;
495  for (std::vector<PluginDesc*>::iterator p = pluginlist.begin(); p != pluginlist.end(); ++p) {
496  if ((*p)->active != (*p)->active_set) {
497  ret = true;
498  break;
499  }
500  if ((*p)->old) {
501  ret = true;
502  break;
503  }
504  }
505  if (cur) {
506  set_old_state(cur);
507  }
508  return ret;
509 }
510 
511 int PluginDisplay::ask_discard() {
512  Gtk::MessageDialog d(*window, _("Discard changes to plugin definitions?"), false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_YES_NO, true);
513  return d.run();
514 }
515 
517  if (check_for_changes()) {
518  int ret = ask_discard();
519  if (ret != Gtk::RESPONSE_YES) {
520  return false;
521  }
522  }
523  return true;
524 }
525 
526 bool PluginDisplay::on_delete_event(GdkEventAny *) {
527  return !check_exit();
528 }
529 
530 void PluginDisplay::on_quit() {
531  if (check_exit()) {
532  finished_callback(false, true);
533  }
534 }
535 
536 void PluginDisplay::on_find() {
537  search_entry->grab_focus();
538 }
539 
540 void PluginDisplay::display_quirks(const Gtk::TreeIter& it) {
541  if (!current_plugin) {
542  cellrenderer_quirks->property_foreground_set().set_value(false);
543  } else {
544  int quirks;
545  it->get_value(1, quirks);
546  if (quirks == current_plugin->quirks_default) {
547  cellrenderer_quirks->property_foreground_set().set_value(false);
548  } else {
549  cellrenderer_quirks->property_foreground().set_value("red");
550  }
551  }
552 }
553 
554 void PluginDisplay::display_category(const Gtk::TreeIter& it) {
555  if (!current_plugin) {
556  cellrenderer_category->property_foreground_set().set_value(false);
557  } else {
558  ustring cat;
559  it->get_value(0, cat);
560  if (cat == current_plugin->deduced_category) {
561  cellrenderer_category->property_foreground_set().set_value(false);
562  } else {
563  cellrenderer_category->property_foreground().set_value("red");
564  }
565  }
566 }
567 
568 void PluginDisplay::load() {
569  int a = combobox_mono_stereo->get_model()->get_path(combobox_mono_stereo->get_active())[0];
570  bool s = selected_only->get_active();
571  bool c = changed_only->get_active();
572  bool d = ladspa_only->get_active();
573  bool e = lv2_only->get_active();
574  plugin_liststore->clear();
575  for (std::vector<PluginDesc*>::iterator v = pluginlist.begin(); v != pluginlist.end(); ++v) {
576  if (s && !(*v)->active) {
577  continue;
578  }
579  else if (c && !(*v)->has_settings) {
580  continue;
581  }
582  else if (d && (*v)->is_lv2) {
583  continue;
584  }
585  else if (e && !(*v)->is_lv2) {
586  continue;
587  }
588  if ((a == 1 && (*v)->tp != 0) || (a == 2 && (*v)->tp != 1)) {
589  continue;
590  }
591 
592  Gtk::TreeIter it = plugin_liststore->append();
593  it->set_value(plugin_liststore->col.name, ustring((*v)->Name));
594  it->set_value(plugin_liststore->col.active, (*v)->active);
595  it->set_value(plugin_liststore->col.pdesc, *v);
596  }
597 }
598 
599 void PluginDisplay::on_save() {
600  finished_callback(do_save(), true);
601 }
602 
603 void PluginDisplay::on_apply() {
604  if (do_save()) {
605  finished_callback(true, false);
606  }
607  reload_plug = false;
608  needs_reload.clear();
609  selection_changed();
610 }
611 
612 void PluginDisplay::on_stereo_to_mono() {
613  for (std::vector<PluginDesc*>::iterator p = needs_reload.begin(); p != needs_reload.end(); ++p) {
614  (*p)->active_set = (*p)->active = false;
615  }
616  machine.save_ladspalist(pluginlist);
617  finished_callback(true, false);
618  reload_plug = false;
619  for (std::vector<PluginDesc*>::iterator p = needs_reload.begin(); p != needs_reload.end(); ++p) {
620  (*p)->active_set = (*p)->active = true;
621  }
622  needs_reload.clear();
623 }
624 
625 bool PluginDisplay::do_save() {
626  bool changed = check_for_changes();
627  if (changed && reload_plug) on_stereo_to_mono();
628  machine.save_ladspalist(pluginlist);
629  for (std::vector<PluginDesc*>::iterator p = pluginlist.begin(); p != pluginlist.end(); ++p) {
630  (*p)->active_set = (*p)->active;
631  (*p)->clear_old();
632  }
633  old_state = 0;
634  change_count = 0;
635  set_title();
636  current_plugin = 0;
637  return changed;
638 }
639 
640 void PluginDisplay::on_select_all(bool v) {
641  int d = 0;
642  Gtk::TreeNodeChildren ch = plugin_liststore->children();
643  for (Gtk::TreeIter it = ch.begin(); it != ch.end(); ++it) {
644  it->set_value(plugin_liststore->col.active, v);
645  d += it->get_value(plugin_liststore->col.pdesc)->set_active(v);
646  }
647  if (d) {
648  change_count += d;
649  set_title();
650  }
651 }
652 
653 void PluginDisplay::on_show_details() {
654  details_box->set_visible(show_details->get_active());
655  int w, h;
656  window->get_size(w, h);
657  window->resize(1, h);
658 }
659 
660 void PluginDisplay::on_add_dry_wet_controller() {
661  if (!current_plugin) {
662  return;
663  }
664  current_plugin->set_add_wet_dry_controller(dry_wet_button->get_active());
665 }
666 
667 void PluginDisplay::on_stereo_to_mono_controller() {
668  if (!current_plugin) {
669  return;
670  }
671  current_plugin->set_stereo_to_mono(stereo_to_mono_button->get_active());
672  reload_plug = true;
673  needs_reload.push_back(current_plugin);
674 }
675 
676 void PluginDisplay::on_row_activated(const Gtk::TreePath& path, Gtk::TreeViewColumn* column) {
677  show_details->clicked();
678 }
679 
680 void PluginDisplay::on_mono_stereo_changed() {
681  load();
682 }
683 
684 void PluginDisplay::on_view_changed(const Gtk::ToggleButton *b) {
685  if (b->get_active()) {
686  load();
687  }
688 }
689 
690 void PluginDisplay::save_current() {
691  if (!current_plugin) {
692  return;
693  }
694  ustring s = plugin_name->get_text();
695  gx_system::strip(s);
696  if (s.empty()) {
697  current_plugin->shortname = current_plugin->Name;
698  } else {
699  current_plugin->shortname = s;
700  }
701  plugin_category->get_active()->get_value(1, current_plugin->category);
702  plugin_quirks->get_active()->get_value(1, current_plugin->quirks);
703  Gtk::TreeIter it = master_slider_idx->get_active();
704  if (it) {
705  it->get_value(0, current_plugin->MasterIdx);
706  } else {
707  current_plugin->MasterIdx = -1;
708  }
709  if (current_plugin->MasterIdx < 0) {
710  current_plugin->MasterLabel = "";
711  } else {
712  current_plugin->MasterLabel = master_slider_name->get_text();
713  }
714  current_plugin->check_has_settings();
715  int changed = current_plugin->check_changed();
716  int change_diff = changed - old_state;
717  if (change_diff) {
718  change_count += change_diff;
719  set_title();
720  }
721  if (!changed) {
722  current_plugin->clear_old();
723  }
724  current_plugin = 0;
725 }
726 
727 void PluginDisplay::set_title() {
728  ustring t = _("Select LADSPA/LV2 plugins for Guitarix");
729  if (change_count) {
730  window->set_title(t + _(" (*changed*)"));
731  } else {
732  window->set_title(t);
733  }
734 }
735 
736 void PluginDisplay::set_old_state(PluginDesc *p) {
737  current_plugin = p;
738  old_state = (p->old != 0);
739  if (!p->old) {
740  p->set_old();
741  }
742 }
743 
744 void PluginDisplay::selection_changed() {
745  Gtk::TreeIter it = treeview1->get_selection()->get_selected();
746  PluginDesc *p = 0;
747  if (it) {
748  p = it->get_value(plugin_liststore->col.pdesc);
749  if (current_plugin == p) {
750  return;
751  }
752  }
753  save_current();
754  on_reordered_conn.block();
755  port_liststore->clear();
756  on_reordered_conn.unblock();
757  ladspa_category->set_text("");
758  ladspa_maker->set_text("");
759  ladspa_uniqueid->set_text("");
760  plugin_name->set_text("");
761  plugin_category->set_active(-1);
762  plugin_quirks->set_active(-1);
763  if (!p) {
764  return;
765  }
766  set_old_state(p);
767  if (p->shortname != p->Name) {
768  plugin_name->modify_text(Gtk::STATE_NORMAL, Gdk::Color("red"));
769  } else {
770  plugin_name->unset_text(Gtk::STATE_NORMAL);
771  }
772  plugin_name->set_text(p->shortname);
773  Gtk::TreeNodeChildren ch = plugin_category->get_model()->children();
774  int i = 0;
775  for (it = ch.begin(); it != ch.end(); ++it, ++i) {
776  ustring cat;
777  it->get_value(1, cat);
778  if (cat == p->category) {
779  plugin_category->set_active(i);
780  break;
781  }
782  }
783  ch = plugin_quirks->get_model()->children();
784  for (i = 0, it = ch.begin(); it != ch.end(); ++it, ++i) {
785  int quirks;
786  it->get_value(1, quirks);
787  if (quirks == p->quirks) {
788  plugin_quirks->set_active(i);
789  break;
790  }
791  }
792  Glib::RefPtr<Gtk::ListStore> ls_master = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(master_slider_idx->get_model());
793  ls_master->clear();
794  it = ls_master->append();
795  i = -1;
796  it->set_value(0, i);
797  ustring ml("");
798  for (unsigned int i = 0; i < p->ctrl_ports.size(); ++i) {
799  it = ls_master->append();
800  it->set_value(0, int(i));
801  if (p->ctrl_ports[i]->pos == p->MasterIdx) {
802  ml = p->ctrl_ports[i]->factory.get_name();
803  }
804  }
805  master_slider_idx->set_active(p->MasterIdx+1);
806  master_slider_name->unset_text(Gtk::STATE_NORMAL);
807  if (!p->MasterLabel.empty()) {
808  master_slider_name->set_text(p->MasterLabel);
809  if (p->MasterLabel != ml) {
810  master_slider_name->modify_text(Gtk::STATE_NORMAL, Gdk::Color("red"));
811  }
812  }
813  dry_wet_button->set_active(current_plugin->add_wet_dry);
814  stereo_to_mono_button->set_active(current_plugin->stereo_to_mono);
815  stereo_to_mono_button->set_sensitive(p->tp);
816  ladspa_category->set_text(p->ladspa_category);
817  ladspa_maker->set_text(p->Maker);
818  if (p->is_lv2) {
819  ladspa_uniqueid->set_text(ustring::compose("LV2: %1", p->path));
820  } else {
821  ladspa_uniqueid->set_text(ustring::compose("%1: %2[%3]", p->UniqueID, p->path, p->index));
822  }
823  for (unsigned int i = 0; i < p->ctrl_ports.size(); ++i) {
824  PortDesc *q = p->ctrl_ports[i];
825  Glib::RefPtr<Gtk::ListStore> tls;
826  if (q->is_output) {
827  tls = output_type_list;
828  } else if (q->has_sr) {
829  tls = display_type_list_sr;
830  } else {
831  tls = display_type_list;
832  }
833  float dflt = q->get_dflt();
834  float low = q->get_low();
835  float up = q->get_up();
836  if (q->has_sr && !q->use_sr) {
838  dflt *= q->SR;
839  }
841  low *= q->SR;
842  }
844  up *= q->SR;
845  }
846  }
847  it = port_liststore->append();
848  it->set_value(port_liststore->col.pos, q->pos);
849  it->set_value(port_liststore->col.name, q->get_name());
850  it->set_value(port_liststore->col.dflt, ustring::format(dflt));
851  it->set_value(port_liststore->col.low, ustring::format(low));
852  it->set_value(port_liststore->col.up, ustring::format(up));
853  it->set_value(port_liststore->col.step, ustring(step_type_names[q->step]));
854  it->set_value(port_liststore->col.display, ustring(display_type_names[q->get_tp()]));
855  it->set_value(port_liststore->col.display_types, tls);
856  it->set_value(port_liststore->col.port, q);
857  it->set_value(port_liststore->col.newrow, q->get_newrow());
858  it->set_value(port_liststore->col.use_sr, q->has_sr && !q->use_sr);
859  it->set_value(port_liststore->col.has_caption, q->has_caption);
860  }
861 }
862 
863 void PluginDisplay::display_master_idx(const Gtk::TreeIter& it) {
864  int i;
865  it->get_value(0, i);
866  if (i < 0) {
867  cellrenderer_master->property_text().set_value("--");
868  cellrenderer_master->property_foreground_set().set_value(false);
869  } else {
870  cellrenderer_master->property_foreground().set_value("red");
871  }
872 }
873 
874 void PluginDisplay::set_master_text() {
875  Gtk::TreeIter it = master_slider_idx->get_active();
876  if (!it) {
877  master_slider_name->set_text("");
878  master_slider_name->set_editable(false);
879  return;
880  }
881  int idx;
882  it->get_value(0, idx);
883  if (idx < 0) {
884  master_slider_name->set_text("");
885  master_slider_name->set_editable(false);
886  } else {
887  for (std::vector<PortDesc*>::iterator q = current_plugin->ctrl_ports.begin(); q != current_plugin->ctrl_ports.end(); ++q) {
888  if ((*q)->pos == idx) {
889  master_slider_name->set_text((*q)->factory.get_name());
890  break;
891  }
892  }
893  master_slider_name->set_editable(true);
894  }
895 }
896 
897 void PluginDisplay::on_parameter_selection_changed() {
898  Gtk::TreeIter it = treeview2->get_selection()->get_selected();
899  enum_liststore->clear();
900  if (it) {
901  PortDesc *q = it->get_value(port_liststore->col.port);
902  if (q->get_tp() == tp_enum) {
903  int up = int(q->get_up());
904  for (int idx = int(q->get_low()); idx <= up; ++idx) {
905  it = enum_liststore->append();
906  it->set_value(enum_liststore->col.value, idx);
907  it->set_value(enum_liststore->col.label, q->get_enum(idx));
908  it->set_value(enum_liststore->col.port, q);
909  }
910  }
911  }
912 }
913 
914 void PluginDisplay::on_reordered(const Gtk::TreePath& path) {
915  assert(current_plugin);
916  std::map<int,int> d;
917  for (unsigned int i = 0; i < current_plugin->ctrl_ports.size(); ++i) {
918  d[current_plugin->ctrl_ports[i]->pos] = i;
919  }
920  std::vector<PortDesc*> l;
921  Gtk::TreeNodeChildren ch = port_liststore->children();
922  for (Gtk::TreeIter it = ch.begin(); it != ch.end(); ++it) {
923  l.push_back(current_plugin->ctrl_ports[d[it->get_value(port_liststore->col.pos)]]);
924  }
925  current_plugin->ctrl_ports = l;
926 }
927 
928 void PluginDisplay::on_type_edited(const ustring& path, const ustring& newtext) {
929  Gtk::TreeIter it = port_liststore->get_iter(path);
930  PortDesc *q = it->get_value(port_liststore->col.port);
931  DisplayType tp_old = q->user.get_tp();
932  DisplayType tp = tp_scale;
933  for (unsigned int i = 0; i < sizeof(display_type_names)/sizeof(display_type_names[0]); i++) {
934  if (newtext == display_type_names[i]) {
935  tp = static_cast<DisplayType>(i);
936  break;
937  }
938  }
939  q->set_tp(tp);
940  if (tp != tp_old) {
941  if (tp == tp_scale_log) {
942  if (q->get_low() <= 0) {
943  q->set_low(1e-7);
944  }
945  if (q->get_up() <= q->get_low()) {
946  q->set_up(q->get_low()*1000);
947  }
948  float dflt = q->get_dflt();
949  if (!(q->get_low() <= dflt && dflt <= q->get_up())) {
950  q->set_dflt(q->get_low());
951  }
952  } else if (tp == tp_toggle) {
953  q->set_dflt(int(q->get_dflt() != 0));
954  q->set_low(0);
955  q->set_up(1);
956  } else if (tp == tp_enum || tp == tp_int) {
957  q->set_dflt(round(q->get_dflt()));
958  q->set_low(round(q->get_low()));
959  q->set_up(round(q->get_up()));
960  }
961  float dflt = q->get_dflt();
962  float low = q->get_low();
963  float up = q->get_up();
964  if (q->has_sr && !q->use_sr) {
965  dflt *= q->SR;
966  low *= q->SR;
967  up *= q->SR;
968  }
969  it->set_value(port_liststore->col.dflt, ustring::format(dflt));
970  it->set_value(port_liststore->col.low, ustring::format(low));
971  it->set_value(port_liststore->col.up, ustring::format(up));
972  }
973  it->set_value(port_liststore->col.display, newtext);
974  on_parameter_selection_changed();
975 }
976 
977 void PluginDisplay::on_step_edited(const ustring& path, const ustring& newtext) {
978  Gtk::TreeIter it = port_liststore->get_iter(path);
979  step_mode m = stp_normal;
980  for (unsigned int i = 0; i < sizeof(step_type_names)/sizeof(step_type_names[0]); ++i) {
981  if (step_type_names[i] == newtext) {
982  m = static_cast<step_mode>(i);
983  break;
984  }
985  }
986  it->get_value(port_liststore->col.port)->step = m;
987  it->set_value(port_liststore->col.step, newtext);
988 }
989 
990 void PluginDisplay::on_label_edited(const ustring& path, const ustring& newtext) {
991  Gtk::TreeIter it = enum_liststore->get_iter(path);
992  PortDesc *q = it->get_value(enum_liststore->col.port);
993  ustring text(newtext);
994  gx_system::strip(text);
995  int idx = it->get_value(enum_liststore->col.value);
996  std::map<int, ustring>::iterator i = q->factory.find_enum(idx);
997  if (text.empty() || (i != q->factory.enum_end() && i->second == text)) {
998  q->user.erase_enum(idx);
999  text = "";
1000  }
1001  if (text.empty()) {
1002  std::map<int, ustring>::iterator i = q->factory.find_enum(idx);
1003  if (i == q->factory.enum_end()) {
1004  text = ustring::format(idx);
1005  } else {
1006  text = i->second;
1007  }
1008  } else {
1009  q->user.set_enumvalue(idx, text);
1010  }
1011  it->set_value(enum_liststore->col.label, text);
1012 }
1013 
1014 void PluginDisplay::on_name_edited(const ustring& path, const ustring& newtext) {
1015  Gtk::TreeIter it = port_liststore->get_iter(path);
1016  PortDesc *q = it->get_value(port_liststore->col.port);
1017  ustring text(newtext);
1018  gx_system::strip(text);
1019  if (text.empty() || q->factory.get_name() == text) {
1021  } else {
1022  q->user.set_name(text);
1023  }
1024  it->set_value(port_liststore->col.name, q->get_name());
1025 }
1026 
1027 void PluginDisplay::on_dflt_edited(const ustring& path, const ustring& newtext) {
1028  Gtk::TreeIter it = port_liststore->get_iter(path);
1029  PortDesc *q = it->get_value(port_liststore->col.port);
1030  ustring text(newtext);
1031  gx_system::strip(text);
1032  float val;
1033  if (text.empty()) {
1035  val = q->factory.get_dflt();
1036  if (val < q->get_low()) {
1037  q->set_low(val);
1038  }
1039  if (val > q->get_up()) {
1040  q->set_up(val);
1041  }
1042  if (q->has_sr && !q->use_sr) {
1043  val *= q->SR;
1044  }
1045  } else {
1046  char *p;
1047  val = strtod(text.c_str(), &p);
1048  if (p != text.c_str() + text.size()) {
1049  return;
1050  }
1051  float val2;
1052  if (q->has_sr && !q->use_sr) {
1053  val2 = val / q->SR;
1054  } else {
1055  val2 = val;
1056  }
1057  if (!(q->get_low() <= val2 && val2 <= q->get_up())) {
1058  return;
1059  }
1060  q->set_dflt(val2);
1061  }
1062  it->set_value(port_liststore->col.dflt, ustring::format(val));
1063 }
1064 
1065 void PluginDisplay::on_low_edited(const ustring& path, const ustring& newtext) {
1066  Gtk::TreeIter it = port_liststore->get_iter(path);
1067  PortDesc *q = it->get_value(port_liststore->col.port);
1068  ustring text(newtext);
1069  gx_system::strip(text);
1070  float val;
1071  if (text.empty()) {
1073  val = q->factory.get_low();
1074  if (q->get_dflt() < val) {
1075  q->set_dflt(val);
1076  }
1077  if (q->get_up() < val) {
1078  q->set_up(min(q->get_up(),val+1));
1079  }
1080  if (q->has_sr && !q->use_sr) {
1081  val *= q->SR;
1082  }
1083  } else {
1084  char *p;
1085  val = strtod(text.c_str(), &p);
1086  if (p != text.c_str() + text.size()) {
1087  return;
1088  }
1089  float val2;
1090  if (q->has_sr && !q->use_sr) {
1091  val2 = val/q->SR;
1092  } else {
1093  val2 = val;
1094  }
1095  if (!(val2 < q->get_up())) {
1096  return;
1097  }
1098  if (q->get_dflt() < val2) {
1099  q->user.set_dflt(val2);
1100  }
1101  it->set_value(port_liststore->col.dflt, ustring::format(q->get_dflt()));
1102  q->set_low(val2);
1103  if (q->get_tp() == tp_enum) {
1104  on_parameter_selection_changed();
1105  }
1106  }
1107  it->set_value(port_liststore->col.low, ustring::format(val));
1108 }
1109 
1110 void PluginDisplay::on_up_edited(const ustring& path, const ustring& newtext) {
1111  Gtk::TreeIter it = port_liststore->get_iter(path);
1112  PortDesc *q = it->get_value(port_liststore->col.port);
1113  ustring text(newtext);
1114  gx_system::strip(text);
1115  float val;
1116  if (text.empty()) {
1118  val = q->factory.get_up();
1119  if (q->get_dflt() > val) {
1120  q->set_dflt(val);
1121  }
1122  if (q->get_low() > val) {
1123  q->set_low(max(q->get_low(),val-1));
1124  }
1125  if (q->has_sr && !q->use_sr) {
1126  val *= q->SR;
1127  }
1128  } else {
1129  char *p;
1130  val = strtod(text.c_str(), &p);
1131  if (p != text.c_str() + text.size()) {
1132  return;
1133  }
1134  float val2;
1135  if (q->has_sr && !q->use_sr) {
1136  val2 = val/q->SR;
1137  } else {
1138  val2 = val;
1139  }
1140  if (!(val2 > q->get_low())) {
1141  return;
1142  }
1143  if (q->get_dflt() > val2) {
1144  q->user.set_dflt(val2);
1145  }
1146  it->set_value(port_liststore->col.dflt, ustring::format(q->get_dflt()));
1147  q->set_up(val2);
1148  if (q->get_tp() == tp_enum) {
1149  on_parameter_selection_changed();
1150  }
1151  }
1152  it->set_value(port_liststore->col.up, ustring::format(val));
1153 }
1154 
1155 void PluginDisplay::on_newrow_toggled(const ustring& path) {
1156  Gtk::TreeIter it = port_liststore->get_iter(path);
1157  PortDesc *q = it->get_value(port_liststore->col.port);
1158  bool s = !cellrenderer_newrow->get_active();
1159  it->set_value(port_liststore->col.newrow, s);
1160  if (s == q->factory.get_newrow()) {
1162  } else {
1163  q->user.set_newrow(s);
1164  }
1165 }
1166 
1167 void PluginDisplay::on_caption_toggled(const ustring& path) {
1168  Gtk::TreeIter it = port_liststore->get_iter(path);
1169  PortDesc *q = it->get_value(port_liststore->col.port);
1170  bool s = !cellrenderer_caption->get_active();
1171  it->set_value(port_liststore->col.has_caption, s);
1172  q->has_caption = s;
1173 }
1174 
1175 void PluginDisplay::on_active_toggled(const ustring& path) {
1176  Gtk::TreeIter it = plugin_liststore->get_iter(path);
1177  bool s = !cellrenderer_active->get_active();
1178  it->set_value(plugin_liststore->col.active, s);
1179  change_count += it->get_value(plugin_liststore->col.pdesc)->set_active(s);
1180  set_title();
1181 }
1182 
1183 } // namespace ladspa
CmdConnection::msg_type end
Definition: jsonrpc.cpp:258
CmdConnection::msg_type start
Definition: jsonrpc.cpp:257
void set_enumvalue(int k, const Glib::ustring &v)
Definition: ladspaback.h:66
std::string get_builder_filepath(const std::string &basename) const
Definition: gx_system.h:373
Glib::ustring Maker
Definition: ladspaback.h:140
DisplayType
Definition: ladspaback.h:27
void erase_enum(int k)
Definition: ladspaback.h:68
void set_low(float v)
Definition: ladspaback.cpp:329
DisplayType get_tp()
Definition: ladspaback.h:111
void set_up(float v)
Definition: ladspaback.cpp:337
const Glib::ustring & get_name()
Definition: ladspaback.h:59
Glib::ustring category
Definition: ladspaback.h:147
void set_add_wet_dry_controller(bool v)
std::map< int, Glib::ustring >::iterator enum_end()
Definition: ladspaback.h:69
static CellRendererComboDerived * create_from_builder(BaseObjectType *cobject)
Definition: ladspalist.cpp:68
ChangeableValues factory
Definition: ladspaback.h:92
void set_dflt(float v)
Definition: ladspaback.cpp:345
void set_tp(DisplayType v)
Definition: ladspaback.cpp:353
std::vector< PortDesc * > ctrl_ports
Definition: ladspaback.h:144
PluginDisplay(gx_engine::GxMachineBase &machine, Glib::RefPtr< Gdk::Pixbuf > icon, sigc::slot< void, bool, bool > finished_callback)
Definition: ladspalist.cpp:73
std::string ladspa_category
Definition: ladspaback.h:152
DisplayType get_tp()
Definition: ladspaback.h:63
float get_dflt()
Definition: ladspaback.h:114
PluginDesc * old
Definition: ladspaback.h:158
const Glib::ustring & get_name()
Definition: ladspaback.h:116
Glib::ustring deduced_category
Definition: ladspaback.h:148
Glib::ustring Name
Definition: ladspaback.h:138
void set_newrow(bool v)
Definition: ladspaback.h:58
#define min(x, y)
step_mode step
Definition: ladspaback.h:88
bool is_set(int f)
Definition: ladspaback.h:125
#define max(x, y)
bool is_set(int f) const
Definition: ladspaback.h:51
std::string to_string(const T &t)
Definition: gx_system.h:529
virtual void save_ladspalist(ladspa::LadspaPluginList &pluginlist)=0
const char * display_type_names[]
Definition: ladspalist.cpp:33
Glib::ustring MasterLabel
Definition: ladspaback.h:142
ChangeableValues user
Definition: ladspaback.h:93
const char * step_type_names[]
Definition: ladspalist.cpp:32
Glib::ustring shortname
Definition: ladspaback.h:139
void set_name(const Glib::ustring &nm)
Definition: ladspaback.h:53
virtual gx_system::CmdlineOptions & get_options() const =0
void strip(Glib::ustring &s)
Definition: gx_system.cpp:984
CellRendererComboDerived(BaseObjectType *castitem)
Definition: ladspalist.cpp:66
Glib::ustring get_enum(int idx)
Definition: ladspaback.cpp:369
void set_stereo_to_mono(bool v)
Definition: bigknob.cc:41
virtual void load_ladspalist(std::vector< std::string > &old_not_found, ladspa::LadspaPluginList &pluginlist)=0
bool enumkey_changed(int k)
Definition: ladspaback.h:124
unsigned long UniqueID
Definition: ladspaback.h:136
static const int SR
Definition: ladspaback.h:94
void set_dflt(float v)
Definition: ladspaback.h:54
std::map< int, Glib::ustring >::iterator find_enum(int k)
Definition: ladspaback.h:67
std::string path
Definition: ladspaback.h:145