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);
151 mainbox = minibox = 0;
152 for (
unsigned int i = 0; i <
sizeof(mapping) /
sizeof(mapping[0]); ++i) {
153 if (name == mapping[i].name) {
155 (this->*mapping[i].func)();
156 fetch(mainbox, minibox);
161 void StackBoxBuilder::loadRackFromBuilder(
const Glib::RefPtr<GxBuilder>& bld) {
162 if (!bld->has_object(
"rackbox")) {
167 if (bld->has_object(
"minibox")) {
168 bld->find_widget(
"minibox", w);
171 bld->find_widget(
"rackbox", w);
177 for (
int i = 1; i<12;++i) {
179 if (bld->has_object(fm)) {
181 bld->find_widget(fm, fastmeter);
182 fastmeter->get_property(
"var_id",
id);
183 fastmeter->set_name(
"simplemeter");
185 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
186 sigc::mem_fun(*
this, &StackBoxBuilder::set_simple),
id), fastmeter), 60);
192 for (
int i = 1; i<12;++i) {
194 if (bld->has_object(fm)) {
196 bld->find_widget(fm, fastmeter);
197 fastmeter->get_property(
"var_id",
id);
200 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
201 sigc::mem_fun(*
this, &StackBoxBuilder::set_simple),
id), fastmeter), 60);
207 for (
int i = 1; i<12;++i) {
209 if (bld->has_object(fm)) {
211 bld->find_widget(fm, fastmeter);
212 fastmeter->get_property(
"var_id",
id);
213 fastmeter->set_name(
"simplemeter");
215 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
216 sigc::mem_fun(*
this, &StackBoxBuilder::set_compressor_level),
id), fastmeter), 60);
224 for (
int i = 1; i<12;++i) {
226 if (bld->has_object(fm)) {
228 bld->find_widget(fm, sw);
229 sw->get_property(
"var_id",
id);
230 sw->set_name(
"effect_on_off");
232 Glib::signal_timeout().connect(sigc::bind<Gxw::Switch*>(sigc::bind<const std::string>(
233 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_cp_value),
id),sw), 60);
241 for (
int i = 1; i<12;++i) {
243 if (bld->has_object(fm)) {
245 bld->find_widget(fm, regler);
246 regler->get_property(
"var_id",
id);
248 Glib::signal_timeout().connect(sigc::bind<Gxw::Regler*>(sigc::bind<const std::string>(
249 sigc::mem_fun(*
this, &StackBoxBuilder::set_regler_cp_value),
id),regler), 60);
256 static const char *rackbox_ids[] = {
"rackbox",
"minibox", 0 };
258 void StackBoxBuilder::loadRackFromGladeFile(
const char *fname) {
260 GxBuilder::create_from_file(
264 void StackBoxBuilder::loadRackFromGladeData(
const char *xmldesc) {
265 loadRackFromBuilder(GxBuilder::create_from_string(xmldesc, &machine, rackbox_ids));
268 void StackBoxBuilder::addwidget(Gtk::Widget *widget) {
275 void StackBoxBuilder::addSmallJConvFavButton(
const char* label,
gx_jconv::IRWindow *irw) {
276 Gtk::Button *button =
new Gtk::Button();
277 button->set_name(
"smallbutton");
278 Gtk::Label *lab =
new Gtk::Label(label);
279 Pango::FontDescription font = lab->get_style()->get_font();
280 font.set_size(7*Pango::SCALE);
281 font.set_weight(Pango::WEIGHT_NORMAL);
282 lab->modify_font(font);
283 button->add(*manage(lab));
285 lab->set_padding(5,0);
286 fBox.
add(manage(button), label);
288 button->signal_clicked().connect(
293 convolver_filename_label.set_label(jcs->
getIRFile());
297 convolver_mono_filename_label.set_label(jcs->
getIRFile());
300 void StackBoxBuilder::openSetLabelBox() {
301 Gtk::VBox *box =
new Gtk::VBox();
302 box->set_homogeneous(
false);
304 box->set_border_width(0);
305 convolver_filename_label.set_name(
"rack_label");
306 Pango::FontDescription font = convolver_filename_label.get_style()->get_font();
307 font.set_size(8*Pango::SCALE);
308 font.set_weight(Pango::WEIGHT_BOLD);
309 convolver_filename_label.modify_font(font);
310 box->pack_start(convolver_filename_label,
false,
false, 0);
316 sigc::mem_fun(*
this, &StackBoxBuilder::set_convolver_filename));
321 void StackBoxBuilder::openSetMonoLabelBox() {
322 Gtk::VBox *box =
new Gtk::VBox();
323 box->set_homogeneous(
false);
325 box->set_border_width(0);
326 convolver_mono_filename_label.set_name(
"rack_label");
327 Pango::FontDescription font = convolver_mono_filename_label.get_style()->get_font();
328 font.set_size(8*Pango::SCALE);
329 font.set_weight(Pango::WEIGHT_BOLD);
330 convolver_mono_filename_label.modify_font(font);
331 box->pack_start(convolver_mono_filename_label,
true,
false, 0);
337 sigc::mem_fun(*
this, &StackBoxBuilder::set_convolver_mono_filename));
343 Gtk::Button *button =
new Gtk::Button();
344 button->set_can_default(
false);
345 button->set_can_focus(
false);
346 Gtk::Label *lab =
new Gtk::Label(label);
351 button->add(*manage(lab));
353 Gtk::Alignment *al =
new Gtk::Alignment(0.0, 0.5, 0.0, 0.0);
354 al->add(*manage(button));
357 button->signal_clicked().connect(
361 void StackBoxBuilder::set_next_flags(
int flags) {
365 bool StackBoxBuilder::set_simple(
Gxw::FastMeter *fastmeter,
const std::string
id) {
377 bool StackBoxBuilder::set_compressor_level(
Gxw::FastMeter *fastmeter,
const std::string
id) {
389 void StackBoxBuilder::create_simple_meter(
const std::string&
id) {
392 fastmeter->set_property(
"dimen",2);
393 fastmeter->set_property(
"type",0);
394 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
395 sigc::mem_fun(*
this, &StackBoxBuilder::set_simple),
id), fastmeter), 60);
397 Gtk::HBox *box =
new Gtk::HBox();
398 box->set_border_width(2);
399 box->pack_start(*Gtk::manage(static_cast<Gtk::Widget*>(fastmeter)),Gtk::PACK_SHRINK);
404 void StackBoxBuilder::create_simple_c_meter(
const std::string&
id,
const std::string& idm,
const char *label) {
407 fastmeter->set_property(
"dimen",2);
408 fastmeter->set_property(
"type",0);
409 fastmeter->set_name(
"simplemeter");
410 Glib::signal_timeout().connect(sigc::bind<Gxw::FastMeter*>(sigc::bind<const std::string>(
411 sigc::mem_fun(*
this, &StackBoxBuilder::set_simple),
id), fastmeter), 60);
416 box->set_border_width(2);
417 box->pack_start(*Gtk::manage(static_cast<Gtk::Widget*>(fastmeter)),Gtk::PACK_SHRINK);
418 box->add(*Gtk::manage(static_cast<Gtk::Widget*>(w)));
419 if (label && label[0]) {
420 Gtk::VBox *boxv =
new Gtk::VBox();
422 boxv->set_homogeneous(
false);
423 boxv->set_spacing(0);
425 Gtk::Label *lab =
new Gtk::Label(label);
426 Pango::FontDescription font = lab->get_style()->get_font();
427 font.set_size(6*Pango::SCALE);
428 font.set_weight(Pango::WEIGHT_NORMAL);
429 lab->modify_font(font);
430 lab->set_name(
"beffekt_label");
431 boxv->add(*manage(lab));
432 boxv->add(*manage(box));
441 bool StackBoxBuilder::set_regler_cp_value(
Gxw::Regler * regler,
const std::string
id) {
451 bool StackBoxBuilder::set_engine_cp_value(
Gxw::Switch * sw,
const std::string
id) {
461 bool StackBoxBuilder::set_engine_value(
const std::string
id) {
471 void StackBoxBuilder::create_port_display(
const std::string&
id,
const char *label) {
473 Glib::signal_timeout().connect(sigc::bind<const std::string>(
474 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
483 bool StackBoxBuilder::set_pd_value(
Gxw::PortDisplay *w,
const std::string
id,
const std::string& idl,
const std::string& idh) {
489 float set = (low + high)*0.001;
498 void StackBoxBuilder::create_p_display(
const std::string&
id,
const std::string& idl,
const std::string& idh) {
500 w->set_name(
"playhead");
501 Gtk::EventBox* e_box =
new Gtk::EventBox();
502 e_box->set_size_request(-1, -1);
503 e_box->set_border_width(0);
504 e_box->set_visible_window(
true);
505 e_box->set_above_child(
true);
506 e_box->add(*manage(static_cast<Gtk::Widget*>(w)));
509 Glib::signal_timeout().connect(sigc::bind<Gxw::PortDisplay*>(sigc::bind<const std::string>(
510 sigc::bind<const std::string>(sigc::bind<const std::string>(
511 sigc::mem_fun(*
this, &StackBoxBuilder::set_pd_value),idh),idl),
id),w ), 60);
514 void StackBoxBuilder::create_feedback_switch(
const char *sw_type,
const std::string&
id) {
518 regler->set_name(
"effect_on_off");
520 Glib::signal_timeout().connect(sigc::bind<const std::string>(
521 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
524 void StackBoxBuilder::load_file(
const std::string&
id,
const std::string& idf) {
525 static Glib::ustring recent_filename =
"";
526 static Glib::ustring hostname =
"localhost";
528 hostname = Gio::Resolver::get_default()->lookup_by_address
535 Glib::ustring title = hostname +
": Select loop file";
536 Gtk::FileChooserDialog d( title);
537 d.set_local_only(
false);
538 d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
539 d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
541 d.add_shortcut_folder_uri(Glib::filename_to_uri(loop_dir, hostname));
543 wav.set_name(
"WAV Files");
544 wav.add_mime_type(
"audio/x-vorbis+ogg");
545 wav.add_mime_type(
"audio/x-wav");
546 wav.add_pattern(
"*.ogg");
547 wav.add_pattern(
"*.wav");
548 wav.add_pattern(
"*.WAV");
549 wav.add_pattern(
"*.Wav");
551 Gtk::FileFilter audio;
552 audio.set_name(
"Audio Files");
553 audio.add_mime_type(
"audio/*");
556 all.add_pattern(
"*");
557 all.set_name(
"All Files");
559 if (!recent_filename.empty()) {
560 d.set_uri(Glib::filename_to_uri (recent_filename, hostname));
561 }
else if ((filename.find(
"tape") != Glib::ustring::npos) && (!filename.empty())) {
562 d.set_uri(Glib::filename_to_uri (loop_dir + filename +
string(
".wav"), hostname));
564 d.set_current_folder_uri(Glib::filename_to_uri (loop_dir, hostname));
566 if (d.run() != Gtk::RESPONSE_OK) {
571 filename = Glib::filename_from_uri(d.get_uri(), hostname);
572 recent_filename = filename;
573 Gtk::RecentManager::Data data;
574 bool result_uncertain;
575 data.mime_type = Gio::content_type_guess(filename,
"", result_uncertain);
576 data.app_name =
"guitarix";
577 data.groups.push_back(
"loopfiles");
578 Gtk::RecentManager::get_default()->add_item(d.get_uri(), data);
587 void StackBoxBuilder::load_file_f(
const std::string&
id,
const std::string& idf) {
588 Glib::signal_timeout().connect_once(
589 sigc::bind<const std::string>(sigc::bind<const std::string>(sigc::mem_fun(
this, &StackBoxBuilder::load_file), idf),
id),100);
592 void StackBoxBuilder::create_fload_switch(
const char *sw_type,
const std::string&
id,
const std::string& idf) {
597 regler->set_name(
"effect_on_off");
601 sigc::bind<const std::string>(sigc::bind<const std::string>(sigc::mem_fun(
this, &StackBoxBuilder::load_file_f), idf),
id)));
605 void StackBoxBuilder::create_h_switch(
const char *sw_type,
const std::string&
id,
const char *label) {
616 void StackBoxBuilder::create_v_switch(
const char *sw_type,
const std::string&
id,
const char *label) {
627 void StackBoxBuilder::create_feedback_slider(
const std::string&
id,
const char *label) {
629 Glib::signal_timeout().connect(sigc::bind<const std::string>(
630 sigc::mem_fun(*
this, &StackBoxBuilder::set_engine_value),
id), 60);
635 void StackBoxBuilder::create_selector(
const std::string&
id,
const char *widget_name) {
644 s->set_name(widget_name);
649 void StackBoxBuilder::create_selector_with_caption(
const std::string&
id,
const char *label) {
670 void StackBoxBuilder::openSpaceBox(
const char* label) {
672 box->set_homogeneous(
true);
674 box->set_border_width(4);
680 fBox.
push(fBox.
add(manage(box), label));
684 void StackBoxBuilder::check_set_flags(
Gxw::Regler *r) {
686 r->set_name(
"show_always");
689 Gtk::PositionType pos = Gtk::POS_BOTTOM;
690 switch (next_flags & UI_NUM_POSITION_MASK) {
699 void StackBoxBuilder::create_mid_rackknob(
const std::string&
id,
const char *label) {
710 void StackBoxBuilder::create_small_rackknob(
const std::string&
id,
const char *label) {
721 void StackBoxBuilder::create_small_rackknobr(
const std::string&
id,
const char *label) {
732 void StackBoxBuilder::create_big_rackknob(
const std::string&
id,
const char *label) {
743 void StackBoxBuilder::addLiveWaveDisplay(
const char* label) {
744 Gtk::HBox * box =
new Gtk::HBox(
false, 4);
745 Gtk::VBox * box1 =
new Gtk::VBox(
false, 0);
746 Gtk::VBox * box2 =
new Gtk::VBox(
false, 0);
747 Gtk::EventBox* e_box =
new Gtk::EventBox();
750 e_box->set_size_request(284, 84);
752 e_box->add(fWaveView);
753 box->pack_start(*manage(box1),
true,
true, 0);
754 box->pack_start(*manage(e_box),
false,
false, 0);
755 box->pack_start(*manage(box2),
true,
true, 0);
756 fBox.
add(manage(box), label);
758 fWaveView.property_text_pos_left() = 1.5;
759 fWaveView.property_text_pos_right() = 77;
764 void StackBoxBuilder::openVerticalBox1(
const char* label) {
766 box->set_homogeneous(
false);
768 box->set_border_width(0);
772 box->
m_label.set_name(
"effekt_label");
773 box->pack_start(box->
m_label,
false,
false, 0 );
779 fBox.
push(fBox.
add(manage(box), label));
783 void StackBoxBuilder::openVerticalBox2(
const char* label) {
784 Gtk::VPaned * box =
new Gtk::VPaned();
785 box->set_border_width(0);
789 pbox->
m_label.set_name(
"rack_label");
790 pbox->pack_start(pbox->
m_label,
false,
false, 0 );
792 pbox->set_border_width(0);
793 box->pack1(*Gtk::manage(static_cast<Gtk::Widget*>(pbox)),
true,
true);
795 hbox->set_homogeneous(
false);
796 hbox->set_spacing(1);
797 hbox->set_border_width(0);
798 box->pack2(*Gtk::manage(static_cast<Gtk::Widget*>(hbox)),
true,
true);
799 box->set_position(200);
805 void StackBoxBuilder::openFlipLabelBox(
const char* label) {
807 box->set_homogeneous(
false);
809 box->set_border_width(0);
813 vbox->set_homogeneous(
false);
814 vbox->set_spacing(0);
815 vbox->set_border_width(0);
818 hbox->set_homogeneous(
false);
819 hbox->set_spacing(0);
820 hbox->set_border_width(0);
823 hbox->
m_label.set_name(
"effekt_label");
825 hbox->
m_label.set_size_request(15, -1);
827 Pango::FontDescription font = hbox->
m_label.get_style()->get_font();
828 font.set_size(8*Pango::SCALE);
829 font.set_weight(Pango::WEIGHT_BOLD);
830 hbox->
m_label.modify_font(font);
833 hbox->add(*manage(vbox));
834 box->add(*manage(hbox));
839 fBox.
push(fBox.
add(manage(box), label));
848 : Gtk::SpinButton(step,
precision(step)), adj(machine, id, get_adjustment()) {
849 get_adjustment()->signal_value_changed().connect(
854 void StackBoxBuilder::addNumEntry(
const std::string&
id,
const char* label_) {
855 Glib::ustring label(label_);
856 if (!machine.parameter_hasId(
id)) {
865 spinner->get_adjustment()->configure(
868 Gtk::HBox *box =
new Gtk::HBox(homogene, 0);
869 Gtk::Label *lab =
new Gtk::Label(label);
870 box->add(*manage(lab));
871 lab->set_name(
"rack_label");
872 fBox.add(manage(box), label);
873 fBox.add(manage(spinner), label);
879 const std::string id;
883 void set_value(
bool v);
887 : Gtk::ToggleButton(), machine(machine_), id(id_) {
889 sigc::mem_fun(
this, &Gtk::ToggleButton::set_active));
890 signal_toggled().connect(
898 void StackBoxBuilder::addMToggleButton(
const std::string&
id,
const char* label_) {
899 Glib::ustring label(label_);
907 Gdk::Color colorRed(
"#58b45e");
908 Gdk::Color colorOwn(
"#7f7f7f");
909 Gdk::Color colorwn(
"#000000");
911 Gtk::Label* lab =
new Gtk::Label(label);
912 Pango::FontDescription font = lab->get_style()->get_font();
913 font.set_weight(Pango::WEIGHT_BOLD);
914 lab->modify_font(font);
915 button->add(*manage(lab));
916 button->set_size_request(70, 20);
917 Gtk::Box* box =
new Gtk::HBox(homogene, 4);
918 Gtk::Box* box1 =
new Gtk::VBox(homogene, 4);
919 box->set_border_width(0);
920 box1->set_border_width(0);
921 box->add(*manage(box1));
922 Gtk::Box* box2 =
new Gtk::VBox(homogene, 4);
923 box2->set_border_width(0);
924 box2->set_size_request(6, 20);
925 box->add(*manage(button));
926 box->add(*manage(box2));
927 box1->set_size_request(6, 20);
933 fBox.container_add(manage(box));
934 button->modify_bg(Gtk::STATE_NORMAL, colorOwn);
935 button->modify_bg(Gtk::STATE_ACTIVE, colorRed);
936 lab->set_name(
"rack_label");
943 const std::string& id;
946 : Gtk::CheckButton(), machine(machine_), id(id_) {
949 signal_toggled().connect(
957 void StackBoxBuilder::addCheckButton(
const std::string&
id,
const char* label_) {
958 if (!machine.parameter_hasId(
id)) {
962 if (label_ && label_[0]) {
965 label = machine.get_parameter(
id).getBool().l_name();
967 Gdk::Color colorRed(
"#000000");
968 Gdk::Color colorOwn(
"#4c5159");
969 Gdk::Color colorba(
"#c4c0c0");
970 Gtk::Label *lab =
new Gtk::Label(label);
972 button->add(*manage(lab));
973 fBox.add(manage(button), label);
974 button->modify_bg(Gtk::STATE_PRELIGHT, colorOwn);
975 button->modify_fg(Gtk::STATE_PRELIGHT, colorRed);
976 button->modify_text(Gtk::STATE_NORMAL, colorRed);
977 button->modify_base(Gtk::STATE_NORMAL, colorba);
978 Glib::RefPtr<Gtk::Style> style = lab->get_style();
979 style->get_font().set_size(8*Pango::SCALE);
980 style->get_font().set_weight(Pango::WEIGHT_NORMAL);
981 lab->modify_font(style->get_font());
986 void StackBoxBuilder::openHorizontalhideBox(
const char* label) {
988 box->set_homogeneous(
false);
990 box->set_border_width(0);
991 fBox.box_pack_start(manage(box) ,
false,
false, 5);
999 void StackBoxBuilder::openHorizontalTableBox(
const char* label) {
1001 if (!fBox.top_is_notebook() && label && label[0]) {
1003 frame->set_label(label);
1004 frame->set_shadow_type(Gtk::SHADOW_NONE);
1005 frame->add(frame->
m_hbox);
1006 fBox.box_pack_start(manage(frame),
false);
1012 box =
new Gtk::HBox();
1013 fBox.push(fBox.add(manage(box), label));
1015 box->set_homogeneous(
false);
1016 box->set_spacing(1);
1017 box->set_border_width(0);
1020 void StackBoxBuilder::openPaintBox2(
const char* label) {
1023 box->set_homogeneous(
false);
1024 box->set_spacing(0);
1025 box->set_border_width(0);
1026 fBox.box_pack_start(manage(box),
false,
false);
1031 void StackBoxBuilder::openTabBox(
const char* label) {
1033 fBox.push(fBox.add(manage(box), label));
1036 void StackBoxBuilder::openpaintampBox(
const char* label) {
1038 box->
m_hbox.set_border_width(4);
1039 box->set_name(label);
1040 box->set_tooltip_text(label);
1041 fBox.box_pack_start(manage(box));
1046 void StackBoxBuilder::closeBox() {
1047 assert(!fBox.empty());
1051 void StackBoxBuilder::openHorizontalBox(
const char* label) {
1053 if (!fBox.top_is_notebook() && label && label[0]) {
1055 frame->set_label(label);
1056 frame->set_shadow_type(Gtk::SHADOW_NONE);
1057 frame->add(frame->
m_hbox);
1058 fBox.box_pack_start(manage(frame),
false);
1064 box =
new Gtk::HBox();
1065 fBox.push(fBox.add(manage(box), label));
1067 box->set_homogeneous(
false);
1068 box->set_spacing(1);
1069 box->set_border_width(0);
1072 void StackBoxBuilder::openVerticalBox(
const char* label) {
1074 box->set_homogeneous(
false);
1075 box->set_spacing(1);
1076 box->set_border_width(0);
1078 if (!fBox.top_is_notebook() && label && label[0]) {
1080 box->
m_label.set_name(
"rack_effect_label");
1081 Glib::RefPtr<Gtk::Style> style = box->
m_label.get_style();
1082 style->get_font().set_size(8*Pango::SCALE);
1083 style->get_font().set_weight(Pango::WEIGHT_BOLD);
1084 box->
m_label.modify_font(style->get_font());
1085 box->pack_start(box->
m_label,
false,
false, 0 );
1086 fBox.box_pack_start(manage(box),
false);
1091 fBox.push(fBox.add(manage(box), label));
1095 void StackBoxBuilder::openFrameBox(
const char* label) {
1098 if (!fBox.top_is_notebook() && label && label[0]) {
1100 frame->set_label(label);
1101 frame->set_shadow_type(Gtk::SHADOW_NONE);
1102 frame->add(frame->
m_hbox);
1103 fBox.box_pack_start(manage(frame),
false);
1109 box =
new Gtk::HBox();
1110 fBox.push(fBox.add(manage(box), label));
1112 box->set_homogeneous(
false);
1113 box->set_spacing(1);
1114 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
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