Guitarix
gx_stackbox_builder.cpp
Go to the documentation of this file.
1 #include "guitarix.h" // NOLINT
2 
3 #include <glibmm/i18n.h> // NOLINT
4 
5 // -------- the gx_head user interface build instruktions
6 
7 namespace gx_gui {
8 
9 // Paint Functions for Gxw::PaintBox
10 
11 const char *pb_gx_rack_amp_expose = "gx_rack_amp_expose";
12 const char *pb_rectangle_skin_color_expose = "rectangle_skin_color_expose";
13 const char *pb_zac_expose = "zac_expose";
14 const char *pb_gxhead_expose = "gxhead_expose";
15 const char *pb_RackBox_expose = "RackBox_expose";
16 const char *pb_gxrack_expose = "gxrack_expose";
17 const char *pb_level_meter_expose = "level_meter_expose";
18 
19 
20 int precision(double n) {
21  if (n < 0.009999)
22  return 3;
23  else if (n < 0.099999)
24  return 2;
25  else if (n < 0.999999)
26  return 1;
27  else
28  return 0;
29 }
30 
31 string fformat(float value, float step) {
32  ostringstream buf;
33  buf << fixed << setprecision(precision(step)) << value;
34  return buf.str();
35 }
36 
37 bool button_press_cb(GdkEventButton *event, gx_engine::GxMachineBase& machine, const std::string& id) {
38  if (event->button == 2) {
39  if (!machine.midi_get_config_mode()) {
40  new gx_main_midi::MidiConnect(event, machine.get_parameter(id), machine);
41  }
42  return true;
43  }
44  return false;
45 }
46 
47 
48 /****************************************************************
49  ** class WidgetStack
50  */
51 
52 void WidgetStack::container_add(Gtk::Widget *w) {
53  dynamic_cast<Gtk::Container*>(top())->add(*w);
54 }
55 
56 void WidgetStack::box_pack_start(Gtk::Widget *w, bool expand, bool fill, int padding) {
57  dynamic_cast<Gtk::Box*>(top())->pack_start(*w, expand, fill, padding);
58 }
59 
60 void WidgetStack::notebook_append_page(Gtk::Widget *w, Gtk::Widget *label) {
61  dynamic_cast<Gtk::Notebook*>(top())->append_page(*w, *label);
62 }
63 
64 Gtk::Widget *WidgetStack::add(Gtk::Widget *w, const Glib::ustring& label) {
65  w->show();
66  Gtk::Widget *t = top();
67  Gtk::Notebook *n = dynamic_cast<Gtk::Notebook*>(t);
68  if (n) {
69  n->append_page(*w, *manage(new Gtk::Label(label)));
70  return w;
71  }
72  Gtk::Box *b = dynamic_cast<Gtk::Box*>(t);
73  if (b) {
74  b->pack_start(*w, true, true, 0);
75  return w;
76  }
77  Gtk::Container *c = dynamic_cast<Gtk::Container*>(t);
78  if (c) {
79  c->add(*w);
80  return w;
81  }
82  assert(false);
83  return w;
84 }
85 
86 /****************************************************************
87  ** class StackBoxBuilder
88  */
89 
91  gx_engine::GxMachineBase& machine_, Gxw::WaveView &fWaveView_, Gtk::Label &convolver_filename_label_,
92  Gtk::Label &convolver_mono_filename_label_, Glib::RefPtr<Gdk::Pixbuf> window_icon_)
93  : fBox(), machine(machine_),
94  fWaveView(fWaveView_), convolver_filename_label(convolver_filename_label_),
95  convolver_mono_filename_label(convolver_mono_filename_label_),
96  widget(), accels(), window_icon(window_icon_), next_flags(0) {
97 }
98 
100 }
101 
102 void StackBoxBuilder::openVerticalMidiBox(const char* label) {
103  openVerticalBox(label);
104 }
105 
107  widget = new Gtk::HBox();
108  widget->show();
109  fBox.push(manage(widget));
110 }
111 
112 #ifndef NDEBUG
113 void wnotify(gpointer data, GObject *where_the_object_was) {
114  printf("WN %p %p\n", where_the_object_was, data);
115 }
116 
117 // check if object will be finalized
118 void trace_finalize(Glib::Object *o, int n) {
119  g_object_weak_ref(o->gobj(), wnotify, GINT_TO_POINTER(n));
120 }
121 #endif
122 
123 void StackBoxBuilder::fetch(Gtk::Widget*& mainbox, Gtk::Widget*& minibox) {
124  fBox.pop();
125  assert(fBox.empty());
126  mainbox = widget;
127  Glib::ListHandle<Gtk::Widget*> l = widget->get_children();
128  if (l.size() == 2) {
129  Glib::ListHandle<Gtk::Widget*>::iterator i = l.begin();
130  minibox = new Gtk::VBox();
131  minibox->show();
132  (*i)->show();
133  (*i)->reparent(*minibox);
134  } else {
135  minibox = 0;
136  }
137 }
138 
139 void StackBoxBuilder::get_box(const std::string& name, Gtk::Widget*& mainbox, Gtk::Widget*& minibox) {
140  struct {
141  const char *name;
142  void (StackBoxBuilder::*func)();
143  } mapping[] = {
144  // mono
145  { "oscilloscope", &StackBoxBuilder::make_rackbox_oscilloscope },
146  { "jconv_mono", &StackBoxBuilder::make_rackbox_jconv_mono },
149  // stereo
151  };
152  mainbox = minibox = 0;
153  for (unsigned int i = 0; i < sizeof(mapping) / sizeof(mapping[0]); ++i) {
154  if (name == mapping[i].name) {
155  prepare();
156  (this->*mapping[i].func)();
157  fetch(mainbox, minibox);
158  }
159  }
160 }
161 
162 void StackBoxBuilder::loadRackFromBuilder(const Glib::RefPtr<GxBuilder>& bld) {
163  if (!bld->has_object("rackbox")) {
164  gx_print_error("load_ui Error", "can't find widget 'rackbox'");
165  return;
166  }
167  Gtk::Widget* w;
168  if (bld->has_object("minibox")) {
169  bld->find_widget("minibox", w);
170  fBox.add(w);
171  }
172  bld->find_widget("rackbox", w);
173  fBox.add(w);
174 
175  // find fastmeters in glade UI's and add a timeout callback to set the levels
176  // fastmeters must have id=gxfastmeterN were N starts with 1
177  std::string id;
178  for (int i = 1; i<12;++i) {
179  Glib::ustring fm = "gxfastmeter" + gx_system::to_string(i);
180  if (bld->has_object(fm)) {
181  Gxw::FastMeter *fastmeter;
182  bld->find_widget(fm, fastmeter);
183  fastmeter->get_property("var_id",id);
184  fastmeter->set_name("simplemeter");
185  if (!id.empty())
186  Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
187  sigc::mem_fun(*this, &StackBoxBuilder::set_simple),id), fastmeter), 60);
188  fastmeter->set_by_power(0.0001);
189  } else {
190  break;
191  }
192  }
193  for (int i = 1; i<12;++i) {
194  Glib::ustring fm = "gxfastmeter" + gx_system::to_string(i)+ ":meterframe";
195  if (bld->has_object(fm)) {
196  Gxw::FastMeter *fastmeter;
197  bld->find_widget(fm, fastmeter);
198  fastmeter->get_property("var_id",id);
199  //fastmeter->set_name("meterframe");
200  if (!id.empty())
201  Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
202  sigc::mem_fun(*this, &StackBoxBuilder::set_simple),id), fastmeter), 60);
203  fastmeter->set_by_power(0.0001);
204  } else {
205  break;
206  }
207  }
208  for (int i = 1; i<12;++i) {
209  Glib::ustring fm = "gxcompressormeter" + gx_system::to_string(i);
210  if (bld->has_object(fm)) {
211  Gxw::FastMeter *fastmeter;
212  bld->find_widget(fm, fastmeter);
213  fastmeter->get_property("var_id",id);
214  fastmeter->set_name("simplemeter");
215  if (!id.empty())
216  Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
217  sigc::mem_fun(*this, &StackBoxBuilder::set_compressor_level),id), fastmeter), 60);
218  fastmeter->set_c_level(0.0);
219  } else {
220  break;
221  }
222  }
223  for (int i = 1; i<12;++i) {
224  Glib::ustring fm = "gxportdisplay" + gx_system::to_string(i);
225  if (bld->has_object(fm)) {
226  Gxw::PortDisplay *regler;
227  bld->find_widget(fm, regler);
228  regler->get_property("var_id",id);
229  if (!id.empty())
230  Glib::signal_timeout().connect(sigc::bind<const std::string>(
231  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_value),id), 60);
232  } else {
233  break;
234  }
235  }
236  // find feedback switches and connect a timeout callback to update the UI elements.
237  // feedback switches must have the id gxfswitchN were N starts with 1
238  for (int i = 1; i<12;++i) {
239  Glib::ustring fm = "gxfswitch" + gx_system::to_string(i);
240  if (bld->has_object(fm)) {
241  Gxw::Switch *sw;
242  bld->find_widget(fm, sw);
243  sw->get_property("var_id",id);
244  sw->set_name("effect_on_off");
245  if (!id.empty())
246  Glib::signal_timeout().connect(sigc::bind<Gxw::Switch*>(sigc::bind<const std::string>(
247  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_cp_value),id),sw), 60);
248  } else {
249  break;
250  }
251  }
252  // find feedback Regler and connect a timeout callback to update the UI elements.
253  // were Regler could be GxKnob's or GxSlider's
254  // feedback Regler must have the id gxfreglerN were N starts with 1
255  for (int i = 1; i<12;++i) {
256  Glib::ustring fm = "gxfregler" + gx_system::to_string(i);
257  if (bld->has_object(fm)) {
258  Gxw::Regler *regler;
259  bld->find_widget(fm, regler);
260  regler->get_property("var_id",id);
261  if (!id.empty())
262  Glib::signal_timeout().connect(sigc::bind<Gxw::Regler*>(sigc::bind<const std::string>(
263  sigc::mem_fun(*this, &StackBoxBuilder::set_regler_cp_value),id),regler), 60);
264  } else {
265  break;
266  }
267  }
268 }
269 
270 static const char *rackbox_ids[] = { "rackbox", "minibox", 0 };
271 
272 void StackBoxBuilder::loadRackFromGladeFile(const char *fname) {
273  loadRackFromBuilder(
274  GxBuilder::create_from_file(
275  machine.get_options().get_builder_filepath(fname), &machine, rackbox_ids));
276 }
277 
278 void StackBoxBuilder::loadRackFromGladeData(const char *xmldesc) {
279  loadRackFromBuilder(GxBuilder::create_from_string(xmldesc, &machine, rackbox_ids));
280 }
281 
282 void StackBoxBuilder::addwidget(Gtk::Widget *widget) {
283  if (widget) {
284  fBox.container_add(manage(widget));
285  }
286  next_flags = 0;
287 }
288 
289 void StackBoxBuilder::addSmallJConvFavButton(const char* label, gx_jconv::IRWindow *irw) {
290  Gtk::Button *button = new Gtk::Button();
291  button->set_name("smallbutton");
292  Gtk::Label *lab = new Gtk::Label(label);
293  Pango::FontDescription font = lab->get_style()->get_font();
294  font.set_size(7*Pango::SCALE);
295  font.set_weight(Pango::WEIGHT_NORMAL);
296  lab->modify_font(font);
297  button->add(*manage(lab));
298  //lab->set_name("rack_label_inverse");
299  lab->set_padding(5,0);
300  fBox.add(manage(button), label);
301  lab->show();
302  button->signal_clicked().connect(
303  sigc::mem_fun(*irw, &gx_jconv::IRWindow::reload_and_show));
304 }
305 
306 void StackBoxBuilder::set_convolver_filename(const gx_engine::GxJConvSettings *jcs) {
307  convolver_filename_label.set_label(jcs->getIRFile());
308 }
309 
310 void StackBoxBuilder::set_convolver_mono_filename(const gx_engine::GxJConvSettings *jcs) {
311  convolver_mono_filename_label.set_label(jcs->getIRFile());
312 }
313 
314 void StackBoxBuilder::openSetLabelBox() {
315  Gtk::VBox *box = new Gtk::VBox();
316  box->set_homogeneous(false);
317  box->set_spacing(0);
318  box->set_border_width(0);
319  convolver_filename_label.set_name("rack_label");
320  Pango::FontDescription font = convolver_filename_label.get_style()->get_font();
321  font.set_size(8*Pango::SCALE);
322  font.set_weight(Pango::WEIGHT_BOLD);
323  convolver_filename_label.modify_font(font);
324  box->pack_start(convolver_filename_label, false, false, 0);
325  box->show_all();
326  gx_engine::JConvParameter *jcp = dynamic_cast<gx_engine::JConvParameter*>(&machine.get_parameter("jconv.convolver"));
327  assert(jcp);
328  convolver_filename_label.set_label(jcp->get_value().getIRFile());
329  jcp->signal_changed().connect(
330  sigc::mem_fun(*this, &StackBoxBuilder::set_convolver_filename));
331  fBox.box_pack_start(manage(box), false);
332  fBox.push(box);
333 }
334 
335 void StackBoxBuilder::openSetMonoLabelBox() {
336  Gtk::VBox *box = new Gtk::VBox();
337  box->set_homogeneous(false);
338  box->set_spacing(0);
339  box->set_border_width(0);
340  convolver_mono_filename_label.set_name("rack_label");
341  Pango::FontDescription font = convolver_mono_filename_label.get_style()->get_font();
342  font.set_size(8*Pango::SCALE);
343  font.set_weight(Pango::WEIGHT_BOLD);
344  convolver_mono_filename_label.modify_font(font);
345  box->pack_start(convolver_mono_filename_label, true, false, 0);
346  box->show_all();
347  gx_engine::JConvParameter *jcp = dynamic_cast<gx_engine::JConvParameter*>(&machine.get_parameter("jconv_mono.convolver"));
348  assert(jcp);
349  convolver_mono_filename_label.set_label(jcp->get_value().getIRFile());
350  jcp->signal_changed().connect(
351  sigc::mem_fun(*this, &StackBoxBuilder::set_convolver_mono_filename));
352  fBox.box_pack_start(manage(box));
353  fBox.push(box);
354 }
355 
356 void StackBoxBuilder::addJConvButton(const char* label, gx_jconv::IRWindow *irw) {
357  Gtk::Button *button = new Gtk::Button();
358  button->set_can_default(false);
359  button->set_can_focus(false);
360  Gtk::Label *lab = new Gtk::Label(label);
361  //Pango::FontDescription font = lab->get_style()->get_font();
362  //font.set_size(10*Pango::SCALE);
363  //font.set_weight(Pango::WEIGHT_NORMAL);
364  //lab->modify_font(font);
365  button->add(*manage(lab));
366  //lab->set_name("rack_label_inverse");
367  Gtk::Alignment *al = new Gtk::Alignment(0.0, 0.5, 0.0, 0.0);
368  al->add(*manage(button));
369  al->show_all();
370  fBox.box_pack_start(manage(al), false);
371  button->signal_clicked().connect(
372  sigc::mem_fun(*irw, &gx_jconv::IRWindow::reload_and_show));
373 }
374 
375 void StackBoxBuilder::addSmallSeqButton(const char* label, gx_seq::SEQWindow *seqw) {
376  Gtk::Button *button = new Gtk::Button();
377  button->set_name("smallbutton");
378  Gtk::Label *lab = new Gtk::Label(label);
379  Pango::FontDescription font = lab->get_style()->get_font();
380  font.set_size(7*Pango::SCALE);
381  font.set_weight(Pango::WEIGHT_NORMAL);
382  lab->modify_font(font);
383  button->add(*manage(lab));
384  //lab->set_name("rack_label_inverse");
385  lab->set_padding(5,0);
386  fBox.add(manage(button), label);
387  lab->show();
388  button->signal_clicked().connect(
389  sigc::mem_fun(*seqw, &gx_seq::SEQWindow::reload_and_show));
390 }
391 
392 void StackBoxBuilder::addSeqButton(const char* label, gx_seq::SEQWindow *seqw) {
393  Gtk::Button *button = new Gtk::Button();
394  button->set_can_default(false);
395  button->set_can_focus(false);
396  Gtk::Label *lab = new Gtk::Label(label);
397  //Pango::FontDescription font = lab->get_style()->get_font();
398  //font.set_size(10*Pango::SCALE);
399  //font.set_weight(Pango::WEIGHT_NORMAL);
400  //lab->modify_font(font);
401  button->add(*manage(lab));
402  //lab->set_name("rack_label_inverse");
403  Gtk::Alignment *al = new Gtk::Alignment(0.0, 0.5, 0.0, 0.0);
404  al->add(*manage(button));
405  al->show_all();
406  fBox.box_pack_start(manage(al), false);
407  button->signal_clicked().connect(
408  sigc::mem_fun(*seqw, &gx_seq::SEQWindow::reload_and_show));
409 }
410 
411 void StackBoxBuilder::set_next_flags(int flags) {
412  next_flags = flags;
413 }
414 
415 bool StackBoxBuilder::set_simple(Gxw::FastMeter *fastmeter,const std::string id) {
416  if (machine.parameter_hasId(id)) {
417  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off"))
418  fastmeter->set_by_power(machine.get_parameter_value<float>(id));
419  else
420  fastmeter->set_by_power(0.0001);
421  return true;
422  } else {
423  return false;
424  }
425 }
426 
427 bool StackBoxBuilder::set_compressor_level(Gxw::FastMeter *fastmeter,const std::string id) {
428  if (machine.parameter_hasId(id)) {
429  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off"))
430  fastmeter->set_c_level(machine.get_parameter_value<float>(id));
431  else
432  fastmeter->set_c_level(0.0);
433  return true;
434  } else {
435  return false;
436  }
437 }
438 
439 void StackBoxBuilder::create_simple_meter(const std::string& id) {
440  Gxw::FastMeter *fastmeter = new Gxw::FastMeter();
441  fastmeter->set_hold_count(5);
442  fastmeter->set_property("dimen",2);
443  fastmeter->set_property("type",0);
444  Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
445  sigc::mem_fun(*this, &StackBoxBuilder::set_simple),id), fastmeter), 60);
446  fastmeter->set_by_power(0.0001);
447  Gtk::HBox *box = new Gtk::HBox();
448  box->set_border_width(2);
449  box->pack_start(*Gtk::manage(static_cast<Gtk::Widget*>(fastmeter)),Gtk::PACK_SHRINK);
450  box->show_all();
451  fBox.box_pack_start(manage(box),false);
452 }
453 
454 void StackBoxBuilder::create_simple_c_meter(const std::string& id, const std::string& idm, const char *label) {
455  Gxw::FastMeter *fastmeter = new Gxw::FastMeter();
456  fastmeter->set_hold_count(5);
457  fastmeter->set_property("dimen",2);
458  fastmeter->set_property("type",0);
459  fastmeter->set_name("simplemeter");
460  Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
461  sigc::mem_fun(*this, &StackBoxBuilder::set_simple),id), fastmeter), 60);
462  fastmeter->set_by_power(0.0001);
463  Gxw::LevelSlider *w = new UiRegler<Gxw::LevelSlider>(machine, idm);
464  w->set_name("lmw");
465  GxPaintBox *box = new GxPaintBox("simple_level_meter_expose");
466  box->set_border_width(2);
467  box->pack_start(*Gtk::manage(static_cast<Gtk::Widget*>(fastmeter)),Gtk::PACK_SHRINK);
468  box->add(*Gtk::manage(static_cast<Gtk::Widget*>(w)));
469  if (label && label[0]) {
470  Gtk::VBox *boxv = new Gtk::VBox();
471  //boxv->set_property("orientation",Gtk::ORIENTATION_VERTICAL);
472  boxv->set_homogeneous(false);
473  boxv->set_spacing(0);
474  // boxv->set_border_width(4);
475  Gtk::Label *lab = new Gtk::Label(label);
476  Pango::FontDescription font = lab->get_style()->get_font();
477  font.set_size(6*Pango::SCALE);
478  font.set_weight(Pango::WEIGHT_NORMAL);
479  lab->modify_font(font);
480  lab->set_name("beffekt_label");
481  boxv->add(*manage(lab));
482  boxv->add(*manage(box));
483  boxv->show_all();
484  fBox.box_pack_start(manage(boxv),false);
485  } else {
486  box->show_all();
487  fBox.box_pack_start(manage(box),false);
488  }
489 }
490 
491 bool StackBoxBuilder::set_regler_cp_value(Gxw::Regler * regler, const std::string id) {
492  if (machine.parameter_hasId(id)) {
493  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off"))
494  regler->cp_set_value(machine.get_parameter_value<float>(id));
495  return true;
496  } else {
497  return false;
498  }
499 }
500 
501 bool StackBoxBuilder::set_engine_cp_value(Gxw::Switch * sw, const std::string id) {
502  if (machine.parameter_hasId(id)) {
503  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off"))
504  sw->cp_set_value(machine.get_parameter_value<float>(id));
505  return true;
506  } else {
507  return false;
508  }
509 }
510 
511 bool StackBoxBuilder::set_engine_value(const std::string id) {
512  if (machine.parameter_hasId(id)) {
513  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off"))
514  machine.signal_parameter_value<float>(id)(machine.get_parameter_value<float>(id));
515  return true;
516  } else {
517  return false;
518  }
519 }
520 
521 void StackBoxBuilder::create_port_display(const std::string& id, const char *label) {
522  if (machine.get_jack()) {
523  UiReglerWithCaption<Gxw::PortDisplay> *w = new UiReglerWithCaption<Gxw::PortDisplay>(machine, id);
524  Glib::signal_timeout().connect(sigc::bind<const std::string>(
525  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_value),id), 60);
526  if (next_flags & UI_LABEL_INVERSE) {
527  w->set_rack_label_inverse(label);
528  } else {
529  w->set_rack_label(label);
530  }
531  addwidget(w);
532  }
533 }
534 
535 bool StackBoxBuilder::set_pd_value(Gxw::PortDisplay *w, const std::string id, const std::string& idl, const std::string& idh) {
536  if (machine.parameter_hasId(id)) {
537  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off")) {
538  float low = machine.get_parameter_value<float>(idl);
539  float high = 100-machine.get_parameter_value<float>(idh);
540  w->set_state(int(low),int(high));
541  float set = (low + high)*0.001;
542  machine.signal_parameter_value<float>(id)(machine.get_parameter_value<float>(id)+set);
543  }
544  return true;
545  } else {
546  return false;
547  }
548 }
549 
550 void StackBoxBuilder::create_p_display(const std::string& id, const std::string& idl, const std::string& idh) {
551  Gxw::PortDisplay *w = new UiRegler<Gxw::PortDisplay>(machine, id);
552  w->set_name("playhead");
553  Gtk::EventBox* e_box = new Gtk::EventBox();
554  e_box->set_size_request(-1, -1);
555  e_box->set_border_width(0);
556  e_box->set_visible_window(true);
557  e_box->set_above_child(true);
558  e_box->add(*manage(static_cast<Gtk::Widget*>(w)));
559  addwidget(e_box);
560  e_box->show_all();
561  if (machine.get_jack()) {
562  Glib::signal_timeout().connect(sigc::bind<Gxw::PortDisplay*>(sigc::bind<const std::string>(
563  sigc::bind<const std::string>(sigc::bind<const std::string>(
564  sigc::mem_fun(*this, &StackBoxBuilder::set_pd_value),idh),idl),id),w ), 60);
565  } else {
566  Glib::signal_timeout().connect(sigc::bind<Gxw::PortDisplay*>(sigc::bind<const std::string>(
567  sigc::bind<const std::string>(sigc::bind<const std::string>(
568  sigc::mem_fun(*this, &StackBoxBuilder::set_pd_value),idh),idl),id),w ), 2000);
569  }
570 }
571 
572 void StackBoxBuilder::create_feedback_switch(const char *sw_type, const std::string& id) {
573  Gtk::Widget *sw = UiSwitch::create(machine, sw_type, id);
574  Gxw::Switch *regler = static_cast<Gxw::Switch*>(sw);
575  //regler->set_relief(Gtk::RELIEF_NONE);
576  regler->set_name("effect_on_off");
577  addwidget(sw);
578  if (machine.get_jack()) {
579  Glib::signal_timeout().connect(sigc::bind<const std::string>(
580  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_value),id), 60);
581  } else {
582  Glib::signal_timeout().connect(sigc::bind<const std::string>(
583  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_value),id), 2000);
584  }
585 }
586 
587 void StackBoxBuilder::load_file(const std::string& id, const std::string& idf) {
588  static Glib::ustring recent_filename = "";
589  static Glib::ustring hostname = "localhost";
590  if (! machine.get_jack()) {
591  hostname = Gio::Resolver::get_default()->lookup_by_address
592  (Gio::InetAddress::create( machine.get_options().get_rpcaddress()));
593  }
594  if (machine.parameter_hasId(id)) {
595  if (machine.get_parameter_value<bool>(id.substr(0,id.find_last_of(".")+1)+"on_off")) {
596  if (machine.get_parameter_value<float>(id)>0) {
597  Glib::ustring filename = machine.get_parameter_value<string>(idf);
598  Glib::ustring title = hostname + ": Select loop file";
599  Gtk::FileChooserDialog d( title);
600  d.set_local_only(false);
601  d.property_destroy_with_parent().set_value(true);
602  d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
603  d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
604  Glib::ustring loop_dir = machine.get_options().get_loop_dir();
605  d.add_shortcut_folder_uri(Glib::filename_to_uri(loop_dir, hostname));
606  Gtk::FileFilter wav;
607  wav.set_name("WAV Files");
608  wav.add_mime_type("audio/x-vorbis+ogg");
609  wav.add_mime_type("audio/x-wav");
610  wav.add_pattern("*.ogg");
611  wav.add_pattern("*.wav");
612  wav.add_pattern("*.WAV");
613  wav.add_pattern("*.Wav");
614  d.add_filter(wav);
615  Gtk::FileFilter audio;
616  audio.set_name("Audio Files");
617  audio.add_mime_type("audio/*");
618  d.add_filter(audio);
619  Gtk::FileFilter all;
620  all.add_pattern("*");
621  all.set_name("All Files");
622  d.add_filter(all);
623  if (!recent_filename.empty()) {
624  d.set_uri(Glib::filename_to_uri (recent_filename, hostname));
625  } else if ((filename.find("tape") != Glib::ustring::npos) && (!filename.empty())) {
626  d.set_uri(Glib::filename_to_uri (loop_dir + filename + string(".wav"), hostname));
627  } else {
628  d.set_current_folder_uri(Glib::filename_to_uri (loop_dir, hostname));
629  }
630  d.signal_response().connect(sigc::bind<Gtk::FileChooserDialog*>(sigc::bind<const std::string>(
631  sigc::bind<const std::string>(sigc::mem_fun(*this, &StackBoxBuilder::on_file_chooser_response),idf),id), &d) );
632  d.show();
633  while(machine.get_parameter_value<float>(id)>0) {
634  //g_main_context_iteration (NULL, true);
635  if (Gtk::Main::iteration(false)) {
636  machine.set_parameter_value(id,0.0);
637  machine.signal_parameter_value<float>(id)(0.0);
638  }
639  }
640 
641  // if (d.run() != Gtk::RESPONSE_OK) {
642  // machine.set_parameter_value(id,0.0);
643  // machine.signal_parameter_value<float>(id)(0.0);
644  // return;
645  // }
646  // filename = Glib::filename_from_uri(d.get_uri(), hostname);
647  // recent_filename = filename;
648  // Gtk::RecentManager::Data data;
649  // bool result_uncertain;
650  // data.mime_type = Gio::content_type_guess(filename, "", result_uncertain);
651  // data.app_name = "guitarix";
652  // data.groups.push_back("loopfiles");
653  // Gtk::RecentManager::get_default()->add_item(d.get_uri(), data);
654  // machine.set_parameter_value(idf,filename);
655  // machine.set_parameter_value(id,0.0);
656  // machine.signal_parameter_value<float>(id)(0.0);
657  }
658  }
659  }
660 }
661 
662 void StackBoxBuilder::on_file_chooser_response(int response_id, Gtk::FileChooserDialog *d, const std::string& id, const std::string& idf)
663 {
664  if( response_id == Gtk::RESPONSE_OK) {
665  static Glib::ustring hostname = "localhost";
666  if (! machine.get_jack()) {
667  hostname = Gio::Resolver::get_default()->lookup_by_address
668  (Gio::InetAddress::create( machine.get_options().get_rpcaddress()));
669  }
670  Glib::ustring filename = Glib::filename_from_uri(d->get_uri(), hostname);
671  Glib::ustring recent_filename = filename;
672  Gtk::RecentManager::Data data;
673  bool result_uncertain;
674  data.mime_type = Gio::content_type_guess(filename, "", result_uncertain);
675  data.app_name = "guitarix";
676  data.groups.push_back("loopfiles");
677  Gtk::RecentManager::get_default()->add_item(d->get_uri(), data);
678  d->hide();
679  machine.set_parameter_value(idf,filename);
680  machine.set_parameter_value(id,0.0);
681  machine.signal_parameter_value<float>(id)(0.0);
682  } else {
683  d->hide();
684  machine.set_parameter_value(id,0.0);
685  machine.signal_parameter_value<float>(id)(0.0);
686  }
687  }
688 
689 void StackBoxBuilder::load_file_f(const std::string& id, const std::string& idf) {
690  Glib::signal_timeout().connect_once(
691  sigc::bind<const std::string>(sigc::bind<const std::string>(sigc::mem_fun(this, &StackBoxBuilder::load_file), idf), id),100);
692 }
693 
694 void StackBoxBuilder::create_fload_switch(const char *sw_type, const std::string& id, const std::string& idf) {
695  if (machine.get_jack()) {
696  Gtk::Widget *sw = UiSwitch::create(machine, sw_type, id);
697  Gxw::Switch *regler = static_cast<Gxw::Switch*>(sw);
698  //regler->set_relief(Gtk::RELIEF_NONE);
699  regler->set_name("effect_on_off");
700  addwidget(sw);
701  gx_engine::Parameter& p = machine.get_parameter(id);
702  p.signal_changed_float().connect(sigc::hide(
703  sigc::bind<const std::string>(sigc::bind<const std::string>(sigc::mem_fun(this, &StackBoxBuilder::load_file_f), idf), id)));
704  }
705 }
706 
707 void StackBoxBuilder::create_h_switch(const char *sw_type, const std::string& id, const char *label) {
708  Gtk::Widget* sw = UiHSwitchWithCaption::create(machine, sw_type, id, label);
709  UiHSwitchWithCaption *w = static_cast<UiHSwitchWithCaption*>(sw);
710  //w->get_regler()->set_relief(Gtk::RELIEF_NONE);
711  w->get_regler()->set_name("effect_on_off");
712  if (next_flags & UI_LABEL_INVERSE) {
713  w->set_rack_label_inverse();
714  }
715  addwidget(sw);
716 }
717 
718 void StackBoxBuilder::create_v_switch(const char *sw_type, const std::string& id, const char *label) {
719  Gtk::Widget* sw = UiVSwitchWithCaption::create(machine, sw_type, id, label);
720  UiVSwitchWithCaption *w = static_cast<UiVSwitchWithCaption*>(sw);
721  //w->get_regler()->set_relief(Gtk::RELIEF_NONE);
722  w->get_regler()->set_name("effect_on_off");
723  if (next_flags & UI_LABEL_INVERSE) {
724  w->set_rack_label_inverse();
725  }
726  addwidget(sw);
727 }
728 
729 void StackBoxBuilder::create_feedback_slider(const std::string& id, const char *label) {
730  UiMasterReglerWithCaption<Gxw::HSlider> *w = new UiMasterReglerWithCaption<Gxw::HSlider>(machine, id);
731  if (machine.get_jack()) {
732  Glib::signal_timeout().connect(sigc::bind<const std::string>(
733  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_value),id), 60);
734  } else {
735  Glib::signal_timeout().connect(sigc::bind<const std::string>(
736  sigc::mem_fun(*this, &StackBoxBuilder::set_engine_value),id), 2000);
737  }
738  w->set_label(label);
739  addwidget(w);
740  }
741 
742 void StackBoxBuilder::create_selector(const std::string& id, const char *widget_name) {
743  gx_engine::Parameter& p = machine.get_parameter(id);
744  Gxw::Selector *s;
745  if (p.isFloat()) {
746  s = new UiSelector<float>(machine, id);
747  } else {
748  s = new UiSelector<int>(machine, id);
749  }
750  if (widget_name) {
751  s->set_name(widget_name);
752  }
753  addwidget(s);
754 }
755 
756 void StackBoxBuilder::create_selector_with_caption(const std::string& id, const char *label) {
757  gx_engine::Parameter& p = machine.get_parameter(id);
758  Gtk::VBox *s;
759  if (p.isFloat()) {
760  UiSelectorWithCaption<float> *sel;
761  s = new UiSelectorWithCaption<float>(machine, id, label);
762  sel = static_cast<UiSelectorWithCaption<float>*>(s);
763  if (next_flags & UI_LABEL_INVERSE) {
764  sel->set_rack_label_inverse();
765  }
766  } else {
767  UiSelectorWithCaption<int> *sel;
768  s = new UiSelectorWithCaption<int>(machine, id, label);
769  sel = static_cast<UiSelectorWithCaption<int>*>(s);
770  if (next_flags & UI_LABEL_INVERSE) {
771  sel->set_rack_label_inverse();
772  }
773  }
774  addwidget(s);
775 }
776 
777 void StackBoxBuilder::openSpaceBox(const char* label) {
778  GxVBox * box = new GxVBox();
779  box->set_homogeneous(true);
780  box->set_spacing(1);
781  box->set_border_width(4);
782  box->show_all();
783  if (!fBox.top_is_notebook() && label && label[0]) {
784  fBox.box_pack_start(manage(box));
785  fBox.push(box);
786  } else {
787  fBox.push(fBox.add(manage(box), label));
788  }
789 }
790 
791 void StackBoxBuilder::check_set_flags(Gxw::Regler *r) {
792  if (next_flags & UI_NUM_SHOW_ALWAYS) {
793  r->set_name("show_always");
794  }
795  if ((next_flags & UI_NUM_POSITION_MASK)) {
796  Gtk::PositionType pos = Gtk::POS_BOTTOM;
797  switch (next_flags & UI_NUM_POSITION_MASK) {
798  case UI_NUM_TOP: pos = Gtk::POS_TOP; break;
799  case UI_NUM_LEFT: pos = Gtk::POS_LEFT; break;
800  case UI_NUM_RIGHT: pos = Gtk::POS_RIGHT; break;
801  }
802  r->set_value_position(pos);
803  }
804 }
805 
806 void StackBoxBuilder::create_mid_rackknob(const std::string& id, const char *label) {
807  UiReglerWithCaption<Gxw::MidKnob> *w = new UiReglerWithCaption<Gxw::MidKnob>(machine, id);
808  if (next_flags & UI_LABEL_INVERSE) {
809  w->set_rack_label_inverse(label);
810  } else {
811  w->set_rack_label(label);
812  }
813  check_set_flags(w->get_regler());
814  addwidget(w);
815 }
816 
817 void StackBoxBuilder::create_small_rackknob(const std::string& id, const char *label) {
818  UiReglerWithCaption<Gxw::SmallKnob> *w = new UiReglerWithCaption<Gxw::SmallKnob>(machine, id);
819  if (next_flags & UI_LABEL_INVERSE) {
820  w->set_rack_label_inverse(label);
821  } else {
822  w->set_rack_label(label);
823  }
824  check_set_flags(w->get_regler());
825  addwidget(w);
826 }
827 
828 void StackBoxBuilder::create_small_rackknobr(const std::string& id, const char *label) {
829  UiReglerWithCaption<Gxw::SmallKnobR> *w = new UiReglerWithCaption<Gxw::SmallKnobR>(machine, id);
830  if (next_flags & UI_LABEL_INVERSE) {
831  w->set_rack_label_inverse(label);
832  } else {
833  w->set_rack_label(label);
834  }
835  check_set_flags(w->get_regler());
836  addwidget(w);
837 }
838 
839 void StackBoxBuilder::create_big_rackknob(const std::string& id, const char *label) {
840  UiReglerWithCaption<Gxw::BigKnob> *w = new UiReglerWithCaption<Gxw::BigKnob>(machine, id);
841  if (next_flags & UI_LABEL_INVERSE) {
842  w->set_rack_label_inverse(label);
843  } else {
844  w->set_rack_label(label);
845  }
846  check_set_flags(w->get_regler());
847  addwidget(w);
848 }
849 
850 void StackBoxBuilder::addLiveWaveDisplay(const char* label) {
851  Gtk::HBox * box = new Gtk::HBox(false, 4);
852  Gtk::VBox * box1 = new Gtk::VBox(false, 0);
853  Gtk::VBox * box2 = new Gtk::VBox(false, 0);
854  Gtk::EventBox* e_box = new Gtk::EventBox();
855  //g_signal_connect(box->gobj(), "expose-event", G_CALLBACK(gx_cairo::conv_widget_expose), NULL);
856  //box->set_size_request(303, 82);
857  e_box->set_size_request(284, 84);
858  //box->set_border_width(12);
859  e_box->add(fWaveView);
860  box->pack_start(*manage(box1), true, true, 0);
861  box->pack_start(*manage(e_box), false, false, 0);
862  box->pack_start(*manage(box2), true, true, 0);
863  fBox.add(manage(box), label);
864  fWaveView.hide(); // was show()'n by addWidget
865  fWaveView.property_text_pos_left() = 1.5;
866  fWaveView.property_text_pos_right() = 77;
867  // multiplicator is already set by signal handler
868  box->show_all();
869 }
870 
871 void StackBoxBuilder::openVerticalBox1(const char* label) {
872  GxVBox * box = new GxVBox();
873  box->set_homogeneous(false);
874  box->set_spacing(1);
875  box->set_border_width(0);
876 
877  if (!fBox.top_is_notebook() && label && label[0]) {
878  box->m_label.set_text(label);
879  box->m_label.set_name("effekt_label");
880  box->pack_start(box->m_label, false, false, 0 );
881  fBox.box_pack_start(manage(box));
882  box->show();
883  box->m_label.show();
884  fBox.push(box);
885  } else {
886  fBox.push(fBox.add(manage(box), label));
887  }
888 }
889 
890 void StackBoxBuilder::openVerticalBox2(const char* label) {
891  Gtk::VPaned * box = new Gtk::VPaned();
892  box->set_border_width(0);
893  GxHBox * pbox = new GxHBox();
894  if (!fBox.top_is_notebook() && label && label[0]) {
895  pbox->m_label.set_text(label);
896  pbox->m_label.set_name("rack_label");
897  pbox->pack_start(pbox->m_label, false, false, 0 );
898  }
899  pbox->set_border_width(0);
900  box->pack1(*Gtk::manage(static_cast<Gtk::Widget*>(pbox)),true,true);
901  GxHBox * hbox = new GxHBox();
902  hbox->set_homogeneous(false);
903  hbox->set_spacing(1);
904  hbox->set_border_width(0);
905  box->pack2(*Gtk::manage(static_cast<Gtk::Widget*>(hbox)),true,true);
906  box->set_position(200);
907  fBox.box_pack_start(manage(box), false, false, 0);
908  box->show_all();
909  fBox.push(hbox);
910 }
911 
912 void StackBoxBuilder::openFlipLabelBox(const char* label) {
913  GxVBox * box = new GxVBox();
914  box->set_homogeneous(false);
915  box->set_spacing(0);
916  box->set_border_width(0);
917 
918  if (!fBox.top_is_notebook() && label && label[0]) {
919  GxVBox * vbox = new GxVBox();
920  vbox->set_homogeneous(false);
921  vbox->set_spacing(0);
922  vbox->set_border_width(0);
923 
924  GxHBox * hbox = new GxHBox();
925  hbox->set_homogeneous(false);
926  hbox->set_spacing(0);
927  hbox->set_border_width(0);
928 
929  hbox->m_label.set_text(label);
930  hbox->m_label.set_name("effekt_label");
931  hbox->m_label.set_angle(90);
932  hbox->m_label.set_size_request(15, -1);
933 
934  Pango::FontDescription font = hbox->m_label.get_style()->get_font();
935  font.set_size(8*Pango::SCALE);
936  font.set_weight(Pango::WEIGHT_BOLD);
937  hbox->m_label.modify_font(font);
938 
939  hbox->add(hbox->m_label);
940  hbox->add(*manage(vbox));
941  box->add(*manage(hbox));
942  fBox.box_pack_start(manage(box), false);
943  box->show_all();
944  fBox.push(vbox);
945  } else {
946  fBox.push(fBox.add(manage(box), label));
947  }
948 }
949 
950 class uiSpinner: public Gtk::SpinButton {
951 private:
953 public:
954  uiSpinner(float step, gx_engine::GxMachineBase& machine, const std::string& id)
955  : Gtk::SpinButton(step, precision(step)), adj(machine, id, get_adjustment()) {
956  get_adjustment()->signal_value_changed().connect(
957  sigc::mem_fun(adj, &uiAdjustment::changed));
958  }
959 };
960 
961 void StackBoxBuilder::addNumEntry(const std::string& id, const char* label_) {
962  Glib::ustring label(label_);
963  if (!machine.parameter_hasId(id)) {
964  return;
965  }
966  const gx_engine::FloatParameter &p = machine.get_parameter(id).getFloat();
967  if (label.empty()) {
968  label = p.l_name();
969  }
970  float step = p.getStepAsFloat();
971  uiSpinner* spinner = new uiSpinner(step, machine, id);
972  spinner->get_adjustment()->configure(
973  machine.get_parameter_value<float>(id), p.getLowerAsFloat(), p.getUpperAsFloat(), step, 10*step, 0);
974  connect_midi_controller(spinner, id, machine);
975  Gtk::HBox *box = new Gtk::HBox(homogene, 0);
976  Gtk::Label *lab = new Gtk::Label(label);
977  box->add(*manage(lab));
978  lab->set_name("rack_label");
979  fBox.add(manage(box), label);
980  fBox.add(manage(spinner), label);
981 }
982 
983 class uiToggleButton: public Gtk::ToggleButton {
984 private:
985  gx_engine::GxMachineBase& machine;
986  const std::string id;
987 public:
988  uiToggleButton(gx_engine::GxMachineBase& machine_, const std::string& id_);
989  void toggled();
990  void set_value(bool v);
991 };
992 
993 uiToggleButton::uiToggleButton(gx_engine::GxMachineBase& machine_, const std::string& id_)
994  : Gtk::ToggleButton(), machine(machine_), id(id_) {
995  machine.signal_parameter_value<bool>(id).connect(
996  sigc::mem_fun(this, &Gtk::ToggleButton::set_active));
997  signal_toggled().connect(
998  sigc::mem_fun(this, &uiToggleButton::toggled));
999 }
1000 
1001 void uiToggleButton::toggled() {
1002  machine.set_parameter_value(id, get_active());
1003 }
1004 
1005 void StackBoxBuilder::addMToggleButton(const std::string& id, const char* label_) {
1006  Glib::ustring label(label_);
1007  if (!machine.parameter_hasId(id)) {
1008  return;
1009  }
1010  const gx_engine::BoolParameter &p = machine.get_parameter(id).getBool();
1011  if (label.empty()) {
1012  label = p.l_name();
1013  }
1014  Gdk::Color colorRed("#58b45e");
1015  Gdk::Color colorOwn("#7f7f7f");
1016  Gdk::Color colorwn("#000000");
1017  uiToggleButton* button = new uiToggleButton(machine, id);
1018  Gtk::Label* lab = new Gtk::Label(label);
1019  Pango::FontDescription font = lab->get_style()->get_font();
1020  font.set_weight(Pango::WEIGHT_BOLD);
1021  lab->modify_font(font);
1022  button->add(*manage(lab));
1023  button->set_size_request(70, 20);
1024  Gtk::Box* box = new Gtk::HBox(homogene, 4);
1025  Gtk::Box* box1 = new Gtk::VBox(homogene, 4);
1026  box->set_border_width(0);
1027  box1->set_border_width(0);
1028  box->add(*manage(box1));
1029  Gtk::Box* box2 = new Gtk::VBox(homogene, 4);
1030  box2->set_border_width(0);
1031  box2->set_size_request(6, 20);
1032  box->add(*manage(button));
1033  box->add(*manage(box2));
1034  box1->set_size_request(6, 20);
1035  button->show();
1036  box1->show();
1037  box2->show();
1038  lab->show();
1039  box->show();
1040  fBox.container_add(manage(box));
1041  button->modify_bg(Gtk::STATE_NORMAL, colorOwn);
1042  button->modify_bg(Gtk::STATE_ACTIVE, colorRed);
1043  lab->set_name("rack_label");
1044  connect_midi_controller(button, id, machine);
1046 
1047 class uiCheckButton: public Gtk::CheckButton {
1048 private:
1049  gx_engine::GxMachineBase& machine;
1050  const std::string& id;
1051 public:
1052  uiCheckButton(gx_engine::GxMachineBase& machine_, const std::string& id_)
1053  : Gtk::CheckButton(), machine(machine_), id(id_) {
1054  set_active(machine.get_parameter_value<bool>(id));
1055  machine.signal_parameter_value<bool>(id).connect(sigc::mem_fun(this, &Gtk::CheckButton::set_active));
1056  signal_toggled().connect(
1057  sigc::mem_fun(this, &uiCheckButton::toggled));
1058  }
1059  void toggled() {
1060  machine.set_parameter_value(id, get_active());
1061  }
1062 };
1063 
1064 void StackBoxBuilder::addCheckButton(const std::string& id, const char* label_) {
1065  if (!machine.parameter_hasId(id)) {
1066  return;
1067  }
1068  Glib::ustring label;
1069  if (label_ && label_[0]) {
1070  label = label_;
1071  } else {
1072  label = machine.get_parameter(id).getBool().l_name();
1073  }
1074  Gdk::Color colorRed("#000000");
1075  Gdk::Color colorOwn("#4c5159");
1076  Gdk::Color colorba("#c4c0c0");
1077  Gtk::Label *lab = new Gtk::Label(label);
1078  uiCheckButton *button = new uiCheckButton(machine, id);
1079  button->add(*manage(lab));
1080  fBox.add(manage(button), label);
1081  button->modify_bg(Gtk::STATE_PRELIGHT, colorOwn);
1082  button->modify_fg(Gtk::STATE_PRELIGHT, colorRed);
1083  button->modify_text(Gtk::STATE_NORMAL, colorRed);
1084  button->modify_base(Gtk::STATE_NORMAL, colorba);
1085  Glib::RefPtr<Gtk::Style> style = lab->get_style();
1086  style->get_font().set_size(8*Pango::SCALE);
1087  style->get_font().set_weight(Pango::WEIGHT_NORMAL);
1088  lab->modify_font(style->get_font());
1089  connect_midi_controller(button, id, machine);
1090  lab->show();
1091 }
1092 
1093 void StackBoxBuilder::openHorizontalhideBox(const char* label) {
1094  GxHBox * box = new GxHBox();
1095  box->set_homogeneous(false);
1096  box->set_spacing(0);
1097  box->set_border_width(0);
1098  fBox.box_pack_start(manage(box) , false, false, 5);
1099  fBox.push(box);
1100  box->hide();
1101  if (label[0] != 0) {
1102  box->show();
1103  }
1104 }
1105 
1106 void StackBoxBuilder::openHorizontalTableBox(const char* label) {
1107  Gtk::HBox *box;
1108  if (!fBox.top_is_notebook() && label && label[0]) {
1109  GxHFrame *frame = new GxHFrame();
1110  frame->set_label(label);
1111  frame->set_shadow_type(Gtk::SHADOW_NONE);
1112  frame->add(frame->m_hbox);
1113  fBox.box_pack_start(manage(frame), false);
1114  frame->m_hbox.show();
1115  frame->show();
1116  box = &frame->m_hbox;
1117  fBox.push(box);
1118  } else {
1119  box = new Gtk::HBox();
1120  fBox.push(fBox.add(manage(box), label));
1121  }
1122  box->set_homogeneous(false);
1123  box->set_spacing(1);
1124  box->set_border_width(0);
1125 }
1126 
1127 void StackBoxBuilder::openPaintBox2(const char* label) {
1128  GxEventBox *box = new GxEventBox();
1129  box->m_eventbox.set_name(label);
1130  box->set_homogeneous(false);
1131  box->set_spacing(0);
1132  box->set_border_width(0);
1133  fBox.box_pack_start(manage(box), false, false);
1134  box->show_all();
1135  fBox.push(&box->m_hbox);
1136 }
1137 
1138 void StackBoxBuilder::openTabBox(const char* label) {
1139  GxNotebookBox * box = new GxNotebookBox();
1140  fBox.push(fBox.add(manage(box), label));
1141 }
1142 
1143 void StackBoxBuilder::openpaintampBox(const char* label) {
1144  GxPaintBox *box = new GxPaintBox("rectangle_skin_color_expose");
1145  box->m_hbox.set_border_width(4);
1146  box->set_name(label);
1147  box->set_tooltip_text(label);
1148  fBox.box_pack_start(manage(box));
1149  box->show_all();
1150  fBox.push(&box->m_hbox);
1151 }
1152 
1153 void StackBoxBuilder::closeBox() {
1154  assert(!fBox.empty());
1155  fBox.pop();
1156 }
1157 
1158 void StackBoxBuilder::openHorizontalBox(const char* label) {
1159  Gtk::HBox *box;
1160  if (!fBox.top_is_notebook() && label && label[0]) {
1161  GxHFrame *frame = new GxHFrame();
1162  frame->set_label(label);
1163  frame->set_shadow_type(Gtk::SHADOW_NONE);
1164  frame->add(frame->m_hbox);
1165  fBox.box_pack_start(manage(frame), false);
1166  frame->m_hbox.show();
1167  frame->show();
1168  box = &frame->m_hbox;
1169  fBox.push(box);
1170  } else {
1171  box = new Gtk::HBox();
1172  fBox.push(fBox.add(manage(box), label));
1173  }
1174  box->set_homogeneous(false);
1175  box->set_spacing(1);
1176  box->set_border_width(0);
1177 }
1178 
1179 void StackBoxBuilder::openVerticalBox(const char* label) {
1180  GxVBox * box = new GxVBox();
1181  box->set_homogeneous(false);
1182  box->set_spacing(1);
1183  box->set_border_width(0);
1184 
1185  if (!fBox.top_is_notebook() && label && label[0]) {
1186  box->m_label.set_text(label);
1187  box->m_label.set_name("rack_effect_label");
1188  Glib::RefPtr<Gtk::Style> style = box->m_label.get_style();
1189  style->get_font().set_size(8*Pango::SCALE);
1190  style->get_font().set_weight(Pango::WEIGHT_BOLD);
1191  box->m_label.modify_font(style->get_font());
1192  box->pack_start(box->m_label, false, false, 0 );
1193  fBox.box_pack_start(manage(box), false);
1194  box->show();
1195  box->m_label.show();
1196  fBox.push(box);
1197  } else {
1198  fBox.push(fBox.add(manage(box), label));
1199  }
1200 }
1201 
1202 void StackBoxBuilder::openFrameBox(const char* label) {
1203  Gtk::HBox *box;
1204 
1205  if (!fBox.top_is_notebook() && label && label[0]) {
1206  GxHFrame *frame = new GxHFrame();
1207  frame->set_label(label);
1208  frame->set_shadow_type(Gtk::SHADOW_NONE);
1209  frame->add(frame->m_hbox);
1210  fBox.box_pack_start(manage(frame), false);
1211  frame->m_hbox.show();
1212  frame->show();
1213  box = &frame->m_hbox;
1214  fBox.push(box);
1215  } else {
1216  box = new Gtk::HBox();
1217  fBox.push(fBox.add(manage(box), label));
1218  }
1219  box->set_homogeneous(false);
1220  box->set_spacing(1);
1221  box->set_border_width(2);
1222 }
1223 
1224 } // end namespace gx_gui
gx_jconv::IRWindow
Definition: gx_jconv_settings.h:36
gx_gui::StackBoxBuilder::make_rackbox_sequencer
void make_rackbox_sequencer()
Definition: gx_mono_rack_builder.cpp:56
gx_engine::Parameter::l_name
string l_name() const
Definition: gx_parameter.h:175
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_gui::StackBoxBuilder::StackBoxBuilder
StackBoxBuilder(gx_engine::GxMachineBase &machine_, Gxw::WaveView &fWaveView_, Gtk::Label &convolver_filename_label_, Gtk::Label &convolver_mono_filename_label_, Glib::RefPtr< Gdk::Pixbuf > window_icon)
Definition: gx_stackbox_builder.cpp:88
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_gui::uiToggleButton::toggled
void toggled()
Definition: gx_stackbox_builder.cpp:999
gx_engine::GxMachineBase
Definition: machine.h:53
gx_gui::StackBoxBuilder::get_box
void get_box(const std::string &name, Gtk::Widget *&mainbox, Gtk::Widget *&minibox)
Definition: gx_stackbox_builder.cpp:137
gx_gui::WidgetStack::push
void push(Gtk::Widget *w)
Definition: gx_stackbox_builder.h:35
gx_engine::ParameterV< float >::getLowerAsFloat
virtual float getLowerAsFloat() const
Definition: gx_paramtable.cpp:1275
gx_gui::StackBoxBuilder::prepare
void prepare()
Definition: gx_stackbox_builder.cpp:104
gx_engine::ParameterV< float >::getUpperAsFloat
virtual float getUpperAsFloat() const
Definition: gx_paramtable.cpp:1279
gx_gui::uiSpinner::uiSpinner
uiSpinner(float step, gx_engine::GxMachineBase &machine, const std::string &id)
Definition: gx_stackbox_builder.cpp:952
gx_gui::precision
int precision(double n)
Definition: gx_stackbox_builder.cpp:20
gx_gui::WidgetStack::empty
bool empty()
Definition: gx_stackbox_builder.h:34
Gxw::Switch
Definition: switch.h:44
gx_engine::ParameterV< GxJConvSettings >
Definition: gx_internal_plugins.h:344
gx_gui::WidgetStack::box_pack_start
void box_pack_start(Gtk::Widget *w, bool expand=true, bool fill=true, int padding=0)
Definition: gx_stackbox_builder.cpp:55
gx_engine::GxMachineBase::signal_parameter_value
sigc::signal< void, T > & signal_parameter_value(const std::string &id)
gx_engine::ParameterV< GxJConvSettings >::get_value
const GxJConvSettings & get_value() const
Definition: gx_internal_plugins.h:362
gx_gui::pb_gxhead_expose
const char * pb_gxhead_expose
Definition: gx_stackbox_builder.cpp:14
gx_engine::ParameterV< bool >
Definition: gx_parameter.h:349
gx_gui::wnotify
void wnotify(gpointer data, GObject *where_the_object_was)
Definition: gx_stackbox_builder.cpp:111
Gxw::PortDisplay
Definition: portdisplay.h:43
gx_gui::StackBoxBuilder::make_rackbox_jconv
void make_rackbox_jconv()
Definition: gx_stereo_rack_builder.cpp:36
gx_gui::WidgetStack::pop
void pop()
Definition: gx_stackbox_builder.h:36
gx_engine::GxMachineBase::set_parameter_value
virtual void set_parameter_value(const std::string &id, int value)=0
UI_NUM_POSITION_MASK
#define UI_NUM_POSITION_MASK
Definition: gx_plugin.h:43
Gxw::WaveView
Definition: waveview.h:42
gx_jconv::IRWindow::reload_and_show
void reload_and_show()
Definition: gx_jconv_settings.cpp:685
gx_gui::uiCheckButton
Definition: gx_stackbox_builder.cpp:1045
gx_system::to_string
std::string to_string(const T &t)
Definition: gx_system.h:524
gx_seq::SEQWindow
Definition: gx_sequencer_settings.h:81
gx_gui::UiVSwitchWithCaption::create
static Gtk::Widget * create(gx_engine::GxMachineBase &machine, const char *sw_type, const std::string &id, const char *label)
Definition: gxw_mm_controllers.cpp:428
gx_gui::uiToggleButton
Definition: gx_stackbox_builder.cpp:981
gx_engine::ParameterV< float >
Definition: gx_parameter.h:228
gx_gui::pb_gx_rack_amp_expose
const char * pb_gx_rack_amp_expose
Definition: gx_stackbox_builder.cpp:11
gx_engine::Parameter::getBool
BoolParameter & getBool()
Definition: gx_parameter.h:469
gx_engine::ParameterV< GxJConvSettings >::signal_changed
sigc::signal< void, const GxJConvSettings * > & signal_changed()
Definition: gx_internal_plugins.h:358
gx_gui::pb_rectangle_skin_color_expose
const char * pb_rectangle_skin_color_expose
Definition: gx_stackbox_builder.cpp:12
Gxw::PortDisplay::set_state
void set_state(int cutoff_low, int cutoff_high)
Definition: portdisplay.cc:54
gx_gui::UiHSwitchWithCaption::create
static Gtk::Widget * create(gx_engine::GxMachineBase &machine, const char *sw_type, const std::string &id, const char *label)
Definition: gxw_mm_controllers.cpp:405
Gxw::Selector
Definition: selector.h:43
gx_gui::StackBoxBuilder::make_rackbox_midi_out
void make_rackbox_midi_out()
Definition: gx_mono_rack_builder.cpp:144
gx_system::CmdlineOptions::get_rpcaddress
const Glib::ustring & get_rpcaddress()
Definition: gx_system.h:491
gx_gui::uiAdjustment::changed
void changed()
Definition: gx_main_interface.h:231
gx_engine::Parameter::getFloat
FloatParameter & getFloat()
Definition: gx_parameter.h:453
Gxw::FastMeter::set_hold_count
void set_hold_count(int val)
Definition: fastmeter.cc:152
gx_engine::GxMachineBase::get_parameter
virtual Parameter & get_parameter(const std::string &id)=0
gx_gui::uiCheckButton::uiCheckButton
uiCheckButton(gx_engine::GxMachineBase &machine_, const std::string &id_)
Definition: gx_stackbox_builder.cpp:1050
Gxw::LevelSlider
Definition: levelslider.h:43
gx_gui::WidgetStack::add
Gtk::Widget * add(Gtk::Widget *w, const Glib::ustring &label=Glib::ustring())
Definition: gx_stackbox_builder.cpp:63
gx_gui::pb_gxrack_expose
const char * pb_gxrack_expose
Definition: gx_stackbox_builder.cpp:16
Gxw::FastMeter::set_by_power
void set_by_power(double lvl)
Definition: fastmeter.cc:137
gx_print_error
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:165
gx_gui::uiToggleButton::set_value
void set_value(bool v)
Gxw::FastMeter::set_c_level
void set_c_level(double lvl)
Definition: fastmeter.cc:142
gx_gui::trace_finalize
void trace_finalize(Glib::Object *o, int n)
Definition: gx_stackbox_builder.cpp:116
gx_gui::uiCheckButton::toggled
void toggled()
Definition: gx_stackbox_builder.cpp:1057
gx_engine::GxJConvSettings::getIRFile
const std::string & getIRFile() const
Definition: gx_internal_plugins.h:319
gx_system::BasicOptions::get_builder_filepath
std::string get_builder_filepath(const std::string &basename) const
Definition: gx_system.h:369
gx_gui::fformat
std::string fformat(float value, float step)
Definition: gx_stackbox_builder.cpp:31
gx_engine::GxMachineBase::midi_get_config_mode
virtual bool midi_get_config_mode(int *ctl=0)=0
gx_gui::uiToggleButton::uiToggleButton
uiToggleButton(gx_engine::GxMachineBase &machine_, const std::string &id_)
Definition: gx_stackbox_builder.cpp:991
gx_gui
Definition: gx_gui_helpers.h:28
gx_main_midi::MidiConnect
Definition: gx_main_midi.h:73
UI_NUM_RIGHT
#define UI_NUM_RIGHT
Definition: gx_plugin.h:42
UI_NUM_LEFT
#define UI_NUM_LEFT
Definition: gx_plugin.h:41
Gxw::FastMeter
Definition: fastmeter.h:42
Gxw::Regler::set_value_position
void set_value_position(Gtk::PositionType p1)
Definition: regler.cc:477
gx_gui::StackBoxBuilder
Definition: gx_stackbox_builder.h:44
gx_gui::StackBoxBuilder::fetch
void fetch(Gtk::Widget *&mainbox, Gtk::Widget *&minibox)
Definition: gx_stackbox_builder.cpp:121
gx_gui::pb_RackBox_expose
const char * pb_RackBox_expose
Definition: gx_stackbox_builder.cpp:15
gx_gui::WidgetStack::notebook_append_page
void notebook_append_page(Gtk::Widget *w, Gtk::Widget *label)
Definition: gx_stackbox_builder.cpp:59
gx_gui::pb_level_meter_expose
const char * pb_level_meter_expose
Definition: gx_stackbox_builder.cpp:17
gx_gui::uiAdjustment
Definition: gx_main_interface.h:221
gx_engine::Parameter::isFloat
bool isFloat() const
Definition: gx_parameter.h:161
gx_engine::ParameterV< float >::getStepAsFloat
virtual float getStepAsFloat() const
Definition: gx_paramtable.cpp:1283
GxPaintBox
struct _GxPaintBox GxPaintBox
Definition: paintbox.h:32
UI_NUM_SHOW_ALWAYS
#define UI_NUM_SHOW_ALWAYS
Definition: gx_plugin.h:44
Gxw::Regler
Definition: regler.h:45
gx_gui::connect_midi_controller
void connect_midi_controller(Gtk::Widget *w, const std::string &id, gx_engine::GxMachineBase &machine)
Definition: gx_main_interface.h:275
gx_gui::uiSpinner
Definition: gx_stackbox_builder.cpp:948
gx_engine::GxMachineBase::get_jack
virtual gx_jack::GxJack * get_jack()=0
gx_gui::WidgetStack::top_is_notebook
bool top_is_notebook()
Definition: gx_stackbox_builder.h:40
gx_engine::GxJConvSettings
Definition: gx_internal_plugins.h:297
gx_engine::Parameter::signal_changed_float
sigc::signal< void, float > & signal_changed_float()
Definition: gx_parameter.h:484
gx_gui::pb_zac_expose
const char * pb_zac_expose
Definition: gx_stackbox_builder.cpp:13
gx_gui::StackBoxBuilder::make_rackbox_oscilloscope
void make_rackbox_oscilloscope()
Definition: gx_mono_rack_builder.cpp:34
UI_NUM_TOP
#define UI_NUM_TOP
Definition: gx_plugin.h:39
guitarix.h
UI_LABEL_INVERSE
#define UI_LABEL_INVERSE
Definition: gx_plugin.h:45
gx_engine::Parameter
Definition: gx_parameter.h:104
gx_gui::StackBoxBuilder::make_rackbox_jconv_mono
void make_rackbox_jconv_mono()
Definition: gx_mono_rack_builder.cpp:85
gx_gui::WidgetStack::container_add
void container_add(Gtk::Widget *w)
Definition: gx_stackbox_builder.cpp:51
gx_gui::button_press_cb
bool button_press_cb(GdkEventButton *event, gx_engine::GxMachineBase &machine, const std::string &id)
Definition: gx_stackbox_builder.cpp:37
gx_system::CmdlineOptions::get_loop_dir
const std::string & get_loop_dir() const
Definition: gx_system.h:474
gx_gui::StackBoxBuilder::~StackBoxBuilder
~StackBoxBuilder()
Definition: gx_stackbox_builder.cpp:97
gx_gui::UiSwitch::create
static UiSwitch * create(gx_engine::GxMachineBase &machine, const char *sw_type, gx_engine::Parameter &param)
Definition: gxw_mm_controllers.cpp:331