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  builder->find_widget("gxvaluedisplay1", step_value);
173  builder->find_widget("label8:rack_label_inverse", step_label);
174 
175  Pango::FontDescription font = preset_label->get_style()->get_font();
176  font.set_size(10*Pango::SCALE);
177  font.set_weight(Pango::WEIGHT_BOLD);
178  preset_label->modify_font(font);
179 
180  make_preset_button(preset_button);
181 
182  drums.push_back(tom);
183  drums.push_back(tom1);
184  drums.push_back(tom2);
185  drums.push_back(kick);
186  drums.push_back(snare);
187  drums.push_back(hat);
188 
189  on_sec_length_changed(false);
190 
191  FOR_DRUMS(
192  d.p->signal_changed().connect(sigc::bind(
193  sigc::mem_fun(this, &SEQWindow::seq_changed), d.box));
194  init_sequences(d.p, d.box);
195  );
196 
197  seq_pos->cp_set_value(0.0);
198  std::string id;
199  seq_pos->get_property("var_id",id);
200 
201  int ti_o = 60;
202  if (!machine.get_jack()) ti_o = 250;
203  Glib::signal_timeout().connect(
204  sigc::bind<Gxw::Regler*>(sigc::bind<const std::string>(
205  sigc::mem_fun(*this, &SEQWindow::get_sequencer_pos),id), seq_pos), ti_o);
206 
207  seq_count->signal_value_changed().connect(
208  sigc::bind(sigc::mem_fun(*this, &SEQWindow::on_sec_length_changed), true));
209 
210  seq_tact->signal_value_changed().connect(
211  sigc::mem_fun(*this, &SEQWindow::on_sec_tact_changed));
212 
213  next_preset->signal_toggled().connect(
214  sigc::mem_fun(*this, &SEQWindow::on_next_preset));
215 
216  previus_preset->signal_toggled().connect(
217  sigc::mem_fun(*this, &SEQWindow::on_previus_preset));
218 
219  set_step->signal_toggled().connect(
220  sigc::mem_fun(*this, &SEQWindow::on_set_step));
221 
222  set_fstep->signal_toggled().connect(
223  sigc::mem_fun(*this, &SEQWindow::on_set_fstep));
224 
225  set_sync->signal_toggled().connect(
226  sigc::mem_fun(*this, &SEQWindow::on_sync_stepper));
227 
228  reset_step->signal_toggled().connect(
229  sigc::mem_fun(*this, &SEQWindow::on_reset_stepper));
230 
231  add_button->signal_clicked().connect(
232  sigc::mem_fun(*this, &SEQWindow::on_preset_add_clicked));
233  add_button->set_tooltip_text(_("add effect unit preset to the sequence"));
234 
235  gtk_window->signal_key_press_event().connect(
236  sigc::mem_fun(this, &SEQWindow::on_key_press_event));
237 
238  if (!machine.get_jack()) {
239  step_value->hide();
240  step_label->hide();
241  }
242 }
243 
244 void SEQWindow::init_sequences(gx_engine::SeqParameter *p, Gtk::HBox* _box) {
245  Glib::ListHandle<Gtk::Widget*> List = _box->get_children();
246  for (Glib::ListHandle<Gtk::Widget*>::iterator itt = List.begin();itt != List.end(); ++itt) {
247  dynamic_cast<Gtk::ToggleButton*>((*itt))->signal_clicked().connect(
248  sigc::bind(sigc::bind(sigc::mem_fun(this, &SEQWindow::on_seq_button_clicked),p),_box));
249  }
250 }
251 
252 void SEQWindow::on_set_step() {
253  if (!set_step->get_active()) return;
254  float tactv = machine.get_parameter_value<float>("seq.tact");
255  float value = std::max(0,int(machine.get_parameter_value<float>("seq.step")-tactv));
256  reset_control("seq.step",value);
257  set_step->set_active(false);
258 }
259 
260 void SEQWindow::on_set_fstep() {
261  if (!set_fstep->get_active()) return;
262  float tactv = machine.get_parameter_value<float>("seq.tact");
263  float valuea = machine.get_parameter_value<float>("seq.asequences");
264  float value = std::min(int(valuea),int(machine.get_parameter_value<float>("seq.step")+tactv));
265  reset_control("seq.step",value);
266  set_fstep->set_active(false);
267 }
268 
269 void SEQWindow::on_sync_stepper() {
270  if (!set_sync->get_active()) return;
271  reset_control("seq.step",machine.get_parameter_value<float>("seq.step_orig"));
272  set_sync->set_active(false);
273 }
274 
275 void SEQWindow::on_reset_stepper() {
276  if (!reset_step->get_active()) return;
277  reset_control("seq.step",0.0);
278  reset_control("seq.step_orig",0.0);
279  reset_control("seq.pos",0.0);
280  reset_step->set_active(false);
281 }
282 
283 void SEQWindow::on_next_preset() {
284  if (!next_preset->get_active()) return;
285  if (!is_active) {
286  is_active = true;
287  Glib::signal_idle().connect_once(sigc::mem_fun(this, &SEQWindow::on_next_preset_set));
288  }
289 }
290 
291 void SEQWindow::on_next_preset_set() {
292  gx_preset::UnitPresetList presetnames;
293  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
294  for (gx_preset::UnitPresetList::iterator i = presetnames.begin(); i != presetnames.end(); ++i) {
295  if (!i->name.empty()) {
296  if (i->is_set) {
297  ++i;
298  if (i->name.empty()) i = presetnames.begin();
299  machine.plugin_preset_list_sync_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, i->name);
300  break;
301  } else {
302  machine.plugin_preset_list_sync_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, presetnames.begin()->name);
303  }
304  }
305  }
306  is_active = false;
307  reset_control("seq.npreset",0);
308 }
309 
310 void SEQWindow::on_previus_preset() {
311  if (!previus_preset->get_active()) return;
312  if (!is_active) {
313  is_active = true;
314  Glib::signal_idle().connect_once(sigc::mem_fun(this, &SEQWindow::on_previus_preset_set));
315  }
316 }
317 
318 void SEQWindow::on_previus_preset_set() {
319  gx_preset::UnitPresetList presetnames;
320  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
321  gx_preset::UnitPresetList::iterator i = presetnames.begin();
322  for ( i = presetnames.begin(); i != presetnames.end(); ++i) {
323  if (!i->name.empty()) {
324  if (i->is_set) break;
325  }
326  }
327  if (i == presetnames.begin()) {
328  i = presetnames.end();
329  --i;
330  } else if (i == presetnames.end()) {
331  i -=2;
332  }
333  --i;
334  machine.plugin_preset_list_sync_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, i->name);
335  is_active = false;
336  reset_control("seq.ppreset",0);
337 }
338 
339 void SEQWindow::on_preset_popup_clicked() {
340  Gtk::Menu *presetMenu = static_cast<Gtk::Menu*>(new PluginPresetPopup(machine.pluginlist_lookup_plugin("seq")->get_pdef(), machine));
341  Gtk::MenuItem* subitem = Gtk::manage(new Gtk::MenuItem("connect midi...", true));
342  presetMenu->append(*subitem);
343  subitem->signal_activate().connect(sigc::mem_fun(
344  *this, &SEQWindow::connect_midi));
345  presetMenu->show_all();
346 }
347 
348 void SEQWindow::connect_midi() {
349  PluginPresetConnectWindow *w = PluginPresetConnectWindow::create(machine);
350  w->run();
351  delete w;
352 }
353 
354 void SEQWindow::make_preset_button(Gtk::HBox * box) {
355  Gtk::Button *p = new Gtk::Button();
356  GtkWidget *l = gtk_image_new_from_stock("rack_preset", (GtkIconSize)-1);
357  p->add(*Gtk::manage(Glib::wrap(l)));
358  p->set_can_default(false);
359  p->set_can_focus(false);
360  p->set_tooltip_text(_("manage effect unit presets"));
361  p->set_name("effect_on_off");
362  box->pack_start(*Gtk::manage(p),Gtk::PACK_SHRINK);
363  p->signal_clicked().connect(
364  sigc::mem_fun(*this, &SEQWindow::on_preset_popup_clicked));
365  p->show_all();
366 }
367 
368 void SEQWindow::reset_control(Glib::ustring id, float value) {
369  machine.set_parameter_value(id,value);
370  machine.signal_parameter_value<float>(id)(value);
371 }
372 
373 int SEQWindow::append_sequence(const gx_engine::GxSeqSettings* seqc, gx_engine::SeqParameter *p, std::vector<int> *sequence) {
374  int s = 0;
375  std::vector<int> sequence_append = seqc->getseqline();
376  for(std::vector<int>::const_iterator i = sequence_append.begin(); i != sequence_append.end(); ++i) {
377  sequence->push_back(*i);
378  ++s;
379  }
380  return s;
381 }
382 
383 void SEQWindow::append_plugin_preset(Glib::ustring name) {
384  if (!is_active) {
385  is_active = true;
386  Glib::signal_timeout().connect_once(sigc::bind(sigc::mem_fun(this, &SEQWindow::append_plugin_preset_set),name),5);
387  }
388 }
389 
390 void SEQWindow::append_plugin_preset_set(Glib::ustring name) {
391  // get current sequences
392  std::vector<int> sequence[DRUMS];
393  int i = 0;
394  FOR_DRUMS(
395  sequence[i] = static_cast<const gx_engine::GxSeqSettings*>(&d.p->get_value())->getseqline();
396  ++i;
397  );
398 
399  // get current control values
400  float value = machine.get_parameter_value<float>("seq.asequences");
401  float bpmv = machine.get_parameter_value<float>("seq.bpm");
402  float tactv = machine.get_parameter_value<float>("seq.tact");
403  float gainv = machine.get_parameter_value<float>("seq.gain");
404  float tomg = machine.get_parameter_value<float>("seq.tom.dsp.Gain");
405  float tomg1 = machine.get_parameter_value<float>("seq.tom.dsp.Gain1");
406  float tomg2 = machine.get_parameter_value<float>("seq.tom.dsp.Gain2");
407  float kickg = machine.get_parameter_value<float>("seq.kick.dsp.Gain");
408  float snareg = machine.get_parameter_value<float>("seq.snare.dsp.Gain");
409  float hatg = machine.get_parameter_value<float>("seq.hat_closed.dsp.Gain");
410  // set preset values
411  machine.plugin_preset_list_set(machine.pluginlist_lookup_plugin("seq")->get_pdef(), false, name);
412 
413  // append preset sequence to current and get new step size
414  int s = 24;
415  i = 0;
416  FOR_DRUMS(
417  s = append_sequence(&d.p->get_value(), d.p, &sequence[i]);
418  ++i;
419  );
420 
421  // set new step size
422  value += float(s);
423  reset_control("seq.asequences",value);
424 
425  // set new sequences as parameter
427  i = 0;
428  FOR_DRUMS(
429  seqc.setseqline(sequence[i]);
430  d.p->set(seqc);
431  ++i;
432  );
433 
434  // reset controls to previus values
435  reset_control("seq.bpm",bpmv);
436  reset_control("seq.tact",tactv);
437  reset_control("seq.gain",gainv);
438  reset_control("seq.tom.dsp.Gain",tomg);
439  reset_control("seq.tom.dsp.Gain1",tomg1);
440  reset_control("seq.tom.dsp.Gain2",tomg2);
441  reset_control("seq.kick.dsp.Gain",kickg);
442  reset_control("seq.snare.dsp.Gain",snareg);
443  reset_control("seq.hat_closed.dsp.Gain",hatg);
444 
445  is_active = false;
446  }
447 
448 static bool delete_plugin_preset_popup(Gtk::Menu *presetMenu) {
449  delete presetMenu;
450  return false;
451 }
452 
453 void SEQWindow::on_selection_done(Gtk::Menu *presetMenu) {
454  Glib::signal_idle().connect(sigc::bind(
455  sigc::ptr_fun(delete_plugin_preset_popup), presetMenu));
456 }
457 
458 void SEQWindow::on_preset_add_clicked() {
459  if (!add_button->get_active()) return;
460  Gtk::MenuItem* item;
461  Gtk::Menu *presetMenu = Gtk::manage(new Gtk::Menu());
462  gx_preset::UnitPresetList presetnames;
463  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
464  for (gx_preset::UnitPresetList::iterator i = presetnames.begin(); i != presetnames.end(); ++i) {
465  if (!i->name.empty()) {
466  item = Gtk::manage(new Gtk::MenuItem(i->name, true));
467  presetMenu->append(*item);
468  item->signal_activate().connect(sigc::bind(sigc::mem_fun(
469  *this, &SEQWindow::append_plugin_preset),i->name));
470  }
471  }
472  presetMenu->signal_selection_done().connect(sigc::bind(sigc::mem_fun(
473  *this, &SEQWindow::on_selection_done),presetMenu));
474  presetMenu->show_all();
475  presetMenu->popup(1, gtk_get_current_event_time());
476  add_button->set_active(false);
477 }
478 
479 void SEQWindow::on_sec_length_changed(bool update) {
480  static int r_save = 24;
481  int r = int(seq_count->cp_get_value());
482  if ( r_save > r) {
483  FOR_DRUMS(
484  remove_seq_block(d.box, r);
485  );
486  r_save = r;
487  } else if( r_save < r) {
488  FOR_DRUMS(
489  append_seq_block(d.box,d.p, r,r_save);
490  );
491  r_save = r;
492  }
493  if (update) {
494  FOR_DRUMS(
495  on_seq_button_clicked(d.box,d.p);
496  );
497  }
498 }
499 
500 void SEQWindow::on_sec_tact_changed() {
501  FOR_DRUMS(
502  seq_changed(&d.p->get_value(), d.box);
503  );
504 }
505 
506 void SEQWindow::append_seq_block(Gtk::HBox * box, gx_engine::SeqParameter *p, int r, int r_save) {
507  Gtk::ToggleButton * ab;
508  for(int j = r_save; j<r; ++j) {
509  ab = new Gtk::ToggleButton();
510  box->pack_start(*Gtk::manage(ab),Gtk::PACK_EXPAND_WIDGET);
511  ab->signal_clicked().connect(
512  sigc::bind(sigc::bind(sigc::mem_fun(this, &SEQWindow::on_seq_button_clicked),p),box));
513  ab->show();
514  }
515 }
516 
517 void SEQWindow::remove_seq_block(Gtk::HBox * box, int r) {
518  Glib::ListHandle<Gtk::Widget*> boxList = box->get_children();
519  int i = 0;
520  for (Glib::ListHandle<Gtk::Widget*>::iterator itt = boxList.begin();itt != boxList.end(); ++itt) {
521  if (i>=r) {
522  box->remove(*(*itt));
523  delete((*itt));
524  }
525  ++i;
526  }
527 }
528 
529 void SEQWindow::scroll_playhead(float value) {
530  Gtk::Adjustment *a = vp->get_hadjustment();
531  static float old_state = 0.0;
532  float u = a->get_upper();
533  float l = a->get_lower();
534  float s = a->get_page_size();
535  float set = (u-s) * ((value)/2300.0);
536  if (u>s) {
537  if (set>l && set<u) {
538  if(std::abs(set-old_state) > 10) {
539  a->set_value(set);
540  old_state = set;
541  }
542  }
543  }
544 
545 }
546 
547 bool SEQWindow::get_sequencer_pos(Gxw::Regler * regler, const std::string id) {
548  float value = 0;
549  if (machine.parameter_hasId(id)) {
550  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off")) {
551  value = machine.get_parameter_value<float>(id);
552  if (!machine.get_jack()) {
553  if (value<99.0) return true;
554  }
555  machine.signal_parameter_value<float>(id)(value);
556  if (machine.get_jack()) machine.signal_parameter_value<float>("seq.step")(machine.get_parameter_value<float>("seq.step"));
557  if (machine.get_parameter_value<float>("seq.follow"))
558  scroll_playhead(value);
559  }
560  return true;
561  } else {
562  return false;
563  }
564 }
565 
566 bool SEQWindow::on_key_press_event(GdkEventKey *event) {
567  return true;
568 }
569 
570 void SEQWindow::on_seq_button_clicked(Gtk::HBox *box, gx_engine::SeqParameter *p) {
571  Glib::signal_timeout().connect_once(sigc::bind(sigc::bind(sigc::mem_fun(this, &SEQWindow::on_seq_button_clicked_set),p),box),2);
572 }
573 
574 void SEQWindow::on_seq_button_clicked_set(Gtk::HBox *box, gx_engine::SeqParameter *p) {
575  std::vector<int> sequence;
577  Glib::ListHandle<Gtk::Widget*> seqList = box->get_children();
578  for (Glib::ListHandle<Gtk::Widget*>::iterator itt = seqList.begin();itt != seqList.end(); ++itt) {
579  sequence.push_back(dynamic_cast<Gtk::ToggleButton*>((*itt))->get_active());
580  }
581  seqc.setseqline(sequence);
582  p->set(seqc);
583 }
584 
585 void SEQWindow::check_preset_label() {
586  Glib::ustring pset = " ";
587  gx_preset::UnitPresetList presetnames;
588  machine.plugin_preset_list_load(machine.pluginlist_lookup_plugin("seq")->get_pdef(), presetnames);
589  gx_preset::UnitPresetList::iterator i = presetnames.begin();
590  for ( i = presetnames.begin(); i != presetnames.end(); ++i) {
591  if (!i->name.empty()) {
592  if (i->is_set) {
593  pset = i->name;
594  break;
595  }
596  }
597  }
598  preset_label->set_label(pset);
599 }
600 
601 void SEQWindow::seq_changed(const gx_engine::GxSeqSettings* seqc, Gtk::HBox *box) {
602 
603  Glib::ListHandle<Gtk::Widget*> seqList = box->get_children();
604  Glib::ListHandle<Gtk::Widget*>::iterator itt = seqList.begin();
605  std::vector<int> sequence = seqc->getseqline();
606  int ic = int(machine.get_parameter_value<float>("seq.tact"))-1;
607  int i0 = ic;
608  for (std::vector<int>::const_iterator i = sequence.begin(); i != sequence.end(); ++i) {
609  if (itt == seqList.end()) break;
610  dynamic_cast<Gtk::ToggleButton*>((*itt))->set_active(*i);
611  if (i0 == ic) {
612  dynamic_cast<Gtk::ToggleButton*>((*itt))->set_name("seq_button");
613  i0 = 0;
614  } else {
615  dynamic_cast<Gtk::ToggleButton*>((*itt))->set_name("button");
616  ++i0;
617  }
618  ++itt;
619  }
620  Glib::signal_idle().connect_once(sigc::mem_fun(this, &SEQWindow::check_preset_label));
621 }
622 
624  if (gtk_window->get_visible() && !(gtk_window->get_window()->get_state() & Gdk::WINDOW_STATE_ICONIFIED)) {
625  gtk_window->hide();
626  } else {
627  FOR_DRUMS(
628  seq_changed(&d.p->get_value(), d.box);
629  );
630  gtk_window->present();
631  }
632 }
633 
634 SEQWindow::~SEQWindow() {
635  delete gtk_window;
636 }
637 
638 } // end namespace
gx_seq::PluginPresetConnectWindow
Definition: gx_sequencer_settings.h:58
gx_seq
Definition: gx_sequencer_settings.h:27
gx_engine::GxMachineBase::parameter_hasId
virtual bool parameter_hasId(const char *p)=0
Gxw::ControlParameter::cp_set_value
void cp_set_value(double value)
Definition: controlparameter.cc:131
gx_seq::SEQWindow::reload_and_show
void reload_and_show()
Definition: gx_sequencer_settings.cpp:621
gx_seq::SEQWindow::create
static SEQWindow * create(const std::string &unit_id, gx_engine::GxMachineBase &machine)
Definition: gx_sequencer_settings.cpp:106
gx_engine::GxMachineBase::get_parameter_value
T get_parameter_value(const std::string &id)
gx_engine::GxMachineBase::get_options
virtual gx_system::CmdlineOptions & get_options() const =0
gx_engine::GxMachineBase
Definition: machine.h:53
gx_engine::GxMachineBase::plugin_preset_list_set
virtual void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)=0
gx_seq::PluginPresetConnectWindow::run
void run()
Definition: gx_sequencer_settings.cpp:99
gx_engine::GxMachineBase::signal_parameter_value
sigc::signal< void, T > & signal_parameter_value(const std::string &id)
gx_seq::PluginPresetConnectWindow::create
static PluginPresetConnectWindow * create(gx_engine::GxMachineBase &machine)
Definition: gx_sequencer_settings.cpp:39
gx_engine::GxSeqSettings::setseqline
void setseqline(const std::vector< int > &seq)
Definition: gx_internal_plugins.h:260
gx_preset::UnitPresetList
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:134
gx_engine::GxMachineBase::pluginlist_lookup_plugin
virtual Plugin * pluginlist_lookup_plugin(const std::string &id) const =0
PluginDef::name
const char * name
Definition: gx_plugin.h:188
gx_seq::Drums::box
Gtk::HBox * box
Definition: gx_sequencer_settings.h:32
gx_engine::GxSeqSettings
Definition: gx_internal_plugins.h:245
gx_engine::GxMachineBase::set_parameter_value
virtual void set_parameter_value(const std::string &id, int value)=0
min
#define min(x, y)
Definition: gx_faust_support.h:6
gx_engine::ParameterV< GxSeqSettings >
Definition: gx_internal_plugins.h:267
FOR_DRUMS
#define FOR_DRUMS(func)
Definition: gx_sequencer_settings.cpp:26
max
#define max(x, y)
Definition: gx_faust_support.h:5
gx_seq::SEQWindow
Definition: gx_sequencer_settings.h:81
gx_seq::PluginPresetConnectWindow::~PluginPresetConnectWindow
~PluginPresetConnectWindow()
Definition: gx_sequencer_settings.cpp:36
gx_engine::GxMachineBase::plugin_preset_list_load
virtual void plugin_preset_list_load(const PluginDef *pdef, gx_preset::UnitPresetList &presetnames)=0
Glib::wrap
Gxw::BigKnob * wrap(GxBigKnob *object, bool take_copy)
Definition: bigknob.cc:44
PluginPresetPopup
Definition: gx_main_window.h:458
gx_engine::Plugin::get_pdef
PluginDef * get_pdef()
Definition: gx_pluginloader.h:54
gx_engine::GxMachineBase::get_parameter
virtual Parameter & get_parameter(const std::string &id)=0
gx_engine::GxMachineBase::plugin_preset_list_sync_set
virtual void plugin_preset_list_sync_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)=0
gx_system::BasicOptions::get_builder_filepath
std::string get_builder_filepath(const std::string &basename) const
Definition: gx_system.h:369
gx_engine::GxMachineBase::midi_get_config_mode
virtual bool midi_get_config_mode(int *ctl=0)=0
gx_main_midi::MidiConnect
Definition: gx_main_midi.h:73
Gxw::ControlParameter::cp_get_value
double cp_get_value()
Definition: controlparameter.cc:136
Gxw::Regler
Definition: regler.h:45
gx_engine::GxMachineBase::get_jack
virtual gx_jack::GxJack * get_jack()=0
gx_engine::ParameterV< GxSeqSettings >::set
bool set(const GxSeqSettings &val) const
Definition: gx_internal_plugins.cpp:228
gx_engine::GxSeqSettings::getseqline
const std::vector< int > & getseqline() const
Definition: gx_internal_plugins.h:258
DRUMS
#define DRUMS
Definition: gx_sequencer_settings.cpp:24
guitarix.h
GDK_KEY_Escape
#define GDK_KEY_Escape
Definition: guitarix.h:53