Widget::Widget(Glib::ustring plugname):
plug_name(plugname)
{
// create controllers for port name
Glib::ustring modes[] = {"linear","ping pong"};
static const size_t _size = sizeof(modes) / sizeof(modes[0]);
make_selector("Delay Mode", modes, _size, 0, 1.0, INVERT);
make_controller_box(&m_vbox2, "Time (R)", 1, 5000, 10, R_DELAY);
make_controller_box(&m_vbox3, "Time (L)", 1, 5000, 10, L_DELAY);
make_controller_box(&m_vbox4, "LFO", 0.2, 5, 0.01, LFOFREQ);
m_vbox4.pack_start(m_selector, Gtk::PACK_SHRINK);
make_controller_box(&m_vbox5, "Level (R)", -20, 20, 0.1, R_GAIN);
make_controller_box(&m_vbox6, "Level (L)", -20, 20, 0.1, L_GAIN);
make_switch_box(&m_vbox7, "Link (L+R)", LINK);
// set propertys for the main paintbox holding the skin
m_paintbox.set_border_width(10);
m_paintbox.set_spacing(6);
m_paintbox.set_homogeneous(false);
m_paintbox.set_name(plug_name);
m_paintbox.property_paint_func() = "gxhead_expose";
add(m_paintbox);
// box for the controllers
m_hbox_.set_spacing(14);
m_hbox_.set_border_width(24);
m_hbox_.set_homogeneous(false);
// set a vertical box in the paintbox
m_vbox.set_border_width(14);
m_vbox1.set_border_width(14);
m_paintbox.pack_start(m_vbox_);
// and controller box on top
m_vbox_.pack_start(m_hbox_, Gtk::PACK_SHRINK);
// put boxed controllers into controller box
m_hbox_.pack_start(m_vbox1, Gtk::PACK_EXPAND_PADDING);
m_hbox_.pack_start(m_vbox3);
m_hbox_.pack_start(m_vbox6);
m_hbox_.pack_start(m_vbox4);
m_hbox_.pack_start(m_vbox5);
m_hbox_.pack_start(m_vbox2);
m_hbox_.pack_start(m_vbox7);
m_hbox_.pack_start(m_vbox, Gtk::PACK_EXPAND_PADDING);
// connect expose handler as resize handler
m_paintbox.signal_expose_event().connect(
sigc::mem_fun(this, &Widget::_expose_event), true);
set_app_paintable(true);
show_all();
}
void test_tasks(void) {
def_task = task_current();
#if 0
task_kthread_init(&task0, (void *)do_task0,
(void *)((ptr_t)task0_stack + TASK_KERNSTACK_SIZE - 0x20));
task_kthread_init(&task1, (void *)do_task1,
(void *)((ptr_t)task1_stack + TASK_KERNSTACK_SIZE - 0x20));
#else
const segment_selector ucs = { .as.word = SEL_USER_CS };
const segment_selector uds = { .as.word = SEL_USER_DS };
uint espU0 = ((uint)task0_usr_stack + R3_STACK_SIZE - 0x18);
uint espK0 = ((uint)task0_stack + TASK_KERNSTACK_SIZE - CONTEXT_SIZE - 0x14);
uint espU1 = ((ptr_t)task1_usr_stack + R3_STACK_SIZE);
uint espK1 = ((ptr_t)task1_stack + TASK_KERNSTACK_SIZE - CONTEXT_SIZE - 0x14);
task_init((task_struct *)&task0, (void *)do_task0,
(void *)espK0, (void *)espU0, ucs, uds);
task_init((task_struct *)&task1, (void *)do_task1,
(void *)espK1, (void *)espU1, ucs, uds);
#endif
/* allow tasks to update cursor with `outl` */
task0.tss.eflags |= eflags_iopl(PL_USER);
task1.tss.eflags |= eflags_iopl(PL_USER);
quit = false;
kbd_set_onpress((kbd_event_f)key_press);
task_set_scheduler(next_task);
/* wait for first timer tick, when execution will be transferred to do_task0 */
cpu_halt();
task_set_scheduler(null);
kbd_set_onpress(null);
k_printf("\nBye.\n");
}
/***********************************************************/
void run_userspace(void) {
char buf[100];
snprintf(buf, 100, "Current privilege level = %d\n", i386_current_privlevel());
size_t nbuf = strlen(buf);
asm("int $0x80 \n" ::
"a"(SYS_WRITE),
"c"(STDOUT_FILENO),
"d"((uint)buf),
"b"(nbuf));
while (1);
}
extern void start_userspace(uint eip3, uint cs3, uint eflags, uint esp3, uint ss3);
task_struct task3;
void test_userspace(void) {
/* init task */
task3.tss.eflags = x86_eflags(); // | eflags_iopl(PL_USER);
task3.tss.cs = SEL_USER_CS;
task3.tss.ds = task3.tss.es = task3.tss.fs = task3.tss.gs = SEL_USER_DS;
task3.tss.ss = SEL_USER_DS;
task3.tss.esp = (uint)task0_usr_stack + R3_STACK_SIZE - CONTEXT_SIZE - 0x20;
task3.tss.eip = (uint)run_userspace;
task3.tss.ss0 = SEL_KERN_DS;
task3.tss.esp0 = (uint)task0_stack + R0_STACK_SIZE - CONTEXT_SIZE - 0x20;
/* make a GDT task descriptor */
segment_descriptor taskdescr;
segdescr_taskstate_init(taskdescr, (uint)&(task3.tss), PL_USER);
segdescr_taskstate_busy(taskdescr, 0);
index_t taskdescr_index = gdt_alloc_entry(taskdescr);
segment_selector tss_sel;
tss_sel.as.word = make_selector(taskdescr_index, 0, taskdescr.as.strct.dpl);
kbd_set_onpress((kbd_event_f)key_press);
uint efl = 0x00203202;
test_eflags();
logmsgf("efl = 0x%x\n", efl);
logmsgf("tss_sel = 0x%x\n", (uint)tss_sel.as.word);
logmsgf("tssd = %x %x\n", taskdescr.as.ints[0], taskdescr.as.ints[1]);
logmsgf("tssd.base = %x\n", taskdescr.as.strct.base_l +
(taskdescr.as.strct.base_m << 16) + (taskdescr.as.strct.base_h << 24));
/* load TR and LDT */
i386_load_task_reg(tss_sel);
//asm ("lldt %%ax \n\t"::"a"( SEL_DEF_LDT ));
/* go userspace */
start_userspace(
(uint)run_userspace, task3.tss.cs,
//(uint)run_userspace, (uint)tss_sel.as.word,
efl,
task3.tss.esp, task3.tss.ss);
}
Widget::Widget(Glib::ustring plugname):
plug_name(plugname)
{
m_fr[0].set_label("BAND 1");
m_fr[0].add(m_lbox[0]);
m_fr[1].set_label("BAND 2");
m_fr[1].add(m_lbox[1]);
m_fr[2].set_label("BAND 3");
m_fr[2].add(m_lbox[2]);
m_fr[3].set_label("BAND 4");
m_fr[3].add(m_lbox[3]);
m_fr[4].set_label("BAND 5");
m_fr[4].add(m_lbox[4]);
m_fr[5].set_label("BAND PASS");
// create controllers for port name
make_controller_box(&m_vbox[1], "RATIO ",
"Compression ratio", 1.0, 1e+02, 0.1, RATIO1, false);
make_controller_box(&m_vbox[2], "RATIO ",
"Compression ratio", 1.0, 1e+02, 0.1, RATIO2, false);
make_controller_box(&m_vbox[3], "RATIO ",
"Compression ratio", 1.0, 1e+02, 0.1, RATIO3, false);
make_controller_box(&m_vbox[4], "RATIO ",
"Compression ratio", 1.0, 1e+02, 0.1, RATIO4, false);
make_controller_box(&m_vbox[5], "RATIO ",
"Compression ratio", 1.0, 1e+02, 0.1, RATIO5, false);
make_controller_box(&m_vbox[1], "ATTACK ",
"Time before the compressor starts to kick in", 0.001, 1.0, 0.001, ATTACK1, false);
make_controller_box(&m_vbox[2], "ATTACK ",
"Time before the compressor starts to kick in", 0.001, 1.0, 0.001, ATTACK2, false);
make_controller_box(&m_vbox[3], "ATTACK ",
"Time before the compressor starts to kick in", 0.001, 1.0, 0.001, ATTACK3, false);
make_controller_box(&m_vbox[4], "ATTACK ",
"Time before the compressor starts to kick in", 0.001, 1.0, 0.001, ATTACK4, false);
make_controller_box(&m_vbox[5], "ATTACK ",
"Time before the compressor starts to kick in", 0.001, 1.0, 0.001, ATTACK5, false);
make_controller_box(&m_vbox[1], "RELEASE ",
"Time before the compressor releases the sound", 0.01, 1e+01, 0.01, RELEASE1, false);
make_controller_box(&m_vbox[2], "RELEASE ",
"Time before the compressor releases the sound", 0.01, 1e+01, 0.01, RELEASE2, false);
make_controller_box(&m_vbox[3], "RELEASE ",
"Time before the compressor releases the sound", 0.01, 1e+01, 0.01, RELEASE3, false);
make_controller_box(&m_vbox[4], "RELEASE ",
"Time before the compressor releases the sound", 0.01, 1e+01, 0.01, RELEASE4, false);
make_controller_box(&m_vbox[5], "RELEASE ",
"Time before the compressor releases the sound", 0.01, 1e+01, 0.01, RELEASE5, false);
make_controller_box(&m_vbox[1], "MAKEUP",
"Post amplification and threshold", -5e+01, 5e+01, 0.1, MAKEUP1, false);
make_controller_box(&m_vbox[2], "MAKEUP",
"Post amplification and threshold", -5e+01, 5e+01, 0.1, MAKEUP2, false);
make_controller_box(&m_vbox[3], "MAKEUP",
"Post amplification and threshold", -5e+01, 5e+01, 0.1, MAKEUP3, false);
make_controller_box(&m_vbox[4], "MAKEUP",
"Post amplification and threshold", -5e+01, 5e+01, 0.1, MAKEUP4, false);
make_controller_box(&m_vbox[5], "MAKEUP",
"Post amplification and threshold", -5e+01, 5e+01, 0.1, MAKEUP5, false);
make_controller_box(&m_vbox[1], "THRESHOLD ",
"Threshold correction, an anticlip measure", 0.0, 1e+01, 0.1, MAKEUPTHRESHOLD1, false);
make_controller_box(&m_vbox[2], "THRESHOLD ",
"Threshold correction, an anticlip measure", 0.0, 1e+01, 0.1, MAKEUPTHRESHOLD2, false);
make_controller_box(&m_vbox[3], "THRESHOLD ",
"Threshold correction, an anticlip measure", 0.0, 1e+01, 0.1, MAKEUPTHRESHOLD3, false);
make_controller_box(&m_vbox[4], "THRESHOLD ",
"Threshold correction, an anticlip measure", 0.0, 1e+01, 0.1, MAKEUPTHRESHOLD4, false);
make_controller_box(&m_vbox[5], "THRESHOLD ",
"Threshold correction, an anticlip measure", 0.0, 1e+01, 0.1, MAKEUPTHRESHOLD5, false);
Glib::ustring modes[] = {"Compress","Bypass","Mute"};
static const size_t _size = sizeof(modes) / sizeof(modes[0]);
make_selector(&m_vbox[1],"Compress or Mute the selected band, or Bypass The Compressor", modes, _size, 1.0, 1.0, MODE1);
make_selector(&m_vbox[2],"Compress or Mute the selected band, or Bypass The Compressor", modes, _size, 1.0, 1.0, MODE2);
make_selector(&m_vbox[3],"Compress or Mute the selected band, or Bypass The Compressor", modes, _size, 1.0, 1.0, MODE3);
make_selector(&m_vbox[4],"Compress or Mute the selected band, or Bypass The Compressor", modes, _size, 1.0, 1.0, MODE4);
make_selector(&m_vbox[5],"Compress or Mute the selected band, or Bypass The Compressor", modes, _size, 1.0, 1.0, MODE5);
make_controller_box(&m_vbox[7], "LOW PASS \n B1><B2", "Crossfrequency between Band1 and Band2",
2e+01, 2e+04, 1.08 , CROSSOVER_B1_B2, true);
make_controller_box(&m_vbox[8], "CROSSOVER \n B2><B3", "Crossfrequency between Band2 and Band3",
2e+01, 2e+04, 1.08 , CROSSOVER_B2_B3, true);
make_controller_box(&m_vbox[9], "CROSSOVER \n B3><B4 ", "Crossfrequency between Band3 and Band4",
2e+01, 2e+04, 1.08 , CROSSOVER_B3_B4, true);
make_controller_box(&m_vbox[10], "HIGH PASS \n B4><B5", "Crossfrequency between Band4 and Band5",
2e+01, 2e+04, 1.08 , CROSSOVER_B4_B5, true);
// set propertys for the main paintbox holding the skin
m_paintbox[0].set_border_width(10);
m_paintbox[0].set_spacing(6);
m_paintbox[0].set_homogeneous(false);
m_paintbox[0].set_name(plug_name);
m_paintbox[0].property_paint_func() = "gxhead_expose";
add(m_paintbox[0]);
// set propertys and stack fastmeters
for (uint32_t i = 0;i<5;i++) {
fastmeter[i].set_hold_count(12);
fastmeter[i].set_property("dimen",5);
fastmeter[i].set_tooltip_text("Output");
fastmeter[i+5].set_hold_count(12);
fastmeter[i+5].set_property("dimen",5);
fastmeter[i+5].set_tooltip_text("Input");
m_paintbox[i+1].property_paint_func() = "RackBox_expose";
m_paintbox[i+1].set_name(plug_name);
m_paintbox[i+1].set_border_width(5);
m_paintbox[i+1].set_spacing(2);
m_paintbox[i+1].pack_start(fastmeter[i+5]);
m_paintbox[i+1].pack_start(fastmeter[i]);
}
// set a vertical box in the paintbox
m_vbox[11].set_border_width(14);
m_vbox[12].set_border_width(14);
m_hbox[2].set_border_width(4);
m_paintbox[0].pack_start(m_vbox[0]);
// box for the controllers
m_hbox[0].set_spacing(4);
m_hbox[0].set_border_width(4);
m_hbox[0].set_homogeneous(false);
m_vbox[0].pack_start(m_hbox[0]);
m_fr[5].add(m_hbox[1]);
m_vbox[0].pack_start(m_fr[5]);
m_vbox[0].pack_start(m_hbox[2]);
// put boxed controllers into controller box
m_hbox[0].pack_start(m_vbox[11], Gtk::PACK_EXPAND_PADDING);
m_hbox[0].pack_start(m_fr[0]);
m_lbox[0].pack_start(m_vbox[1]);
m_lbox[0].pack_start(m_paintbox[1],Gtk::PACK_SHRINK);
m_hbox[0].pack_start(m_fr[1]);
m_lbox[1].pack_start(m_vbox[2]);
m_lbox[1].pack_start(m_paintbox[2],Gtk::PACK_SHRINK);
m_hbox[0].pack_start(m_fr[2]);
m_lbox[2].pack_start(m_vbox[3]);
m_lbox[2].pack_start(m_paintbox[3],Gtk::PACK_SHRINK);
m_hbox[0].pack_start(m_fr[3]);
m_lbox[3].pack_start(m_vbox[4]);
m_lbox[3].pack_start(m_paintbox[4],Gtk::PACK_SHRINK);
m_hbox[0].pack_start(m_fr[4]);
m_lbox[4].pack_start(m_vbox[5]);
m_lbox[4].pack_start(m_paintbox[5],Gtk::PACK_SHRINK);
m_hbox[0].pack_start(m_vbox[12], Gtk::PACK_EXPAND_PADDING);
// put boxed controllers into controller box
m_hbox[1].pack_start(m_vbox[13], Gtk::PACK_EXPAND_PADDING);
m_hbox[1].pack_start(m_vbox[7]);
m_hbox[1].pack_start(m_vbox[8]);
m_hbox[1].pack_start(m_vbox[9]);
m_hbox[1].pack_start(m_vbox[10]);
m_hbox[1].pack_start(m_vbox[15]);
m_hbox[1].pack_start(m_vbox[14], Gtk::PACK_EXPAND_PADDING);
// default disable tooltips
gtk_settings_set_long_property(
gtk_settings_get_default(), "gtk-enable-tooltips", false, "gx_mbcompressor");
make_switch_box(&m_vbox[15], "Tooltips");
m_switch.signal_toggled().connect(sigc::mem_fun(
*this, &Widget::set_tooltips));
set_app_paintable(true);
show_all();
}
Widget::Widget(Glib::ustring plugname):
plug_name(plugname)
{
// create controllers for port name
Glib::ustring modes[] = {"(Chromatic)","Standard", "Standard/Es", "Open E",
"Drop D","Half Step Down","Full Step Down","1 and 1/2 Steps Down","Double Drop D","Drop C",
"Drop C#","Drop B","Drop A#","Drop A","Open D","Open D Minor", "Open G","Open G Minor",
"Open C","Open C#","Open C Minor","Open E7","Open E Minor7","Open G Major7","Open A Minor",
"Open A Minor7","Open A","C Tuning","C# Tuning","Bb Tuning","A to A (Baritone)","Open Dsus2",
"Open Gsus2","G6","Modal G","Overtone","Pentatonic","Minor Third","Major Third","All Fourths",
"Augmented Fourths","Slow Motion","Admiral","Buzzard","Face","Four and Twenty","Ostrich","Capo 200",
"Balalaika","Cittern One","Cittern Two","Dobro","Lefty","Mandoguitar","Rusty Cage","Hardcore"};
static const size_t _size = sizeof(modes) / sizeof(modes[0]);
make_selector("Tunning Modes", modes, _size, 0, 1.0, TUNEMODE);
m_vbox8.pack_start(tuner_tuning);
Glib::ustring temperament_modes[] = {"12-TET","19-TET","24-TET", "31-TET"};
static const size_t _size2 = sizeof(temperament_modes) / sizeof(modes[0]);
make_selector("Tunning Scale", temperament_modes, _size2, 0, 1.0, TEMPERAMENT);
m_vbox8.pack_start(tuner_temperament);
m_vbox8.set_spacing(2);
make_switch_box(&m_hbox_, "", "FAST DETECTION", FASTNOTE);
m_vbox8.pack_start(m_vbox4);
m_vbox8.pack_start(m_hbox_);
Glib::ustring channel[] = {"0","1","2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16"};
static const size_t _size1 = sizeof(channel) / sizeof(channel[0]);
make_selector("Set Midi Channel", channel, _size1, 0, 1.0, CHANNEL);
m_fr1.set_label("MIDI OUT");
m_fr1.add(m_vbox5);
m_fr1.set_name("amplabel");
m_vbox5.pack_start(select1);
make_controller_box(&m_vbox1, "BPM", 0, 360, 1, BPM);
make_controller_box(&m_vbox9, "VELOCITY", 0, 127, 1, VELOCITY);
make_switch_box(&m_hbox5_, "", "SEND MIDI", ONMIDI);
make_switch_box(&m_hbox6_, "", "PITCH WHEEL", PITCHBEND);
make_switch_box(&m_hbox7_, "", "SINGLE NOTE", SINGLENOTE);
m_vbox5.pack_start(m_vbox1);
m_vbox5.pack_start(m_vbox9);
m_vbox5.pack_start(m_hbox5_);
m_vbox5.pack_start(m_hbox6_);
m_vbox5.pack_start(m_hbox7_);
m_vbox5.set_spacing(2);
make_controller_box(&m_vbox4, "Threshold (db)", -60, 4, 1, THRESHOLD);
//m_bigknob1.set_value_position(Gtk::POS_RIGHT);
make_controller_box(&m_vbox4, "Reference Pitch (Hz)", 427.0, 453.0, 0.1, REFFREQ);
//m_bigknob.set_value_position(Gtk::POS_RIGHT);
make_controller_box(&m_vbox4, "Verify Level", 1, 12, 1, VERIFY);
// set propertys for the tuner widget
m_tuner.set_size_request( 440, 65 ) ;
m_tuner.set_streaming(true);
m_tuner.set_display_flat(false);
m_tuner.set_reference_pitch(440.0);
m_tuner.set_property("scale",1.5);
m_hbox1_.pack_start(m_tuner);
m_hbox1_.set_border_width(5);
m_fr2.set_label("TUNER");
m_fr2.add(m_vbox8);
m_fr2.set_name("amplabel");
m_hbox2_.pack_start(m_fr2);
m_hbox2_.pack_start(m_fr1);
m_hbox2_.set_spacing(2);
m_vbox2.pack_start(m_hbox1_);
m_vbox2.pack_start(m_hbox2_,Gtk::PACK_SHRINK);
m_vbox2.set_border_width(1);
m_vbox2.set_homogeneous(false);
m_paintbox1.property_paint_func() = "RackBox_expose";
m_paintbox1.set_name(plug_name);
m_paintbox1.set_border_width(5);
m_paintbox1.pack_start(m_vbox2);
m_hbox2_.pack_start(m_vbox3,Gtk::PACK_SHRINK);
// set propertys for the main paintbox holding the skin
m_paintbox.set_border_width(10);
m_paintbox.set_spacing(0);
m_paintbox.set_homogeneous(false);
m_paintbox.set_name(plug_name);
m_paintbox.property_paint_func() = "gxhead_expose";
m_paintbox.pack_start(m_hbox4_,Gtk::PACK_SHRINK);
m_paintbox.pack_start(m_paintbox1);
m_paintbox.pack_start(m_hbox3_,Gtk::PACK_SHRINK);
m_hbox3_.set_border_width(8);
m_hbox4_.set_border_width(8);
m_paintbox2.property_paint_func() = "level_meter_expose";
//m_paintbox2.set_spacing(20);
m_paintbox2.set_border_width(2);
//m_paintbox2.set_size_request(22, -1 );
//m_paintbox2.pack_start(m_vbox3,Gtk::PACK_SHRINK);
m_vbox3.pack_start(m_vbox7, Gtk::PACK_EXPAND_PADDING);
m_vbox3.pack_start(m_paintbox2,Gtk::PACK_SHRINK);
m_vbox3.pack_start(m_vbox6, Gtk::PACK_EXPAND_PADDING);
m_paintbox2.pack_start(fastmeter,Gtk::PACK_SHRINK);
make_controller_box(static_cast<Gtk::Box*>(&m_paintbox2), "", -60, 4, 1, LEVEL);
levelslider.set_tooltip_text("Set Note ON level");
//m_paintbox2.pack_start(levelslider,Gtk::PACK_SHRINK);
levelslider.set_show_value(false);
levelslider.set_name(plug_name);
fastmeter.set_hold_count(8);
fastmeter.set_property("dimen",5);
//m_paintbox.set_size_request( 425, 160 ) ;
// connect expose handler as resize handler
m_paintbox.signal_expose_event().connect(
sigc::mem_fun(this, &Widget::_expose_event), true);
add(m_paintbox);
set_app_paintable(true);
show_all();
reset = 1;
}
Widget::Widget(Glib::ustring plugname):
plug_name(plugname)
{
// create controllers for port name
make_controller_box(&m_vbox[1], "DETUNE", -0.25, 0.25, 0.01, DETUNE);
make_controller_box(&m_vbox[2], "WET", 0.0, 100.0, 1, WET);
make_controller_box(&m_vbox[3], "DRY", 0.0, 100.0, 1, DRY);
make_controller_box(&m_vbox[4], "LOW", 0.0, 2.0, 0.01, LOW);
make_controller_box(&m_vbox[5], "MIDDLELOW", 0.0, 2.0, 0.01, MIDDLELOW);
make_controller_box(&m_vbox[6], "MIDDLETREBLE", 0.0, 2.0, 0.01, MIDDLETREBLE);
make_controller_box(&m_vbox[7], "TREBLE", 0.0, 2.0, 0.01, TREBLE);
Glib::ustring octaves[] = {"no shift","octave up","octave down"};
static const size_t _size1 = sizeof(octaves) / sizeof(octaves[0]);
make_selector("OCTAVE", octaves, _size1, 0, 1.0, OCTAVE);
Glib::ustring compensate[] = {"delay ","compensate"};
static const size_t _size2 = sizeof(compensate) / sizeof(compensate[0]);
make_selector("COMPENSATE", compensate, _size2, 0, 1.0, COMPENSATE);
Glib::ustring latency[] = {"high quality ","low quality ","realtime "};
static const size_t _size3 = sizeof(latency) / sizeof(latency[0]);
make_selector("LATENCY", latency, _size3, 0, 1.0, LATENCY);
m_vbox[0].pack_start(m_selector[0]);
m_vbox[0].pack_start(m_selector[1]);
m_vbox[0].pack_start(m_selector[2]);
m_latencyreport.set_name("lalabel");
m_vbox[0].pack_start(m_latencyreport);
// set propertys for the main paintbox holding the skin
m_paintbox.set_border_width(10);
m_paintbox.set_spacing(6);
m_paintbox.set_homogeneous(false);
m_paintbox.set_name(plug_name);
m_paintbox.property_paint_func() = "compressor_expose";
add(m_paintbox);
// box for the controllers
m_hbox.set_spacing(14);
m_hbox.set_border_width(24);
m_hbox.set_homogeneous(false);
// set a vertical box in the paintbox
m_vbox[8].set_border_width(14);
m_vbox[10].set_border_width(14);
m_paintbox.pack_start(m_vbox[9]);
// and controller box on top
m_vbox[9].pack_start(m_hbox, Gtk::PACK_SHRINK);
// put boxed controllers into controller box
m_hbox.pack_start(m_vbox[10], Gtk::PACK_EXPAND_PADDING);
m_hbox.pack_start(m_vbox[0]);
m_hbox.pack_start(m_vbox[1]);
m_hbox.pack_start(m_vbox[2]);
m_hbox.pack_start(m_vbox[3]);
m_hbox.pack_start(m_vbox[4]);
m_hbox.pack_start(m_vbox[5]);
m_hbox.pack_start(m_vbox[6]);
m_hbox.pack_start(m_vbox[7]);
m_hbox.pack_start(m_vbox[8], Gtk::PACK_EXPAND_PADDING);
// connect expose handler as resize handler
// m_paintbox.signal_expose_event().connect(
// sigc::mem_fun(this, &Widget::_expose_event), true);
set_app_paintable(true);
show_all();
}
Widget::Widget(Glib::ustring plugname):
plug_name(plugname)
{
// create all selectors
Glib::ustring tubes[] = {"12ax7","12AU7","12AT7","6DJ8","6C16","6V6","12ax7 feedback",
"12AU7 feedback","12AT7 feedback","6DJ8 feedback","pre 12ax7/ master 6V6","pre 12AU7/ master 6V6",
"pre 12AT7/ master 6V6","pre 6DJ8/ master 6V6","pre 12ax7/ push-pull 6V6","pre 12AU7/ push-pull 6V6",
"pre 12AT7/ push pull 6V6","pre 6DJ8/ push-pull 6V6"
};
tubes_size = sizeof(tubes) / sizeof(tubes[0]);
make_selector("Tubes", tubes, tubes_size, 0, 1.0, MODEL);
m_hboxsel1.pack_start(m_selector,Gtk::PACK_SHRINK);
m_hboxsel1.pack_start(m_hboxsel2,Gtk::PACK_EXPAND_PADDING);
m_vboxsel.pack_start(m_hboxsel1,Gtk::PACK_EXPAND_PADDING);
Glib::ustring ts[] = {"default","Bassman","Twin Reverb","Princeton","JCM-800",
"JCM-2000","M-Lead","M2199","AC-30","Mesa Boogie","SOL 100","JTM-45","AC-15",
"Peavey","Ibanez","Roland","Ampeg","Rev.Rocket","MIG 100 H","Triple Giant",
"Trio Preamp","Hughes&Kettner","Fender Junior","Fender","Fender Deville",
"Gibsen", "Off"
};
static const size_t ts_size = sizeof(ts) / sizeof(ts[0]);
make_selector("Tonestacks", ts, ts_size, 0,1.0, T_MODEL);
Glib::ustring cab[] = {"4x12","2x12","1x12","4x10","2x10","HighGain","Twin",
"Bassman","Marshall","AC30","Princeton","A2","1x15","Mesa","Briliant","Vitalize",
"Charisma","1x8", "Off"
};
static const size_t cab_size = sizeof(cab) / sizeof(cab[0]);
make_selector("Cabinets", cab, cab_size, 0, 1.0, C_MODEL);
// create all controllers
make_controller_box(&m_vbox, "mastergain", -20, 20, 0.1, GAIN1);
make_controller_box(&m_vbox1, "pregain", -20, 20, 0.1, PREGAIN);
make_controller_box(&m_vbox2, "distortion", 1, 100, 1, WET_DRY);
make_controller_box(&m_vbox3, "drive", 0.01, 1, 0.01, DRIVE);
make_controller_box(&m_vbox4, "mid", 0, 1, 0.01, MIDDLE);
make_controller_box(&m_vbox5, "bass", 0, 1, 0.01, BASS);
make_controller_box(&m_vbox6, "treble", 0, 1, 0.01, TREBLE);
// put cabinet selector above cab controller
m_vbox7.pack_start(c_selector,Gtk::PACK_SHRINK);
make_controller_box(&m_vbox7, "cabinet", 1, 20, 1, CLevel);
make_controller_box(&m_vbox8, "presence", 1, 10, 1, ALevel);
// set propertys for the main paintbox holding the skin
m_paintbox.set_border_width(30);
m_paintbox.set_spacing(12);
m_paintbox.set_homogeneous(false);
m_paintbox.set_name(plug_name);
m_paintbox.property_paint_func() = "amp_skin_expose";
add(m_paintbox);
// box for the controllers
m_hbox_.set_spacing(12);
m_hbox_.set_homogeneous(false);
// this box set space for the upper part of the skin
m_hbox1_.set_spacing(12);
m_hbox1_.set_border_width(65);
// set a vertical box in the paintbox
m_paintbox.pack_start(m_vbox_);
// and put space box on top
m_vbox_.pack_start(m_hbox1_, Gtk::PACK_EXPAND_PADDING);
// and controller box on bottem
m_vbox_.pack_start(m_hbox_,Gtk::PACK_SHRINK);
// amp controllers including the tube selector
m_hboxsel.set_spacing(12);
m_hboxsel.set_homogeneous(false);
m_hboxsel.pack_start(m_vbox1);
m_hboxsel.pack_start(m_vbox2);
m_hboxsel.pack_start(m_vbox3);
m_hboxsel.pack_start(m_vbox8);
m_hboxsel.pack_start(m_vbox);
m_vboxsel.pack_start(m_hboxsel);
// put boxed controllers into controller box
m_hbox_.pack_start(m_vboxhh);
m_hbox_.pack_start(m_vboxsel);
m_hbox_.pack_start(m_vbox7);
// etxra box for the boxed tonestack controllers
m_hboxtonestack1.pack_start(m_hboxtonestack3,Gtk::PACK_EXPAND_PADDING);
m_hboxtonestack1.pack_start(t_selector,Gtk::PACK_SHRINK);
m_hboxtonestack1.pack_start(m_hboxtonestack2,Gtk::PACK_EXPAND_PADDING);
m_vboxtonestack.pack_start(m_hboxtonestack1);
m_vboxtonestack.pack_start(m_hbox);
m_hbox.set_border_width(8);
m_hbox.pack_start(m_vbox5);
m_hbox.pack_start(m_vbox4);
m_hbox.pack_start(m_vbox6);
m_hbox.pack_start(m_vboxii);
m_hbox.set_spacing(5);
// add tonestack controller box to main controller box
m_hbox_.pack_start(m_vboxtonestack);
// connect expose handler as resize handler
m_paintbox.signal_expose_event().connect(
sigc::mem_fun(this, &Widget::_expose_event), true);
show_all();
}
