Guitarix
gx_sequencer_settings.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2017 Hermann Meyer, Andreas Degert
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 
20 #include "guitarix.h" // NOLINT
21 
22 namespace gx_seq {
23 
24 #define DRUMS 6
25 
26 #define FOR_DRUMS(func) std::for_each(drums.begin(), drums.end(), [&](Drums d) { func });
27 
28 /****************************************************************
29  ** PluginPresetConnectWindow
30  */
31 
32 PluginPresetConnectWindow *PluginPresetConnectWindow::create_from_builder(
33  BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& _machine) {
34  return new PluginPresetConnectWindow(cobject, bld, _machine);
35 }
36 
38 }
39 
41  gx_engine::GxMachineBase& machine) {
42  Glib::RefPtr<gx_gui::GxBuilder> bld = gx_gui::GxBuilder::create_from_file(
43  machine.get_options().get_builder_filepath("pluginpreset_connectwindow.glade"));
45  bld->get_toplevel_derived("PluginPresetConnectWindow", w,
46  sigc::bind(sigc::ptr_fun(PluginPresetConnectWindow::create_from_builder), bld, sigc::ref(machine)));
47  return w;
48 }
49 
50 bool PluginPresetConnectWindow::on_key_press_event(GdkEventKey *event) {
51  if (event->keyval == GDK_KEY_Escape && (event->state & Gtk::AccelGroup::get_default_mod_mask()) == 0) {
52  hide();
53  return true;
54  }
55  return Gtk::Window::on_key_press_event(event);
56 }
57 
58 void PluginPresetConnectWindow::on_connect() {
59  Gtk::TreeIter it = treeview->get_selection()->get_selected();
60  if (it && !machine.midi_get_config_mode()) {
61  Glib::ustring id = "seq." + it->get_value(upresetliststore->col.name);
62  if (machine.parameter_hasId(id))
63  new gx_main_midi::MidiConnect(0, machine.get_parameter(id), machine);
64  }
65 }
66 
67 PluginPresetConnectWindow::PluginPresetConnectWindow(
68  BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& _machine)
69  : Gtk::Window(cobject),
70  upresetliststore(UPresetListStore::create()),
71  machine(_machine) {
72  set_title("Connect Midi");
73  Gtk::Button *b;
74  bld->find_widget("closebutton", b);
75  b->signal_clicked().connect(
76  sigc::mem_fun(*this, &PluginPresetConnectWindow::hide));
77  bld->find_widget("connectbutton", connectbutton);
78  connectbutton->signal_clicked().connect(
79  sigc::mem_fun0(*this, &PluginPresetConnectWindow::on_connect));
80  bld->find_widget("treeview", treeview);
81  gx_preset::UnitPresetList presetnames;
82  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
83  for (gx_preset::UnitPresetList::const_iterator i = presetnames.begin(); i != presetnames.end(); ++i) {
84  if (i->name.empty()) {
85  break;
86  }
87  upresetliststore->append()->set_value(upresetliststore->col.name, i->name);
88  }
89  treeview->set_model(upresetliststore);
90  connectbutton->set_sensitive(false);
91  Glib::RefPtr<Gtk::TreeSelection> sel = treeview->get_selection();
92  sel->signal_changed().connect(
93  sigc::mem_fun(*this, &PluginPresetConnectWindow::on_selection_changed));
94 }
95 
96 void PluginPresetConnectWindow::on_selection_changed() {
97  connectbutton->set_sensitive(treeview->get_selection()->get_selected());
98 }
99 
101  Gtk::Main::run(*this);
102 }
103 
104 /****************************************************************
105  ** Sequencer Parameter Window
106  */
107 
108 SEQWindow *SEQWindow::create(const std::string& unit_id, gx_engine::GxMachineBase& machine) {
109  Glib::RefPtr<gx_gui::GxBuilder> bld = gx_gui::GxBuilder::create_from_file(
110  machine.get_options().get_builder_filepath("Sequencer.glade"), &machine);
111  gx_engine::SeqParameter *tomp = dynamic_cast<gx_engine::SeqParameter*>(&machine.get_parameter("seq.sequencer.tom"));
112  gx_engine::SeqParameter *tomp1 = dynamic_cast<gx_engine::SeqParameter*>(&machine.get_parameter("seq.sequencer.tom1"));
113  gx_engine::SeqParameter *tomp2 = dynamic_cast<gx_engine::SeqParameter*>(&machine.get_parameter("seq.sequencer.tom2"));
114  gx_engine::SeqParameter *kickp = dynamic_cast<gx_engine::SeqParameter*>(&machine.get_parameter("seq.sequencer.kick"));
115  gx_engine::SeqParameter *snarep = dynamic_cast<gx_engine::SeqParameter*>(&machine.get_parameter("seq.sequencer.snare"));
116  gx_engine::SeqParameter *hatp = dynamic_cast<gx_engine::SeqParameter*>(&machine.get_parameter("seq.sequencer.hat"));
117  assert(tomp);
118  assert(tomp1);
119  assert(tomp2);
120  assert(kickp);
121  assert(snarep);
122  assert(hatp);
123  return new SEQWindow(bld, tomp, tomp1, tomp2, kickp, snarep, hatp, machine);
124 }
125 
126 /*
127  ** Constructor
128  */
129 
130 SEQWindow::SEQWindow(const Glib::RefPtr<gx_gui::GxBuilder>& bld,gx_engine::SeqParameter *tomp_,
134  : machine(machine_),
135  builder(bld),
136  tom(tomp_),
137  tom1(tomp1_),
138  tom2(tomp2_),
139  kick(kickp_),
140  snare(snarep_),
141  hat(hatp_),
142  is_active(false),
143  gtk_window(0) {
144  bld->get_toplevel("SequencerWindow", gtk_window);
145 
146  init_connect();
147 
148  // reset display
149 }
150 
151 void SEQWindow::init_connect() {
152 
153  builder->find_widget("viewport1", vp);
154  builder->find_widget("hbox1", tom.box);
155  builder->find_widget("hbox1a", tom1.box);
156  builder->find_widget("hbox1b", tom2.box);
157  builder->find_widget("hbox2", kick.box);
158  builder->find_widget("hbox3", snare.box);
159  builder->find_widget("hbox4", hat.box);
160  builder->find_widget("gxplayhead1", seq_pos);
161  builder->find_widget("gxsmallknob6", seq_count);
162  builder->find_widget("gxselector1", seq_tact);
163  builder->find_widget("hbox12", preset_button);
164  builder->find_widget("gxswitch6", add_button);
165  builder->find_widget("gxswitch3", next_preset);
166  builder->find_widget("gxswitch7", previus_preset);
167  builder->find_widget("gxswitch4", set_step);
168  builder->find_widget("gxswitch5", set_fstep);
169  builder->find_widget("gxswitch8", set_sync);
170  builder->find_widget("gxswitch9", reset_step);
171  builder->find_widget("label9:rack_label_inverse", preset_label);
172 
173  Pango::FontDescription font = preset_label->get_style()->get_font();
174  font.set_size(10*Pango::SCALE);
175  font.set_weight(Pango::WEIGHT_BOLD);
176  preset_label->modify_font(font);
177 
178  make_preset_button(preset_button);
179 
180  drums.push_back(tom);
181  drums.push_back(tom1);
182  drums.push_back(tom2);
183  drums.push_back(kick);
184  drums.push_back(snare);
185  drums.push_back(hat);
186 
187  on_sec_length_changed(false);
188 
189  FOR_DRUMS(
190  d.p->signal_changed().connect(sigc::bind(
191  sigc::mem_fun(this, &SEQWindow::seq_changed), d.box));
192  init_sequences(d.p, d.box);
193  );
194 
195  seq_pos->cp_set_value(0.0);
196  std::string id;
197  seq_pos->get_property("var_id",id);
198 
199  Glib::signal_timeout().connect(
200  sigc::bind<Gxw::Regler*>(sigc::bind<const std::string>(
201  sigc::mem_fun(*this, &SEQWindow::get_sequencer_pos),id), seq_pos), 60);
202 
203  seq_count->signal_value_changed().connect(
204  sigc::bind(sigc::mem_fun(*this, &SEQWindow::on_sec_length_changed), true));
205 
206  seq_tact->signal_value_changed().connect(
207  sigc::mem_fun(*this, &SEQWindow::on_sec_tact_changed));
208 
209  next_preset->signal_toggled().connect(
210  sigc::mem_fun(*this, &SEQWindow::on_next_preset));
211 
212  previus_preset->signal_toggled().connect(
213  sigc::mem_fun(*this, &SEQWindow::on_previus_preset));
214 
215  set_step->signal_toggled().connect(
216  sigc::mem_fun(*this, &SEQWindow::on_set_step));
217 
218  set_fstep->signal_toggled().connect(
219  sigc::mem_fun(*this, &SEQWindow::on_set_fstep));
220 
221  set_sync->signal_toggled().connect(
222  sigc::mem_fun(*this, &SEQWindow::on_sync_stepper));
223 
224  reset_step->signal_toggled().connect(
225  sigc::mem_fun(*this, &SEQWindow::on_reset_stepper));
226 
227  add_button->signal_clicked().connect(
228  sigc::mem_fun(*this, &SEQWindow::on_preset_add_clicked));
229  add_button->set_tooltip_text(_("add effect unit preset to the sequence"));
230 
231  gtk_window->signal_key_press_event().connect(
232  sigc::mem_fun(this, &SEQWindow::on_key_press_event));
233 }
234 
235 void SEQWindow::init_sequences(gx_engine::SeqParameter *p, Gtk::HBox* _box) {
236  Glib::ListHandle<Gtk::Widget*> List = _box->get_children();
237  for (Glib::ListHandle<Gtk::Widget*>::iterator itt = List.begin();itt != List.end(); ++itt) {
238  dynamic_cast<Gtk::ToggleButton*>((*itt))->signal_clicked().connect(
239  sigc::bind(sigc::bind(sigc::mem_fun(this, &SEQWindow::on_seq_button_clicked),p),_box));
240  }
241 }
242 
243 void SEQWindow::on_set_step() {
244  if (!set_step->get_active()) return;
245  float tactv = machine.get_parameter_value<float>("seq.tact");
246  float value = std::max(0,int(machine.get_parameter_value<float>("seq.step")-tactv));
247  reset_control("seq.step",value);
248  set_step->set_active(false);
249 }
250 
251 void SEQWindow::on_set_fstep() {
252  if (!set_fstep->get_active()) return;
253  float tactv = machine.get_parameter_value<float>("seq.tact");
254  float valuea = machine.get_parameter_value<float>("seq.asequences");
255  float value = std::min(int(valuea),int(machine.get_parameter_value<float>("seq.step")+tactv));
256  reset_control("seq.step",value);
257  set_fstep->set_active(false);
258 }
259 
260 void SEQWindow::on_sync_stepper() {
261  if (!set_sync->get_active()) return;
262  reset_control("seq.step",machine.get_parameter_value<float>("seq.step_orig"));
263  set_sync->set_active(false);
264 }
265 
266 void SEQWindow::on_reset_stepper() {
267  if (!reset_step->get_active()) return;
268  reset_control("seq.step",0.0);
269  reset_control("seq.step_orig",0.0);
270  reset_control("seq.pos",0.0);
271  reset_step->set_active(false);
272 }
273 
274 void SEQWindow::on_next_preset() {
275  if (!next_preset->get_active()) return;
276  if (!is_active) {
277  is_active = true;
278  Glib::signal_idle().connect_once(sigc::mem_fun(this, &SEQWindow::on_next_preset_set));
279  }
280 }
281 
282 void SEQWindow::on_next_preset_set() {
283  gx_preset::UnitPresetList presetnames;
284  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
285  for (gx_preset::UnitPresetList::iterator i = presetnames.begin(); i != presetnames.end(); ++i) {
286  if (!i->name.empty()) {
287  if (i->is_set) {
288  ++i;
289  if (i->name.empty()) i = presetnames.begin();
290  machine.plugin_preset_list_sync_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, i->name);
291  break;
292  } else {
293  machine.plugin_preset_list_sync_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, presetnames.begin()->name);
294  }
295  }
296  }
297  is_active = false;
298  reset_control("seq.npreset",0);
299 }
300 
301 void SEQWindow::on_previus_preset() {
302  if (!previus_preset->get_active()) return;
303  if (!is_active) {
304  is_active = true;
305  Glib::signal_idle().connect_once(sigc::mem_fun(this, &SEQWindow::on_previus_preset_set));
306  }
307 }
308 
309 void SEQWindow::on_previus_preset_set() {
310  gx_preset::UnitPresetList presetnames;
311  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
312  gx_preset::UnitPresetList::iterator i = presetnames.begin();
313  for ( i = presetnames.begin(); i != presetnames.end(); ++i) {
314  if (!i->name.empty()) {
315  if (i->is_set) break;
316  }
317  }
318  if (i == presetnames.begin()) {
319  i = presetnames.end();
320  --i;
321  } else if (i == presetnames.end()) {
322  i -=2;
323  }
324  --i;
325  machine.plugin_preset_list_sync_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, i->name);
326  is_active = false;
327  reset_control("seq.ppreset",0);
328 }
329 
330 void SEQWindow::on_preset_popup_clicked() {
331  Gtk::Menu *presetMenu = static_cast<Gtk::Menu*>(new PluginPresetPopup(machine.pluginlist_lookup_plugin("seq")->get_pdef(), machine));
332  Gtk::MenuItem* subitem = Gtk::manage(new Gtk::MenuItem("connect midi...", true));
333  presetMenu->append(*subitem);
334  subitem->signal_activate().connect(sigc::mem_fun(
335  *this, &SEQWindow::connect_midi));
336  presetMenu->show_all();
337 }
338 
339 void SEQWindow::connect_midi() {
341  w->run();
342  delete w;
343 }
344 
345 void SEQWindow::make_preset_button(Gtk::HBox * box) {
346  Gtk::Button *p = new Gtk::Button();
347  GtkWidget *l = gtk_image_new_from_stock("rack_preset", (GtkIconSize)-1);
348  p->add(*Gtk::manage(Glib::wrap(l)));
349  p->set_can_default(false);
350  p->set_can_focus(false);
351  p->set_tooltip_text(_("manage effect unit presets"));
352  p->set_name("effect_on_off");
353  box->pack_start(*Gtk::manage(p),Gtk::PACK_SHRINK);
354  p->signal_clicked().connect(
355  sigc::mem_fun(*this, &SEQWindow::on_preset_popup_clicked));
356  p->show_all();
357 }
358 
359 void SEQWindow::reset_control(Glib::ustring id, float value) {
360  machine.set_parameter_value(id,value);
361  machine.signal_parameter_value<float>(id)(value);
362 }
363 
364 int SEQWindow::append_sequence(const gx_engine::GxSeqSettings* seqc, gx_engine::SeqParameter *p, std::vector<int> *sequence) {
365  int s = 0;
366  std::vector<int> sequence_append = seqc->getseqline();
367  for(std::vector<int>::const_iterator i = sequence_append.begin(); i != sequence_append.end(); ++i) {
368  sequence->push_back(*i);
369  ++s;
370  }
371  return s;
372 }
373 
374 void SEQWindow::append_plugin_preset(Glib::ustring name) {
375  if (!is_active) {
376  is_active = true;
377  Glib::signal_timeout().connect_once(sigc::bind(sigc::mem_fun(this, &SEQWindow::append_plugin_preset_set),name),5);
378  }
379 }
380 
381 void SEQWindow::append_plugin_preset_set(Glib::ustring name) {
382  // get current sequences
383  std::vector<int> sequence[DRUMS];
384  int i = 0;
385  FOR_DRUMS(
386  sequence[i] = static_cast<const gx_engine::GxSeqSettings*>(&d.p->get_value())->getseqline();
387  ++i;
388  );
389 
390  // get current control values
391  float value = machine.get_parameter_value<float>("seq.asequences");
392  float bpmv = machine.get_parameter_value<float>("seq.bpm");
393  float tactv = machine.get_parameter_value<float>("seq.tact");
394  float gainv = machine.get_parameter_value<float>("seq.gain");
395  float tomg = machine.get_parameter_value<float>("seq.tom.dsp.Gain");
396  float tomg1 = machine.get_parameter_value<float>("seq.tom.dsp.Gain1");
397  float tomg2 = machine.get_parameter_value<float>("seq.tom.dsp.Gain2");
398  float kickg = machine.get_parameter_value<float>("seq.kick.dsp.Gain");
399  float snareg = machine.get_parameter_value<float>("seq.snare.dsp.Gain");
400  float hatg = machine.get_parameter_value<float>("seq.hat_closed.dsp.Gain");
401  // set preset values
402  machine.plugin_preset_list_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, name);
403 
404  // append preset sequence to current and get new step size
405  int s = 24;
406  i = 0;
407  FOR_DRUMS(
408  s = append_sequence(&d.p->get_value(), d.p, &sequence[i]);
409  ++i;
410  );
411 
412  // set new step size
413  value += float(s);
414  reset_control("seq.asequences",value);
415 
416  // set new sequences as parameter
418  i = 0;
419  FOR_DRUMS(
420  seqc.setseqline(sequence[i]);
421  d.p->set(seqc);
422  ++i;
423  );
424 
425  // reset controls to previus values
426  reset_control("seq.bpm",bpmv);
427  reset_control("seq.tact",tactv);
428  reset_control("seq.gain",gainv);
429  reset_control("seq.tom.dsp.Gain",tomg);
430  reset_control("seq.tom.dsp.Gain1",tomg1);
431  reset_control("seq.tom.dsp.Gain2",tomg2);
432  reset_control("seq.kick.dsp.Gain",kickg);
433  reset_control("seq.snare.dsp.Gain",snareg);
434  reset_control("seq.hat_closed.dsp.Gain",hatg);
435 
436  is_active = false;
437  }
438 
439 static bool delete_plugin_preset_popup(Gtk::Menu *presetMenu) {
440  delete presetMenu;
441  return false;
442 }
443 
444 void SEQWindow::on_selection_done(Gtk::Menu *presetMenu) {
445  Glib::signal_idle().connect(sigc::bind(
446  sigc::ptr_fun(delete_plugin_preset_popup), presetMenu));
447 }
448 
449 void SEQWindow::on_preset_add_clicked() {
450  if (!add_button->get_active()) return;
451  Gtk::MenuItem* item;
452  Gtk::Menu *presetMenu = Gtk::manage(new Gtk::Menu());
453  gx_preset::UnitPresetList presetnames;
454  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
455  for (gx_preset::UnitPresetList::iterator i = presetnames.begin(); i != presetnames.end(); ++i) {
456  if (!i->name.empty()) {
457  item = Gtk::manage(new Gtk::MenuItem(i->name, true));
458  presetMenu->append(*item);
459  item->signal_activate().connect(sigc::bind(sigc::mem_fun(
460  *this, &SEQWindow::append_plugin_preset),i->name));
461  }
462  }
463  presetMenu->signal_selection_done().connect(sigc::bind(sigc::mem_fun(
464  *this, &SEQWindow::on_selection_done),presetMenu));
465  presetMenu->show_all();
466  presetMenu->popup(1, gtk_get_current_event_time());
467  add_button->set_active(false);
468 }
469 
470 void SEQWindow::on_sec_length_changed(bool update) {
471  static int r_save = 24;
472  int r = int(seq_count->cp_get_value());
473  if ( r_save > r) {
474  FOR_DRUMS(
475  remove_seq_block(d.box, r);
476  );
477  r_save = r;
478  } else if( r_save < r) {
479  FOR_DRUMS(
480  append_seq_block(d.box,d.p, r,r_save);
481  );
482  r_save = r;
483  }
484  if (update) {
485  FOR_DRUMS(
486  on_seq_button_clicked(d.box,d.p);
487  );
488  }
489 }
490 
491 void SEQWindow::on_sec_tact_changed() {
492  FOR_DRUMS(
493  seq_changed(&d.p->get_value(), d.box);
494  );
495 }
496 
497 void SEQWindow::append_seq_block(Gtk::HBox * box, gx_engine::SeqParameter *p, int r, int r_save) {
498  Gtk::ToggleButton * ab;
499  for(int j = r_save; j<r; ++j) {
500  ab = new Gtk::ToggleButton();
501  box->pack_start(*Gtk::manage(ab),Gtk::PACK_EXPAND_WIDGET);
502  ab->signal_clicked().connect(
503  sigc::bind(sigc::bind(sigc::mem_fun(this, &SEQWindow::on_seq_button_clicked),p),box));
504  ab->show();
505  }
506 }
507 
508 void SEQWindow::remove_seq_block(Gtk::HBox * box, int r) {
509  Glib::ListHandle<Gtk::Widget*> boxList = box->get_children();
510  int i = 0;
511  for (Glib::ListHandle<Gtk::Widget*>::iterator itt = boxList.begin();itt != boxList.end(); ++itt) {
512  if (i>=r) {
513  box->remove(*(*itt));
514  delete((*itt));
515  }
516  ++i;
517  }
518 }
519 
520 void SEQWindow::scroll_playhead(float value) {
521  Gtk::Adjustment *a = vp->get_hadjustment();
522  static float old_state = 0.0;
523  float u = a->get_upper();
524  float l = a->get_lower();
525  float s = a->get_page_size();
526  float set = (u-s) * ((value)/2300.0);
527  if (u>s) {
528  if (set>l && set<u) {
529  if(std::abs(set-old_state) > 10) {
530  a->set_value(set);
531  old_state = set;
532  }
533  }
534  }
535 
536 }
537 
538 bool SEQWindow::get_sequencer_pos(Gxw::Regler * regler, const std::string id) {
539  float value = 0;
540  if (machine.parameter_hasId(id)) {
541  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off")) {
542  value = machine.get_parameter_value<float>(id);
543  if (!machine.get_jack()) {
544  if (value<99.0) return true;
545  }
546  machine.signal_parameter_value<float>(id)(value);
547  machine.signal_parameter_value<float>("seq.step")(machine.get_parameter_value<float>("seq.step"));
548  if (machine.get_parameter_value<float>("seq.follow"))
549  scroll_playhead(value);
550  }
551  return true;
552  } else {
553  return false;
554  }
555 }
556 
557 bool SEQWindow::on_key_press_event(GdkEventKey *event) {
558  return true;
559 }
560 
561 void SEQWindow::on_seq_button_clicked(Gtk::HBox *box, gx_engine::SeqParameter *p) {
562  Glib::signal_timeout().connect_once(sigc::bind(sigc::bind(sigc::mem_fun(this, &SEQWindow::on_seq_button_clicked_set),p),box),2);
563 }
564 
565 void SEQWindow::on_seq_button_clicked_set(Gtk::HBox *box, gx_engine::SeqParameter *p) {
566  std::vector<int> sequence;
568  Glib::ListHandle<Gtk::Widget*> seqList = box->get_children();
569  for (Glib::ListHandle<Gtk::Widget*>::iterator itt = seqList.begin();itt != seqList.end(); ++itt) {
570  sequence.push_back(dynamic_cast<Gtk::ToggleButton*>((*itt))->get_active());
571  }
572  seqc.setseqline(sequence);
573  p->set(seqc);
574 }
575 
576 void SEQWindow::check_preset_label() {
577  Glib::ustring pset = " ";
578  gx_preset::UnitPresetList presetnames;
579  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
580  gx_preset::UnitPresetList::iterator i = presetnames.begin();
581  for ( i = presetnames.begin(); i != presetnames.end(); ++i) {
582  if (!i->name.empty()) {
583  if (i->is_set) {
584  pset = i->name;
585  break;
586  }
587  }
588  }
589  preset_label->set_label(pset);
590 }
591 
592 void SEQWindow::seq_changed(const gx_engine::GxSeqSettings* seqc, Gtk::HBox *box) {
593 
594  Glib::ListHandle<Gtk::Widget*> seqList = box->get_children();
595  Glib::ListHandle<Gtk::Widget*>::iterator itt = seqList.begin();
596  std::vector<int> sequence = seqc->getseqline();
597  int ic = int(machine.get_parameter_value<float>("seq.tact"))-1;
598  int i0 = ic;
599  for (std::vector<int>::const_iterator i = sequence.begin(); i != sequence.end(); ++i) {
600  if (itt == seqList.end()) break;
601  dynamic_cast<Gtk::ToggleButton*>((*itt))->set_active(*i);
602  if (i0 == ic) {
603  dynamic_cast<Gtk::ToggleButton*>((*itt))->set_name("seq_button");
604  i0 = 0;
605  } else {
606  dynamic_cast<Gtk::ToggleButton*>((*itt))->set_name("button");
607  ++i0;
608  }
609  ++itt;
610  }
611  Glib::signal_idle().connect_once(sigc::mem_fun(this, &SEQWindow::check_preset_label));
612 }
613 
615  if (gtk_window->get_visible() && !(gtk_window->get_window()->get_state() & Gdk::WINDOW_STATE_ICONIFIED)) {
616  gtk_window->hide();
617  } else {
618  FOR_DRUMS(
619  seq_changed(&d.p->get_value(), d.box);
620  );
621  gtk_window->present();
622  }
623 }
624 
625 SEQWindow::~SEQWindow() {
626  delete gtk_window;
627 }
628 
629 } // end namespace
void setseqline(const std::vector< int > &seq)
#define GDK_KEY_Escape
Definition: guitarix.h:53
virtual void plugin_preset_list_sync_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)=0
PluginDef * get_pdef()
const std::vector< int > & getseqline() const
std::string get_builder_filepath(const std::string &basename) const
Definition: gx_system.h:373
virtual Parameter & get_parameter(const std::string &id)=0
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:135
const char * name
Definition: gx_plugin.h:188
static PluginPresetConnectWindow * create(gx_engine::GxMachineBase &machine)
static SEQWindow * create(const std::string &unit_id, gx_engine::GxMachineBase &machine)
virtual gx_jack::GxJack * get_jack()=0
bool set(const GxSeqSettings &val) const
#define min(x, y)
T get_parameter_value(const std::string &id)
#define FOR_DRUMS(func)
#define max(x, y)
virtual bool parameter_hasId(const char *p)=0
virtual void set_parameter_value(const std::string &id, int value)=0
virtual void plugin_preset_list_load(const PluginDef *pdef, gx_preset::UnitPresetList &presetnames)=0
virtual gx_system::CmdlineOptions & get_options() const =0
static Glib::RefPtr< UPresetListStore > create()
virtual void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)=0
Gxw::BigKnob * wrap(GxBigKnob *object, bool take_copy)
Definition: bigknob.cc:44
virtual Plugin * pluginlist_lookup_plugin(const std::string &id) const =0
#define DRUMS
virtual bool midi_get_config_mode(int *ctl=0)=0
sigc::signal< void, T > & signal_parameter_value(const std::string &id)