3 #include <glibmm/i18n.h> 23 else if (n < 0.099999)
25 else if (n < 0.999999)
33 buf << fixed << setprecision(
precision(step)) << value;
38 if (event->button == 2) {
53 dynamic_cast<Gtk::Container*
>(top())->
add(*w);
57 dynamic_cast<Gtk::Box*
>(top())->pack_start(*w, expand, fill, padding);
61 dynamic_cast<Gtk::Notebook*
>(top())->append_page(*w, *label);
66 Gtk::Widget *t = top();
67 Gtk::Notebook *n =
dynamic_cast<Gtk::Notebook*
>(t);
69 n->append_page(*w, *manage(
new Gtk::Label(label)));
72 Gtk::Box *b =
dynamic_cast<Gtk::Box*
>(t);
74 b->pack_start(*w,
true,
true, 0);
77 Gtk::Container *c =
dynamic_cast<Gtk::Container*
>(t);
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) {
102 void StackBoxBuilder::openVerticalMidiBox(
const char* label) {
103 openVerticalBox(label);
107 widget =
new Gtk::HBox();
109 fBox.
push(manage(widget));
113 void wnotify(gpointer data, GObject *where_the_object_was) {
114 printf(
"WN %p %p\n", where_the_object_was, data);
119 g_object_weak_ref(o->gobj(),
wnotify, GINT_TO_POINTER(n));
125 assert(fBox.
empty());
127 Glib::ListHandle<Gtk::Widget*> l = widget->get_children();
129 Glib::ListHandle<Gtk::Widget*>::iterator i = l.begin();
130 minibox =
new Gtk::VBox();
133 (*i)->reparent(*minibox);
152 mainbox = minibox = 0;
153 for (
unsigned int i = 0; i <
sizeof(mapping) /
sizeof(mapping[0]); ++i) {
154 if (name == mapping[i].name) {
156 (this->*mapping[i].func)();
157 fetch(mainbox, minibox);
162 void StackBoxBuilder::loadRackFromBuilder(
const Glib::RefPtr<GxBuilder>& bld) {
163 if (!bld->has_object(
"rackbox")) {
168 if (bld->has_object(
"minibox")) {
169 bld->find_widget(
"minibox", w);
172 bld->find_widget(
"rackbox", w);
178 for (
int i = 1; i<12;++i) {
180 if (bld->has_object(fm)) {
182 bld->find_widget(fm, fastmeter);
183 fastmeter->get_property(
"var_id",
id);
184 fastmeter->set_name(
"simplemeter");
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);
193 for (
int i = 1; i<12;++i) {
195 if (bld->has_object(fm)) {
197 bld->find_widget(fm, fastmeter);
198 fastmeter->get_property(
"var_id",
id);
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);
208 for (
int i = 1; i<12;++i) {
210 if (bld->has_object(fm)) {
212 bld->find_widget(fm, fastmeter);
213 fastmeter->get_property(
"var_id",
id);
214 fastmeter->set_name(
"simplemeter");
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);
223 for (
int i = 1; i<12;++i) {
225 if (bld->has_object(fm)) {
227 bld->find_widget(fm, regler);
228 regler->get_property(
"var_id",
id);
230 Glib::signal_timeout().connect(sigc::bind<const std::string>(
231 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
238 for (
int i = 1; i<12;++i) {
240 if (bld->has_object(fm)) {
242 bld->find_widget(fm, sw);
243 sw->get_property(
"var_id",
id);
244 sw->set_name(
"effect_on_off");
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);
255 for (
int i = 1; i<12;++i) {
257 if (bld->has_object(fm)) {
259 bld->find_widget(fm, regler);
260 regler->get_property(
"var_id",
id);
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);
270 static const char *rackbox_ids[] = {
"rackbox",
"minibox", 0 };
272 void StackBoxBuilder::loadRackFromGladeFile(
const char *fname) {
274 GxBuilder::create_from_file(
278 void StackBoxBuilder::loadRackFromGladeData(
const char *xmldesc) {
279 loadRackFromBuilder(GxBuilder::create_from_string(xmldesc, &machine, rackbox_ids));
282 void StackBoxBuilder::addwidget(Gtk::Widget *widget) {
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));
299 lab->set_padding(5,0);
300 fBox.
add(manage(button), label);
302 button->signal_clicked().connect(
307 convolver_filename_label.set_label(jcs->
getIRFile());
311 convolver_mono_filename_label.set_label(jcs->
getIRFile());
314 void StackBoxBuilder::openSetLabelBox() {
315 Gtk::VBox *box =
new Gtk::VBox();
316 box->set_homogeneous(
false);
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);
330 sigc::mem_fun(*
this, &StackBoxBuilder::set_convolver_filename));
335 void StackBoxBuilder::openSetMonoLabelBox() {
336 Gtk::VBox *box =
new Gtk::VBox();
337 box->set_homogeneous(
false);
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);
351 sigc::mem_fun(*
this, &StackBoxBuilder::set_convolver_mono_filename));
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);
365 button->add(*manage(lab));
367 Gtk::Alignment *al =
new Gtk::Alignment(0.0, 0.5, 0.0, 0.0);
368 al->add(*manage(button));
371 button->signal_clicked().connect(
375 Gtk::Button *button =
new Gtk::Button();
376 button->set_can_default(
false);
377 button->set_can_focus(
false);
378 Gtk::Label *lab =
new Gtk::Label(label);
383 button->add(*manage(lab));
385 Gtk::Alignment *al =
new Gtk::Alignment(0.0, 0.5, 0.0, 0.0);
386 al->add(*manage(button));
389 button->signal_clicked().connect(
393 void StackBoxBuilder::set_next_flags(
int flags) {
397 bool StackBoxBuilder::set_simple(
Gxw::FastMeter *fastmeter,
const std::string
id) {
409 bool StackBoxBuilder::set_compressor_level(
Gxw::FastMeter *fastmeter,
const std::string
id) {
421 void StackBoxBuilder::create_simple_meter(
const std::string&
id) {
424 fastmeter->set_property(
"dimen",2);
425 fastmeter->set_property(
"type",0);
426 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
427 sigc::mem_fun(*
this, &StackBoxBuilder::set_simple),
id), fastmeter), 60);
429 Gtk::HBox *box =
new Gtk::HBox();
430 box->set_border_width(2);
431 box->pack_start(*Gtk::manage(static_cast<Gtk::Widget*>(fastmeter)),Gtk::PACK_SHRINK);
436 void StackBoxBuilder::create_simple_c_meter(
const std::string&
id,
const std::string& idm,
const char *label) {
439 fastmeter->set_property(
"dimen",2);
440 fastmeter->set_property(
"type",0);
441 fastmeter->set_name(
"simplemeter");
442 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
443 sigc::mem_fun(*
this, &StackBoxBuilder::set_simple),
id), fastmeter), 60);
448 box->set_border_width(2);
449 box->pack_start(*Gtk::manage(static_cast<Gtk::Widget*>(fastmeter)),Gtk::PACK_SHRINK);
450 box->add(*Gtk::manage(static_cast<Gtk::Widget*>(w)));
451 if (label && label[0]) {
452 Gtk::VBox *boxv =
new Gtk::VBox();
454 boxv->set_homogeneous(
false);
455 boxv->set_spacing(0);
457 Gtk::Label *lab =
new Gtk::Label(label);
458 Pango::FontDescription font = lab->get_style()->get_font();
459 font.set_size(6*Pango::SCALE);
460 font.set_weight(Pango::WEIGHT_NORMAL);
461 lab->modify_font(font);
462 lab->set_name(
"beffekt_label");
463 boxv->add(*manage(lab));
464 boxv->add(*manage(box));
473 bool StackBoxBuilder::set_regler_cp_value(
Gxw::Regler * regler,
const std::string
id) {
483 bool StackBoxBuilder::set_engine_cp_value(
Gxw::Switch * sw,
const std::string
id) {
493 bool StackBoxBuilder::set_engine_value(
const std::string
id) {
503 void StackBoxBuilder::create_port_display(
const std::string&
id,
const char *label) {
505 Glib::signal_timeout().connect(sigc::bind<const std::string>(
506 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
515 bool StackBoxBuilder::set_pd_value(
Gxw::PortDisplay *w,
const std::string
id,
const std::string& idl,
const std::string& idh) {
521 float set = (low + high)*0.001;
530 void StackBoxBuilder::create_p_display(
const std::string&
id,
const std::string& idl,
const std::string& idh) {
532 w->set_name(
"playhead");
533 Gtk::EventBox* e_box =
new Gtk::EventBox();
534 e_box->set_size_request(-1, -1);
535 e_box->set_border_width(0);
536 e_box->set_visible_window(
true);
537 e_box->set_above_child(
true);
538 e_box->add(*manage(static_cast<Gtk::Widget*>(w)));
541 Glib::signal_timeout().connect(sigc::bind<Gxw::PortDisplay*>(sigc::bind<const std::string>(
542 sigc::bind<const std::string>(sigc::bind<const std::string>(
543 sigc::mem_fun(*
this, &StackBoxBuilder::set_pd_value),idh),idl),
id),w ), 60);
546 void StackBoxBuilder::create_feedback_switch(
const char *sw_type,
const std::string&
id) {
550 regler->set_name(
"effect_on_off");
552 Glib::signal_timeout().connect(sigc::bind<const std::string>(
553 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
556 void StackBoxBuilder::load_file(
const std::string&
id,
const std::string& idf) {
557 static Glib::ustring recent_filename =
"";
558 static Glib::ustring hostname =
"localhost";
560 hostname = Gio::Resolver::get_default()->lookup_by_address
567 Glib::ustring title = hostname +
": Select loop file";
568 Gtk::FileChooserDialog d( title);
569 d.set_local_only(
false);
570 d.property_destroy_with_parent().set_value(
true);
571 d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
572 d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
574 d.add_shortcut_folder_uri(Glib::filename_to_uri(loop_dir, hostname));
576 wav.set_name(
"WAV Files");
577 wav.add_mime_type(
"audio/x-vorbis+ogg");
578 wav.add_mime_type(
"audio/x-wav");
579 wav.add_pattern(
"*.ogg");
580 wav.add_pattern(
"*.wav");
581 wav.add_pattern(
"*.WAV");
582 wav.add_pattern(
"*.Wav");
584 Gtk::FileFilter audio;
585 audio.set_name(
"Audio Files");
586 audio.add_mime_type(
"audio/*");
589 all.add_pattern(
"*");
590 all.set_name(
"All Files");
592 if (!recent_filename.empty()) {
593 d.set_uri(Glib::filename_to_uri (recent_filename, hostname));
594 }
else if ((filename.find(
"tape") != Glib::ustring::npos) && (!filename.empty())) {
595 d.set_uri(Glib::filename_to_uri (loop_dir + filename +
string(
".wav"), hostname));
597 d.set_current_folder_uri(Glib::filename_to_uri (loop_dir, hostname));
599 d.signal_response().connect(sigc::bind<Gtk::FileChooserDialog*>(sigc::bind<const std::string>(
600 sigc::bind<const std::string>(sigc::mem_fun(*
this, &StackBoxBuilder::on_file_chooser_response),idf),
id), &d) );
604 if (Gtk::Main::iteration(
false)) {
631 void StackBoxBuilder::on_file_chooser_response(
int response_id, Gtk::FileChooserDialog *d,
const std::string&
id,
const std::string& idf)
633 if( response_id == Gtk::RESPONSE_OK) {
634 static Glib::ustring hostname =
"localhost";
636 hostname = Gio::Resolver::get_default()->lookup_by_address
639 Glib::ustring filename = Glib::filename_from_uri(d->get_uri(), hostname);
640 Glib::ustring recent_filename = filename;
641 Gtk::RecentManager::Data data;
642 bool result_uncertain;
643 data.mime_type = Gio::content_type_guess(filename,
"", result_uncertain);
644 data.app_name =
"guitarix";
645 data.groups.push_back(
"loopfiles");
646 Gtk::RecentManager::get_default()->add_item(d->get_uri(), data);
658 void StackBoxBuilder::load_file_f(
const std::string&
id,
const std::string& idf) {
659 Glib::signal_timeout().connect_once(
660 sigc::bind<const std::string>(sigc::bind<const std::string>(sigc::mem_fun(
this, &StackBoxBuilder::load_file), idf),
id),100);
663 void StackBoxBuilder::create_fload_switch(
const char *sw_type,
const std::string&
id,
const std::string& idf) {
668 regler->set_name(
"effect_on_off");
672 sigc::bind<const std::string>(sigc::bind<const std::string>(sigc::mem_fun(
this, &StackBoxBuilder::load_file_f), idf),
id)));
676 void StackBoxBuilder::create_h_switch(
const char *sw_type,
const std::string&
id,
const char *label) {
687 void StackBoxBuilder::create_v_switch(
const char *sw_type,
const std::string&
id,
const char *label) {
698 void StackBoxBuilder::create_feedback_slider(
const std::string&
id,
const char *label) {
700 Glib::signal_timeout().connect(sigc::bind<const std::string>(
701 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
706 void StackBoxBuilder::create_selector(
const std::string&
id,
const char *widget_name) {
715 s->set_name(widget_name);
720 void StackBoxBuilder::create_selector_with_caption(
const std::string&
id,
const char *label) {
741 void StackBoxBuilder::openSpaceBox(
const char* label) {
743 box->set_homogeneous(
true);
745 box->set_border_width(4);
751 fBox.
push(fBox.
add(manage(box), label));
755 void StackBoxBuilder::check_set_flags(
Gxw::Regler *r) {
757 r->set_name(
"show_always");
760 Gtk::PositionType pos = Gtk::POS_BOTTOM;
761 switch (next_flags & UI_NUM_POSITION_MASK) {
770 void StackBoxBuilder::create_mid_rackknob(
const std::string&
id,
const char *label) {
781 void StackBoxBuilder::create_small_rackknob(
const std::string&
id,
const char *label) {
792 void StackBoxBuilder::create_small_rackknobr(
const std::string&
id,
const char *label) {
803 void StackBoxBuilder::create_big_rackknob(
const std::string&
id,
const char *label) {
814 void StackBoxBuilder::addLiveWaveDisplay(
const char* label) {
815 Gtk::HBox * box =
new Gtk::HBox(
false, 4);
816 Gtk::VBox * box1 =
new Gtk::VBox(
false, 0);
817 Gtk::VBox * box2 =
new Gtk::VBox(
false, 0);
818 Gtk::EventBox* e_box =
new Gtk::EventBox();
821 e_box->set_size_request(284, 84);
823 e_box->add(fWaveView);
824 box->pack_start(*manage(box1),
true,
true, 0);
825 box->pack_start(*manage(e_box),
false,
false, 0);
826 box->pack_start(*manage(box2),
true,
true, 0);
827 fBox.
add(manage(box), label);
829 fWaveView.property_text_pos_left() = 1.5;
830 fWaveView.property_text_pos_right() = 77;
835 void StackBoxBuilder::openVerticalBox1(
const char* label) {
837 box->set_homogeneous(
false);
839 box->set_border_width(0);
843 box->
m_label.set_name(
"effekt_label");
844 box->pack_start(box->
m_label,
false,
false, 0 );
850 fBox.
push(fBox.
add(manage(box), label));
854 void StackBoxBuilder::openVerticalBox2(
const char* label) {
855 Gtk::VPaned * box =
new Gtk::VPaned();
856 box->set_border_width(0);
860 pbox->
m_label.set_name(
"rack_label");
861 pbox->pack_start(pbox->
m_label,
false,
false, 0 );
863 pbox->set_border_width(0);
864 box->pack1(*Gtk::manage(static_cast<Gtk::Widget*>(pbox)),
true,
true);
866 hbox->set_homogeneous(
false);
867 hbox->set_spacing(1);
868 hbox->set_border_width(0);
869 box->pack2(*Gtk::manage(static_cast<Gtk::Widget*>(hbox)),
true,
true);
870 box->set_position(200);
876 void StackBoxBuilder::openFlipLabelBox(
const char* label) {
878 box->set_homogeneous(
false);
880 box->set_border_width(0);
884 vbox->set_homogeneous(
false);
885 vbox->set_spacing(0);
886 vbox->set_border_width(0);
889 hbox->set_homogeneous(
false);
890 hbox->set_spacing(0);
891 hbox->set_border_width(0);
894 hbox->
m_label.set_name(
"effekt_label");
896 hbox->
m_label.set_size_request(15, -1);
898 Pango::FontDescription font = hbox->
m_label.get_style()->get_font();
899 font.set_size(8*Pango::SCALE);
900 font.set_weight(Pango::WEIGHT_BOLD);
901 hbox->
m_label.modify_font(font);
904 hbox->add(*manage(vbox));
905 box->add(*manage(hbox));
910 fBox.
push(fBox.
add(manage(box), label));
919 : Gtk::SpinButton(step,
precision(step)), adj(machine, id, get_adjustment()) {
920 get_adjustment()->signal_value_changed().connect(
925 void StackBoxBuilder::addNumEntry(
const std::string&
id,
const char* label_) {
926 Glib::ustring label(label_);
927 if (!machine.parameter_hasId(
id)) {
936 spinner->get_adjustment()->configure(
939 Gtk::HBox *box =
new Gtk::HBox(homogene, 0);
940 Gtk::Label *lab =
new Gtk::Label(label);
941 box->add(*manage(lab));
942 lab->set_name(
"rack_label");
943 fBox.add(manage(box), label);
944 fBox.add(manage(spinner), label);
950 const std::string id;
954 void set_value(
bool v);
958 : Gtk::ToggleButton(), machine(machine_), id(id_) {
960 sigc::mem_fun(
this, &Gtk::ToggleButton::set_active));
961 signal_toggled().connect(
969 void StackBoxBuilder::addMToggleButton(
const std::string&
id,
const char* label_) {
970 Glib::ustring label(label_);
978 Gdk::Color colorRed(
"#58b45e");
979 Gdk::Color colorOwn(
"#7f7f7f");
980 Gdk::Color colorwn(
"#000000");
982 Gtk::Label* lab =
new Gtk::Label(label);
983 Pango::FontDescription font = lab->get_style()->get_font();
984 font.set_weight(Pango::WEIGHT_BOLD);
985 lab->modify_font(font);
986 button->add(*manage(lab));
987 button->set_size_request(70, 20);
988 Gtk::Box* box =
new Gtk::HBox(homogene, 4);
989 Gtk::Box* box1 =
new Gtk::VBox(homogene, 4);
990 box->set_border_width(0);
991 box1->set_border_width(0);
992 box->add(*manage(box1));
993 Gtk::Box* box2 =
new Gtk::VBox(homogene, 4);
994 box2->set_border_width(0);
995 box2->set_size_request(6, 20);
996 box->add(*manage(button));
997 box->add(*manage(box2));
998 box1->set_size_request(6, 20);
1004 fBox.container_add(manage(box));
1005 button->modify_bg(Gtk::STATE_NORMAL, colorOwn);
1006 button->modify_bg(Gtk::STATE_ACTIVE, colorRed);
1007 lab->set_name(
"rack_label");
1014 const std::string& id;
1017 : Gtk::CheckButton(), machine(machine_), id(id_) {
1020 signal_toggled().connect(
1028 void StackBoxBuilder::addCheckButton(
const std::string&
id,
const char* label_) {
1029 if (!machine.parameter_hasId(
id)) {
1032 Glib::ustring label;
1033 if (label_ && label_[0]) {
1036 label = machine.get_parameter(
id).getBool().l_name();
1038 Gdk::Color colorRed(
"#000000");
1039 Gdk::Color colorOwn(
"#4c5159");
1040 Gdk::Color colorba(
"#c4c0c0");
1041 Gtk::Label *lab =
new Gtk::Label(label);
1043 button->add(*manage(lab));
1044 fBox.add(manage(button), label);
1045 button->modify_bg(Gtk::STATE_PRELIGHT, colorOwn);
1046 button->modify_fg(Gtk::STATE_PRELIGHT, colorRed);
1047 button->modify_text(Gtk::STATE_NORMAL, colorRed);
1048 button->modify_base(Gtk::STATE_NORMAL, colorba);
1049 Glib::RefPtr<Gtk::Style> style = lab->get_style();
1050 style->get_font().set_size(8*Pango::SCALE);
1051 style->get_font().set_weight(Pango::WEIGHT_NORMAL);
1052 lab->modify_font(style->get_font());
1057 void StackBoxBuilder::openHorizontalhideBox(
const char* label) {
1059 box->set_homogeneous(
false);
1060 box->set_spacing(0);
1061 box->set_border_width(0);
1062 fBox.box_pack_start(manage(box) ,
false,
false, 5);
1065 if (label[0] != 0) {
1070 void StackBoxBuilder::openHorizontalTableBox(
const char* label) {
1072 if (!fBox.top_is_notebook() && label && label[0]) {
1074 frame->set_label(label);
1075 frame->set_shadow_type(Gtk::SHADOW_NONE);
1076 frame->add(frame->
m_hbox);
1077 fBox.box_pack_start(manage(frame),
false);
1083 box =
new Gtk::HBox();
1084 fBox.push(fBox.add(manage(box), label));
1086 box->set_homogeneous(
false);
1087 box->set_spacing(1);
1088 box->set_border_width(0);
1091 void StackBoxBuilder::openPaintBox2(
const char* label) {
1094 box->set_homogeneous(
false);
1095 box->set_spacing(0);
1096 box->set_border_width(0);
1097 fBox.box_pack_start(manage(box),
false,
false);
1102 void StackBoxBuilder::openTabBox(
const char* label) {
1104 fBox.push(fBox.add(manage(box), label));
1107 void StackBoxBuilder::openpaintampBox(
const char* label) {
1109 box->
m_hbox.set_border_width(4);
1110 box->set_name(label);
1111 box->set_tooltip_text(label);
1112 fBox.box_pack_start(manage(box));
1117 void StackBoxBuilder::closeBox() {
1118 assert(!fBox.empty());
1122 void StackBoxBuilder::openHorizontalBox(
const char* label) {
1124 if (!fBox.top_is_notebook() && label && label[0]) {
1126 frame->set_label(label);
1127 frame->set_shadow_type(Gtk::SHADOW_NONE);
1128 frame->add(frame->
m_hbox);
1129 fBox.box_pack_start(manage(frame),
false);
1135 box =
new Gtk::HBox();
1136 fBox.push(fBox.add(manage(box), label));
1138 box->set_homogeneous(
false);
1139 box->set_spacing(1);
1140 box->set_border_width(0);
1143 void StackBoxBuilder::openVerticalBox(
const char* label) {
1145 box->set_homogeneous(
false);
1146 box->set_spacing(1);
1147 box->set_border_width(0);
1149 if (!fBox.top_is_notebook() && label && label[0]) {
1151 box->
m_label.set_name(
"rack_effect_label");
1152 Glib::RefPtr<Gtk::Style> style = box->
m_label.get_style();
1153 style->get_font().set_size(8*Pango::SCALE);
1154 style->get_font().set_weight(Pango::WEIGHT_BOLD);
1155 box->
m_label.modify_font(style->get_font());
1156 box->pack_start(box->
m_label,
false,
false, 0 );
1157 fBox.box_pack_start(manage(box),
false);
1162 fBox.push(fBox.add(manage(box), label));
1166 void StackBoxBuilder::openFrameBox(
const char* label) {
1169 if (!fBox.top_is_notebook() && label && label[0]) {
1171 frame->set_label(label);
1172 frame->set_shadow_type(Gtk::SHADOW_NONE);
1173 frame->add(frame->
m_hbox);
1174 fBox.box_pack_start(manage(frame),
false);
1180 box =
new Gtk::HBox();
1181 fBox.push(fBox.add(manage(box), label));
1183 box->set_homogeneous(
false);
1184 box->set_spacing(1);
1185 box->set_border_width(2);
static Gtk::Widget * create(gx_engine::GxMachineBase &machine, const char *sw_type, const std::string &id, const char *label)
static Gtk::Widget * create(gx_engine::GxMachineBase &machine, const char *sw_type, const std::string &id, const char *label)
virtual float getUpperAsFloat() const
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)
const char * pb_gxhead_expose
void make_rackbox_oscilloscope()
void wnotify(gpointer data, GObject *where_the_object_was)
std::string get_builder_filepath(const std::string &basename) const
void set_rack_label_inverse()
void set_rack_label_inverse()
const char * pb_zac_expose
void get_box(const std::string &name, Gtk::Widget *&mainbox, Gtk::Widget *&minibox)
virtual Parameter & get_parameter(const std::string &id)=0
void make_rackbox_sequencer()
static UiSwitch * create(gx_engine::GxMachineBase &machine, const char *sw_type, gx_engine::Parameter ¶m)
#define UI_NUM_POSITION_MASK
virtual gx_jack::GxJack * get_jack()=0
void set_c_level(double lvl)
virtual float getLowerAsFloat() const
const char * pb_gx_rack_amp_expose
void make_rackbox_jconv()
const std::string & get_loop_dir() const
void set_label(const char *label)
sigc::signal< void, const GxJConvSettings * > & signal_changed()
void make_rackbox_midi_out()
const Glib::ustring & get_rpcaddress()
void gx_print_error(const char *, const std::string &)
sigc::signal< void, float > & signal_changed_float()
void cp_set_value(double value)
void set_rack_label(const char *label)
T get_parameter_value(const std::string &id)
const char * pb_RackBox_expose
virtual bool parameter_hasId(const char *p)=0
const std::string & getIRFile() const
virtual void set_parameter_value(const std::string &id, int value)=0
const char * pb_level_meter_expose
void set_state(int cutoff_low, int cutoff_high)
std::string to_string(const T &t)
void connect_midi_controller(Gtk::Widget *w, const std::string &id, gx_engine::GxMachineBase &machine)
void set_rack_label_inverse(const char *label)
void set_value_position(Gtk::PositionType p1)
void set_hold_count(int val)
FloatParameter & getFloat()
virtual gx_system::CmdlineOptions & get_options() const =0
virtual float getStepAsFloat() const
struct _GxPaintBox GxPaintBox
const GxJConvSettings & get_value() const
bool button_press_cb(GdkEventButton *event, gx_engine::GxMachineBase &machine, const std::string &id)
void set_by_power(double lvl)
const char * pb_rectangle_skin_color_expose
uiSpinner(float step, gx_engine::GxMachineBase &machine, const std::string &id)
void trace_finalize(Glib::Object *o, int n)
void set_rack_label_inverse()
const char * pb_gxrack_expose
void fetch(Gtk::Widget *&mainbox, Gtk::Widget *&minibox)
virtual bool midi_get_config_mode(int *ctl=0)=0
sigc::signal< void, T > & signal_parameter_value(const std::string &id)
BoolParameter & getBool()
std::string fformat(float value, float step)
void make_rackbox_jconv_mono()
#define UI_NUM_SHOW_ALWAYS