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