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