ScreenArea::ScreenArea(int _iWidth, int _iHeight, int _iScale) : m_iFilterScale(1), m_vFilter2x(NULL), m_vFilterIB(NULL), m_puiPixels(NULL), m_puiDelta(NULL), m_iScaledWidth(_iWidth), m_iScaledHeight(_iHeight), m_bEnableRender(true), m_bShowCursor(true) { g_assert(_iWidth >= 1 && _iHeight >= 1 && _iScale >= 1); m_iWidth = _iWidth; m_iHeight = _iHeight; m_iScale = _iScale; set_events(Gdk::EXPOSURE_MASK | Gdk::POINTER_MOTION_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK); char aiEmptyData[8]; memset(aiEmptyData, 0, sizeof(aiEmptyData)); Glib::RefPtr<Gdk::Bitmap> poSource = Gdk::Bitmap::create(aiEmptyData, 8, 8); Glib::RefPtr<Gdk::Bitmap> poMask = Gdk::Bitmap::create(aiEmptyData, 8, 8); Gdk::Color oFg; Gdk::Color oBg; oFg.set_rgb(0, 0, 0); oBg.set_rgb(0, 0, 0); m_poEmptyCursor = new Gdk::Cursor(poSource, poMask, oFg, oBg, 0, 0); }
/** Borra todos los datos de un formulario al cambiar de pagina. @param bloc, GtkNotebookPage. @param guint, pag contiene el numero de pagina. */ void Preferencias::borraDatosForm(GtkNotebookPage* bloc,guint pag) { Gdk::Color col; Glib::RefPtr<Gtk::TextBuffer> buf; Gtk::TreeModel::iterator it; col.set_rgb(0,0,0); clasesG->set_text(""); nomClasesG->set_text(""); buf = descripClasesG->get_buffer(); buf->set_text(""); //claseLinea.set_active_text(""); estadosG->set_text(""); nomEstadosG->set_text(""); buf = descripEstadosG->get_buffer(); buf->set_text(""); colorEstadosG->set_color(col); separPuntosGPD->set_value(0); numColumnsG->set_value(0); numFilasG->set_value(0); colorEstadosG->set_sensitive(false); claseLinea->set_sensitive(false); iter = it; }
AnalogMemoryGUI::AnalogMemoryGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage(new VBox(false)); MyBox *p_writeAddressingModeBox = manage (new MyBox("Write Addressing Mode", Gtk::Orientation::ORIENTATION_VERTICAL)); m_comboWriteAddressForm = manage (new ComboBoxText()); m_comboWriteAddressForm->append_text("Direct (no fill)"); m_comboWriteAddressForm->append_text("Linear up only, no fill"); m_comboWriteAddressForm->append_text("Linear up only, fill"); m_comboWriteAddressForm->append_text("Linear down only, no fill"); m_comboWriteAddressForm->append_text("Linear down only, fill"); m_comboWriteAddressForm->append_text("Reflected"); m_comboWriteAddressForm->signal_changed().connect(compose(bind<0> (mem_fun(*this, &AnalogMemoryGUI::write_control), p_write_addressing_mode), mem_fun(*m_comboWriteAddressForm, &ComboBoxText::get_active_row_number))); p_writeAddressingModeBox->pack_start(*m_comboWriteAddressForm); p_mainWidget->pack_start(*p_writeAddressingModeBox); p_mainWidget->pack_start(*(m_dialN = CreateDial("N (for 2^N memory cells)", p_n, NORMAL, 1))); p_mainWidget->pack_start(*(m_dialWriteThresh = CreateDial("Write Threshold", p_write_tresh, NORMAL, 0.01))); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_background); }
VCAExpAudioGUI::VCAExpAudioGUI(const std::string& URI) { EventBox *p_background = manage(new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage(new VBox(false, 5)); Frame *p_gainFrame = manage(new Frame("Gain")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_gainBox = manage(new HBox(true)); slot<void> p_slotGain1 = compose(bind<0>(mem_fun(*this, &VCAExpAudioGUI::write_control), p_gain1), mem_fun(*this, &VCAExpAudioGUI::get_gain1)); m_dialGain1 = new LabeledDial("Gain Offset", p_slotGain1, p_gain1, 0, 1, NORMAL, 0.01, 2); p_gainBox->pack_start(*m_dialGain1); slot<void> p_slotGain2 = compose(bind<0>(mem_fun(*this, &VCAExpAudioGUI::write_control), p_gain2), mem_fun(*this, &VCAExpAudioGUI::get_gain2)); m_dialGain2 = new LabeledDial("2nd Gain Boost", p_slotGain2, p_gain2, 0, 1, NORMAL, 0.01, 2); p_gainBox->pack_start(*m_dialGain2); p_gainFrame->add(*p_gainBox); p_mainWidget->pack_start(*p_gainFrame); Frame *p_inFrame = manage(new Frame("In")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_volumeBox = manage(new HBox(true)); slot<void> p_slotIn1 = compose(bind<0>(mem_fun(*this, &VCAExpAudioGUI::write_control), p_in1), mem_fun(*this, &VCAExpAudioGUI::get_in1)); m_dialIn1 = new LabeledDial("In 1", p_slotIn1, p_in1, 0, 2, NORMAL, 0.01, 2); p_volumeBox->pack_start(*m_dialIn1); slot<void> p_slotIn2 = compose(bind<0>(mem_fun(*this, &VCAExpAudioGUI::write_control), p_in2), mem_fun(*this, &VCAExpAudioGUI::get_in2)); m_dialIn2 = new LabeledDial("In 2", p_slotIn2, p_in2, 0, 2, NORMAL, 0.01, 2); p_volumeBox->pack_start(*m_dialIn2); p_inFrame->add(*p_volumeBox); p_mainWidget->pack_start(*p_inFrame); slot<void> p_slotOutputLevel = compose(bind<0>(mem_fun(*this, &VCAExpAudioGUI::write_control), p_outputLevel), mem_fun(*this, &VCAExpAudioGUI::get_outputLevel)); m_dialOutputLevel = new LabeledDial("Output Level", p_slotOutputLevel, p_outputLevel, 0, 2, NORMAL, 0.01, 2); p_mainWidget->pack_start(*m_dialOutputLevel); p_mainWidget->set_size_request(150, 300); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
Gdk::Color WidgetExpanderBase::getARandColor() { Gdk::Color RandColor; RandColor.set_rgb(Glib::Rand().get_int_range(0, 65535), Glib::Rand().get_int_range(0, 65535), Glib::Rand().get_int_range(0, 65535)); return RandColor; }
BeatRepeaterMonoGUI::BeatRepeaterMonoGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage (new VBox(false)); MyBox *p_beatBox = manage (new MyBox("Beat", Gtk::Orientation::ORIENTATION_VERTICAL)); HBox *p_beatDials = manage(new HBox(false)); m_dialTempo = new LabeledDial("Tempo", p_tempo, 40, 320, NORMAL, 1, 0); m_dialTempo->signal_value_changed().connect(compose(bind<0>(mem_fun(*this, &BeatRepeaterMonoGUI::write_control), p_tempo), mem_fun(*m_dialTempo, &LabeledDial::get_value))); p_beatDials->pack_start(*m_dialTempo, Gtk::PACK_EXPAND_PADDING, 0); m_dialBeatSize = new LabeledDial("Beat Size", p_beatSize, 0.0078125, 128, MULTIPLIER, 0.0078125, 7); m_dialBeatSize->signal_value_changed().connect(compose(bind<0>(mem_fun(*this, &BeatRepeaterMonoGUI::write_control), p_beatSize), mem_fun(*m_dialBeatSize, &LabeledDial::get_value))); p_beatDials->pack_start(*m_dialBeatSize, Gtk::PACK_EXPAND_PADDING, 0); p_beatBox->pack_start(*p_beatDials); Alignment* p_align = new Alignment(0.5, 0.5, 0, 0); m_checkReverse = manage(new CheckButton("Reverse")); m_checkReverse->signal_toggled().connect(compose(bind<0>(mem_fun(*this, &BeatRepeaterMonoGUI::write_control), p_reverse), mem_fun(*m_checkReverse, &CheckButton::get_active))); p_align->add(*m_checkReverse); p_beatBox->pack_start(*p_align); p_mainWidget->pack_start(*p_beatBox); MyBox *p_envelopeFrame = manage(new MyBox("Envelope", Gtk::Orientation::ORIENTATION_HORIZONTAL)); m_dialAttack = new LabeledDial("Attack", p_attack, 3, 25, NORMAL, 1, 0); m_dialAttack->signal_value_changed().connect(compose(bind<0>(mem_fun(*this, &BeatRepeaterMonoGUI::write_control), p_attack), mem_fun(*m_dialAttack, &LabeledDial::get_value))); p_envelopeFrame->pack_start(*m_dialAttack); m_dialRelease = new LabeledDial("Release", p_release, 3, 25, NORMAL, 1, 0); m_dialRelease->signal_value_changed().connect(compose(bind<0>(mem_fun(*this, &BeatRepeaterMonoGUI::write_control), p_release), mem_fun(*m_dialRelease, &LabeledDial::get_value))); p_envelopeFrame->pack_start(*m_dialRelease); p_mainWidget->pack_start(*p_envelopeFrame); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
bool RedBlueLevelSelector::redraw(GdkEventExpose */*bleh*/) { //!Check if the window we want draw is ready Glib::RefPtr<Gdk::Window> window = get_window(); if(!window) return true; const int w(get_width()),h(get_height()); Gdk::Color color; Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(window)); int i; // Draw the gradient for(i=0;i<w;i++) { float red_blue(((float(i)/float(w)+0.5f)-1.0f)/2.0f+1.0f); float blue_red(2.0f-(red_blue)); if(red_blue>1.0f)red_blue=1.0f; if(blue_red>1.0f)blue_red=1.0f; color.set_rgb( round_to_int(min(red_blue,1.0f)*65535), round_to_int(sqrt(min(red_blue,blue_red))*65535), round_to_int(min(blue_red,1.0f)*65535) ); gc->set_rgb_fg_color(color); window->draw_rectangle(gc, true, i, 0, 1, h); } // Draw a frame gc->set_rgb_fg_color(Gdk::Color("#000000")); window->draw_rectangle(gc, false, 0, 0, w-1, h-1); // Draw the position of the current value i=(int)(((level-1.0f)*2.0f+1.0f-0.5f)*w+0.5); gc->set_rgb_fg_color(Gdk::Color("#00ff00")); window->draw_rectangle(gc, true, i, 1, 1, h-1); // Print out the value Glib::RefPtr<Pango::Layout> layout(Pango::Layout::create(get_pango_context())); layout->set_text(etl::strprintf("%0.02f",level)); layout->set_alignment(Pango::ALIGN_CENTER); gc->set_rgb_fg_color(Gdk::Color("#a00000")); window->draw_layout(gc, w/2, 4, layout); return true; }
LfoTempoGUI::LfoTempoGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage (new VBox(false, 5)); Label *p_labelWaveForm = manage (new Label("Wave Form")); p_mainWidget->pack_start(*p_labelWaveForm); m_comboWaveForm = manage (new ComboBoxText()); m_comboWaveForm->append_text("Sine"); m_comboWaveForm->append_text("Triangle"); m_comboWaveForm->append_text("Sawtooth Up"); m_comboWaveForm->append_text("Sawtooth Down"); m_comboWaveForm->append_text("Rectangle"); m_comboWaveForm->append_text("S & H"); slot<void> p_slotWaveForm = compose(bind<0> (mem_fun(*this, &LfoTempoGUI::write_control), p_waveForm), mem_fun(*m_comboWaveForm, &ComboBoxText::get_active_row_number)); m_comboWaveForm->signal_changed().connect(p_slotWaveForm); p_mainWidget->pack_start(*m_comboWaveForm); Frame *p_freqFrame = manage(new Frame("Tempo")); HBox *p_freqBox = manage(new HBox(true)); slot<void> p_slotTempo = compose(bind<0>(mem_fun(*this, &LfoTempoGUI::write_control), p_tempo), mem_fun(*this, &LfoTempoGUI::get_tempo)); m_dialTempo = new LabeledDial("Tempo", p_slotTempo, p_tempo, 1, 320, NORMAL, 1, 0); p_freqBox->pack_start(*m_dialTempo); slot<void> p_slotTempoMultiplier = compose(bind<0>(mem_fun(*this, &LfoTempoGUI::write_control), p_tempoMultiplier), mem_fun(*this, &LfoTempoGUI::get_tempoMultiplier)); m_dialTempoMultiplier = new LabeledDial("Tempo Multiplier", p_slotTempoMultiplier, p_tempoMultiplier, 0.0078125, 32, DIVIDER, 1, 7); p_freqBox->pack_start(*m_dialTempoMultiplier); p_freqFrame->add(*p_freqBox); p_mainWidget->pack_start(*p_freqFrame); slot<void> p_slotPhi0 = compose(bind<0> (mem_fun(*this, &LfoTempoGUI::write_control), p_phi0), mem_fun(*this, &LfoTempoGUI::get_phi0)); m_dialPhi0 = new LabeledDial("Phi0", p_slotPhi0, p_phi0, 0, 6.28, NORMAL, 0.01, 2); p_mainWidget->pack_start(*m_dialPhi0); p_mainWidget->set_size_request(160, 260); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
RindModulatorCVGUI::RindModulatorCVGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); slot<void> p_slotGain = compose(bind<0>(mem_fun(*this, &RindModulatorCVGUI::write_control), p_gain), mem_fun(*this, &RindModulatorCVGUI::get_gain)); m_dialGain = new LabeledDial("Gain", p_slotGain, p_gain, -10, 10, NORMAL, 0.01, 2); p_background->add(*m_dialGain); p_background->set_size_request(100, 80); add(*p_background); Gtk::manage(p_background); }
HaasGUI::HaasGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); HBox *p_mainWidget = manage (new HBox(true)); p_mainWidget->pack_start(*(m_dialDelay = CreateDial("Delay (ms)", p_delay, NORMAL, 1))); p_mainWidget->pack_start(*(m_dialMix = CreateDial("Dry/Wet (%)", p_dry_wet, NORMAL, 1))); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_background); }
/** Rellena los datos en el formulario correspondientes a la clase o el estado seleccionado por el usuario. */ void Preferencias::seleccionaEstado() { Glib::RefPtr<Gtk::TreeSelection> filaSeleccionada; Gtk::TreeModel::iterator it; string etiquetaClase; Glib::RefPtr<Gtk::TextBuffer> buf; Gdk::Color col; int i; iter = it; i = 0; filaSeleccionada = treeviewEstadosG->get_selection(); iter = filaSeleccionada->get_selected(); if(iter) { int numCopClaseEst = copiaEstadoCelula.size(); Gtk::TreeModel::Row row = *iter; etiquetaClase = row[columModel.nomCol]; while(i < numCopClaseEst && etiquetaClase != copiaEstadoCelula[i].getEtiquetaClasificacion()) { i++; } if(etiquetaClase == copiaEstadoCelula[i].getEtiquetaClasificacion()) { col.set_rgb(copiaEstadoCelula[i].getColorEstadoR(), copiaEstadoCelula[i].getColorEstadoG(), copiaEstadoCelula[i].getColorEstadoB()); indiceClassEstado = i; estadosG->set_text(copiaEstadoCelula[i].getEtiquetaClasificacion()); nomEstadosG->set_text(copiaEstadoCelula[i].getNombreClasificacion()); buf = descripEstadosG->get_buffer(); buf->set_text(copiaEstadoCelula[i].getDescripcionClasificacion()); colorEstadosG->set_sensitive(true); colorEstadosG->set_color(col); } } }
bool BlackLevelSelector::redraw(GdkEventExpose */*bleh*/) { //!Check if the window we want draw is ready Glib::RefPtr<Gdk::Window> window = get_window(); if(!window) return true; const int w(get_width()),h(get_height()); Gdk::Color color; Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(window)); int i; // Draw the gradient for(i=0;i<w;i++) { color.set_rgb(i*65536/w,i*65536/w,i*65536/w); gc->set_rgb_fg_color(color); window->draw_rectangle(gc, true, i, 0, 1, h); } // Draw a frame gc->set_rgb_fg_color(Gdk::Color("#000000")); window->draw_rectangle(gc, false, 0, 0, w-1, h-1); // Draw the position of the current value i=(int)(level*w+0.5); gc->set_rgb_fg_color(Gdk::Color("#ff0000")); window->draw_rectangle(gc, true, i, 1, 1, h-1); // Print out the value Glib::RefPtr<Pango::Layout> layout(Pango::Layout::create(get_pango_context())); layout->set_text(etl::strprintf("%0.01f%%",level*100.0f)); layout->set_alignment(Pango::ALIGN_CENTER); gc->set_rgb_fg_color(Gdk::Color("#a00000")); window->draw_layout(gc, w/2, 4, layout); return true; }
void DoTextWidget() { InitGtkmm(); Gtk::Window win; TextWidget t_wdg; Gdk::Color white; white.set_rgb(0x0, 0x0, 0xffff); win.set_title("TextWidget"); t_wdg.modify_bg(Gtk::STATE_NORMAL, white); win.set_default_size(300, 300); win.add(t_wdg); RunWindow(win); }
HysteresisGUI::HysteresisGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage (new VBox(false)); p_mainWidget->pack_start(*(m_dialCenter = CreateDial("Center", p_center, NORMAL, 0.01))); p_mainWidget->pack_start(*(m_dialOverlap = CreateDial("Overlap", p_overlap, NORMAL, 0.01))); p_mainWidget->pack_start(*(m_dialLowSlope = CreateDial("Low Slope", p_lowSlope, NORMAL, 0.01))); //p_mainWidget->pack_start(*(m_dialLowOffset = CreateDial("Low Offset", p_lowOffset, NORMAL, 0.01))); p_mainWidget->pack_start(*(m_dialHighSlope = CreateDial("High Slope", p_highSlope, NORMAL, 0.01))); //p_mainWidget->pack_start(*(m_dialHighOffset = CreateDial("High Offset", p_highOffset, NORMAL, 0.01))); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
Noise2CVGUI::Noise2CVGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage (new VBox(false, 5)); Label *p_labelWaveForm = manage (new Label("Noise Type")); p_mainWidget->pack_start(*p_labelWaveForm); m_comboNoiseForm = manage (new ComboBoxText()); m_comboNoiseForm->append_text("White"); m_comboNoiseForm->append_text("Random"); m_comboNoiseForm->append_text("Pink"); slot<void> p_slotNoiseForm = compose(bind<0> (mem_fun(*this, &Noise2CVGUI::write_control), p_noiseType), mem_fun(*m_comboNoiseForm, &ComboBoxText::get_active_row_number)); m_comboNoiseForm->signal_changed().connect(p_slotNoiseForm); p_mainWidget->pack_start(*m_comboNoiseForm); slot<void> p_slotRandomRate = compose(bind<0>(mem_fun(*this, &Noise2CVGUI::write_control), p_rate), mem_fun(*this, &Noise2CVGUI::get_randomRate)); m_dialRandomRate = new LabeledDial("Random Rate", p_slotRandomRate, p_rate, 0, 10, NORMAL, 0.01, 2); p_mainWidget->pack_start(*m_dialRandomRate); slot<void> p_slotRandomLevel = compose(bind<0>(mem_fun(*this, &Noise2CVGUI::write_control), p_level), mem_fun(*this, &Noise2CVGUI::get_randomLevel)); m_dialRandomLevel = new LabeledDial("Random Level", p_slotRandomLevel, p_level, 0, 1, LOG, 0.0001, 4); p_mainWidget->pack_start(*m_dialRandomLevel); p_mainWidget->set_size_request(150, 200); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
EnvGUI::EnvGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage (new VBox(false, 5)); m_envScope = new EnvGUIScope(); p_mainWidget->pack_start(*m_envScope); Frame *p_adsrFrame = manage (new Frame("ADSR")); p_adsrFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_adsrWidget = manage (new HBox(false)); slot<void> p_slotAttack = compose(bind<0>(mem_fun(*this, &EnvGUI::write_control), p_attack), mem_fun(*this, &EnvGUI::get_attack)); m_scaleAttack = new LabeledDial("Attack", p_slotAttack, p_attack, 0, 1, NORMAL, 0.01, 2); p_adsrWidget->pack_start(*m_scaleAttack); slot<void> p_slotDecay = compose(bind<0> (mem_fun(*this, &EnvGUI::write_control), p_decay), mem_fun(*this, &EnvGUI::get_decay)); m_scaleDecay = new LabeledDial("Decay", p_slotDecay, p_decay, 0, 1, NORMAL, 0.01, 2); p_adsrWidget->pack_start(*m_scaleDecay); slot<void> p_slotSustain = compose(bind<0> (mem_fun(*this, &EnvGUI::write_control), p_sustain), mem_fun(*this, &EnvGUI::get_sustain)); m_scaleSustain = new LabeledDial("Sustain", p_slotSustain, p_delay, 0, 1, NORMAL, 0.01, 2); p_adsrWidget->pack_start(*m_scaleSustain); slot<void> p_slotRelease = compose(bind<0> (mem_fun(*this, &EnvGUI::write_control), p_release), mem_fun(*this, &EnvGUI::get_release)); m_scaleRelease = new LabeledDial("Release", p_slotRelease, p_release, 0, 1, NORMAL, 0.01, 2); p_adsrWidget->pack_start(*m_scaleRelease); p_adsrFrame->add(*p_adsrWidget); p_mainWidget->pack_start(*p_adsrFrame); p_mainWidget->pack_start(*(new HSeparator())); Frame *p_dhtFrame = manage (new Frame("Delay / Hold / Time Scale")); p_dhtFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_dhtWidget = manage (new HBox(false)); slot<void> p_slotDelay = compose(bind<0>(mem_fun(*this, &EnvGUI::write_control), p_delay), mem_fun(*this, &EnvGUI::get_delay)); m_scaleDelay = new LabeledDial("Delay", p_slotDelay, p_delay, 0, 1, NORMAL, 0.01, 2); p_dhtWidget->pack_start(*m_scaleDelay); slot<void> p_slotHold = compose(bind<0> (mem_fun(*this, &EnvGUI::write_control), p_hold), mem_fun(*this, &EnvGUI::get_hold)); m_scaleHold = new LabeledDial("Hold", p_slotHold, p_hold, 0, 1, NORMAL, 0.01, 2); p_dhtWidget->pack_start(*m_scaleHold); slot<void> p_slotTimescale = compose(bind<0> (mem_fun(*this, &EnvGUI::write_control), p_timeScale), mem_fun(*this, &EnvGUI::get_timescale)); m_scaleTimeScale = new LabeledDial("Time Scale", p_slotTimescale, p_timeScale, 0, 10, NORMAL, 0.01, 2); p_dhtWidget->pack_start(*m_scaleTimeScale); p_dhtFrame->add(*p_dhtWidget); p_mainWidget->pack_start(*p_dhtFrame); m_envScope->m_attackValue = m_scaleAttack->get_value(); m_envScope->m_decayValue = m_scaleDecay->get_value(); m_envScope->m_sustainValue = m_scaleSustain->get_value(); m_envScope->m_releaseValue = m_scaleRelease->get_value(); m_envScope->m_delayValue = m_scaleDelay->get_value(); m_envScope->m_holdValue = m_scaleHold->get_value(); m_envScope->Redraw(); p_mainWidget->set_size_request(200, 320); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
Vco2CVGUI::Vco2CVGUI(const char* plugin_uri) { EventBox *p_background = manage(new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage(new VBox(false, 5)); Label *p_labeWaveForm = manage (new Label("Wave Form")); p_mainWidget->pack_start(*p_labeWaveForm); m_comboWaveForm = manage (new ComboBoxText()); m_comboWaveForm->append_text("Sine"); m_comboWaveForm->append_text("Triangle"); m_comboWaveForm->append_text("Sawtooth"); m_comboWaveForm->append_text("Rectangle"); m_comboWaveForm->append_text("Aux Saw 1"); m_comboWaveForm->append_text("Aux Saw 2"); m_comboWaveForm->append_text("Aux Saw 3"); slot<void> p_slotWaveForm = compose(bind<0> (mem_fun(*this, &Vco2CVGUI::write_control), p_waveForm), mem_fun(*this, &Vco2CVGUI::get_waveform)); m_comboWaveForm->signal_changed().connect(p_slotWaveForm); p_mainWidget->pack_start(*m_comboWaveForm); Frame *p_freqFrame = manage(new Frame("Frequency")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_freqBox = manage(new HBox(true)); slot<void> p_slotOctave = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_octave), mem_fun(*this, &Vco2CVGUI::get_octave)); m_scaleOctave = new LabeledDial("Octave", p_slotOctave, p_octave, 0, 6, NORMAL, 1, 0); p_freqBox->pack_start(*m_scaleOctave); slot<void> p_slotTune = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_tune), mem_fun(*this, &Vco2CVGUI::get_tune)); m_scaleTune = new LabeledDial("Tune", p_slotTune, p_tune, 0, 1, LOG, 0.0001, 4); p_freqBox->pack_start(*m_scaleTune); slot<void> p_slotSubharmonic = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_semitone), mem_fun(*this, &Vco2CVGUI::get_semitone)); m_scaleSemitone = new LabeledDial("Semitone", p_slotSubharmonic, p_semitone, 0, 12, NORMAL, 1, 0); p_freqBox->pack_start(*m_scaleSemitone); p_freqFrame->add(*p_freqBox); p_mainWidget->pack_start(*p_freqFrame); Frame *p_pwpFrame = manage(new Frame("Pulse Width / Phase")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_pwpBox = manage(new HBox(true)); slot<void> p_slotPw0 = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_pw0), mem_fun(*this, &Vco2CVGUI::get_pw)); m_scalePW = new LabeledDial("PW", p_slotPw0, p_pw0, 0.1, 0.9, NORMAL, 0.001, 3); p_pwpBox->pack_start(*m_scalePW); slot<void> p_slotPwGain = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_pwGain), mem_fun(*this, &Vco2CVGUI::get_pwGain)); m_scalePWGain = new LabeledDial("PW Gain", p_slotPwGain, p_pwGain, 0, 1, LOG, 0.0001, 4); p_pwpBox->pack_start(*m_scalePWGain); slot<void> p_slotEdge = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_edge), mem_fun(*this, &Vco2CVGUI::get_edge)); m_scaleEdge = new LabeledDial("Edge", p_slotEdge, p_edge, 1, 10, NORMAL, 0.05, 2); p_pwpBox->pack_start(*m_scaleEdge); slot<void> p_slotPhi0 = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_phi0), mem_fun(*this, &Vco2CVGUI::get_phi0)); m_scalePhi0 = new LabeledDial("Phi0", p_slotPhi0, p_phi0, 0, 6.28, LOG, 0.0001, 4); p_pwpBox->pack_start(*m_scalePhi0); p_pwpFrame->add(*p_pwpBox); p_mainWidget->pack_start(*p_pwpFrame); Frame *p_modulationFrame = manage(new Frame("Modulation")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_modulationBox = manage(new HBox(true)); slot<void> p_slotExpFMGain = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_expFMGain), mem_fun(*this, &Vco2CVGUI::get_expFMGain)); m_scaleExpFMGain = new LabeledDial("Exp FM Gain", p_slotExpFMGain, p_expFMGain, 0, 10, LOG, 0.001, 3); p_modulationBox->pack_start(*m_scaleExpFMGain); slot<void> p_slotLinFMGain = compose(bind<0>(mem_fun(*this, &Vco2CVGUI::write_control), p_linFMGain), mem_fun(*this, &Vco2CVGUI::get_linFMGain)); m_scaleLinFMGain = new LabeledDial("Lin FM Gain", p_slotLinFMGain, p_linFMGain, 0, 10, LOG, 0.001, 3); p_modulationBox->pack_start(*m_scaleLinFMGain); p_modulationFrame->add(*p_modulationBox); p_mainWidget->pack_start(*p_modulationFrame); p_mainWidget->set_size_request(260, 360); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
CardActivatorEventBox::CardActivatorEventBox(int width) { static ActivationConsolidationFunctionalityConfiguration config = SAESGUIConfigurationManager::Current()->GetActivationConsolidationFunctionalityConfiguration(); static LabelConfiguration selectedLabelConfiguration = SAESGUIConfigurationManager::ConvertToLabelConfiguration(config.getLabelSelectedConfiguration()); static LabelConfiguration unselectedLabelConfiguration = SAESGUIConfigurationManager::ConvertToLabelConfiguration(config.getLabelUnselectedConfiguration()); static LabelConfiguration titleLabelConfiguration = SAESGUIConfigurationManager::ConvertToLabelConfiguration(config.getTitleFontConfiguration()); Gdk::Color selectedBoxColor; selectedBoxColor.set_rgb(config.getSelectedBoxColor().getRed(), config.getSelectedBoxColor().getGreen(), config.getSelectedBoxColor().getBlue()); Gdk::Color unselectedBoxColor; unselectedBoxColor.set_rgb(config.getUnselectedBoxColor().getRed(), config.getUnselectedBoxColor().getGreen(), config.getUnselectedBoxColor().getBlue()); Gdk::Color selectedFontColor; selectedFontColor.set_rgb(config.getSelectedFontColor().getRed(), config.getSelectedFontColor().getGreen(), config.getSelectedFontColor().getBlue()); Gdk::Color unselectedFontColor; unselectedFontColor.set_rgb(config.getUnselectedFontColor().getRed(), config.getUnselectedFontColor().getGreen(), config.getUnselectedFontColor().getBlue()); std::map< string, std::map< string, string > > eventboxSelectionMap; if(MachineOperationManager::getInstance()->getElectoralConfiguration() != NULL) { try { listCAD = MachineOperationManager::getInstance()->getElectoralConfiguration()->getVotingDevice()->getCustomAttributeDefinitionList( MachineOperationManager::getInstance()->getElectoralConfiguration()->getVotingDevice()->getFirstVotingDevice(), Machine_type::VOTING_DEVICES_PM); } catch (...) { } for(list<Custom_attribute_definition>::iterator iter = listCAD.begin(); iter != listCAD.end(); iter++) { std::map< string, string > customAttrMap; for ( Custom_attribute_definition::ValueIterator cad = iter->getValue().begin(); cad != iter->getValue().end(); cad++) { customAttrMap[*cad] = ElectionStringResourcesManager::Current()->getResource(*cad); } string s = Glib::ustring::compose(_("Smartmatic.SAES.GUI.Widgets.CardActivactorEventBox.TitleCustomAttribute"), ElectionStringResourcesManager::Current()->getResource(iter->getName_key())); eventboxSelectionMap[s] = customAttrMap; } } eventboxSelectionWidget = manage(new EventboxSelectionWidget(eventboxSelectionMap)); eventboxSelectionWidget->SetSelectedBoxColor(selectedBoxColor); eventboxSelectionWidget->SetUnselectedBoxColor(unselectedBoxColor); eventboxSelectionWidget->SetSelectedFontColor(selectedFontColor); eventboxSelectionWidget->SetUnselectedFontColor(unselectedFontColor); eventboxSelectionWidget->SetTitlesFontDescription(titleLabelConfiguration); eventboxSelectionWidget->SetSelectedFontDescription(selectedLabelConfiguration); eventboxSelectionWidget->SetUnselectedFontDescription(unselectedLabelConfiguration); eventboxSelectionWidget->set_size_request(width, -1); eventboxSelectionWidget->SetTitlesHeight(config.getTitleHeight()); eventboxSelectionWidget->signal_box_clicked().connect(sigc::mem_fun(*this, &CardActivatorEventBox::on_EventboxClicked)); eventboxSelectionWidget->SetFirstSelected(); eventboxSelectionWidget->show(); pack_start(*eventboxSelectionWidget); }
VcfGUI::VcfGUI(const std::string& URI) { EventBox *p_background = manage(new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage(new VBox(false, 5)); Label *p_labeFilterType = manage (new Label("Filter Type")); p_mainWidget->pack_start(*p_labeFilterType); m_comboVCFType = manage (new ComboBoxText()); m_comboVCFType->append_text("Resonant Lowpass"); m_comboVCFType->append_text("Lowpass"); m_comboVCFType->append_text("Highpass"); m_comboVCFType->append_text("Bandpass I"); m_comboVCFType->append_text("Bandpass II"); m_comboVCFType->append_text("Notch"); m_comboVCFType->append_text("24dB Lowpass I"); m_comboVCFType->append_text("24dB Lowpass II"); slot<void> p_slotVCFType = compose(bind<0> (mem_fun(*this, &VcfGUI::write_control), p_vcfType), mem_fun(*m_comboVCFType, &ComboBoxText::get_active_row_number)); m_comboVCFType->signal_changed().connect(p_slotVCFType); p_mainWidget->pack_start(*m_comboVCFType); slot<void> p_slotGain = compose(bind<0>(mem_fun(*this, &VcfGUI::write_control), p_inputGain), mem_fun(*this, &VcfGUI::get_inputGain)); m_scaleInputGain = new LabeledDial("Input Gain", p_slotGain, p_inputGain, 0, 10, LOG, 0.0001, 4); p_mainWidget->pack_start(*m_scaleInputGain); Frame *p_freqFrame = manage(new Frame("Frequency")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_freqBox = manage(new HBox(true)); slot<void> p_slotFrequency = compose(bind<0>(mem_fun(*this, &VcfGUI::write_control), p_freq), mem_fun(*this, &VcfGUI::get_frequency)); m_scaleFrequency = new LabeledDial("Frequency", p_slotFrequency, p_freq, 0, 10, LOG, 0.0001, 4); p_freqBox->pack_start(*m_scaleFrequency); slot<void> p_slotExpFMGain = compose(bind<0>(mem_fun(*this, &VcfGUI::write_control), p_expFMGain), mem_fun(*this, &VcfGUI::get_expFMGain)); m_scaleExpFMGain = new LabeledDial("Exp FM Gain", p_slotExpFMGain, p_expFMGain, 0, 10, LOG, 0.0001, 4); p_freqBox->pack_start(*m_scaleExpFMGain); slot<void> p_slotLinFMGain = compose(bind<0>(mem_fun(*this, &VcfGUI::write_control), p_linFMGain), mem_fun(*this, &VcfGUI::get_linFMGain)); m_scaleLinFMGain = new LabeledDial("Lin FM Gain", p_slotLinFMGain, p_linFMGain, 0, 10, LOG, 0.0001, 4); p_freqBox->pack_start(*m_scaleLinFMGain); p_freqFrame->add(*p_freqBox); p_mainWidget->pack_start(*p_freqFrame); Frame *p_resFrame = manage(new Frame("Resonance")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_resBox = manage(new HBox(true)); slot<void> p_slotResonance = compose(bind<0>(mem_fun(*this, &VcfGUI::write_control), p_resonance), mem_fun(*this, &VcfGUI::get_resonance)); m_scaleResonance = new LabeledDial("Resonance", p_slotResonance, p_resonance, 0.01, 1, LOG, 0.0001, 4); p_resBox->pack_start(*m_scaleResonance); slot<void> p_slotResonanceGain = compose(bind<0>(mem_fun(*this, &VcfGUI::write_control), p_resonanceGain), mem_fun(*this, &VcfGUI::get_resonanceGain)); m_scaleResonanceGain = new LabeledDial("Resonance Gain", p_slotResonanceGain, p_resonanceGain, 0, 1, LOG, 0.0001, 4); p_resBox->pack_start(*m_scaleResonanceGain); p_resFrame->add(*p_resBox); p_mainWidget->pack_start(*p_resFrame); p_mainWidget->set_size_request(180, 310); p_background->add(*p_mainWidget); add(*p_background); Gtk::manage(p_mainWidget); }
GranulatorMonoGUI::GranulatorMonoGUI(const std::string& URI) { EventBox *p_background = manage (new EventBox()); Gdk::Color* color = new Gdk::Color(); color->set_rgb(7710, 8738, 9252); p_background->modify_bg(Gtk::STATE_NORMAL, *color); VBox *p_mainWidget = manage(new VBox(false, 5)); Frame *p_gainFrame = manage(new Frame("Gain")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_gainBox = manage(new HBox(true)); slot<void> p_slotInputGain = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_inputGain), mem_fun(*this, &GranulatorMonoGUI::get_inputGain)); m_dialInputGain = new LabeledDial("Input Gain", p_slotInputGain, p_inputGain, -10, 10, NORMAL, 0.01, 2); p_gainBox->pack_start(*m_dialInputGain); slot<void> p_slotOutputGain = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_outputGain), mem_fun(*this, &GranulatorMonoGUI::get_outputGain)); m_dialOutputGain = new LabeledDial("Output Gain", p_slotOutputGain, p_outputGain, -10, 10, NORMAL, 0.01, 2); p_gainBox->pack_start(*m_dialOutputGain); p_gainFrame->add(*p_gainBox); p_mainWidget->pack_start(*p_gainFrame); Frame *p_grainFrame = manage(new Frame("Grain")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_grainBox = manage(new HBox(true)); slot<void> p_slotGrainSize = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_grainSize), mem_fun(*this, &GranulatorMonoGUI::get_grainSize)); m_dialGrainSize = new LabeledDial("Grain Size (ms)", p_slotGrainSize, p_grainSize, 6, 10000, LOG, 1, 0); p_grainBox->pack_start(*m_dialGrainSize); slot<void> p_slotAttack = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_attack), mem_fun(*this, &GranulatorMonoGUI::get_attack)); m_dialAttack = new LabeledDial("Attack (ms)", p_slotAttack, p_attack, 3, 100, NORMAL, 1, 0); p_grainBox->pack_start(*m_dialAttack); slot<void> p_slotRelease = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_release), mem_fun(*this, &GranulatorMonoGUI::get_release)); m_dialRelease = new LabeledDial("Release (ms)", p_slotRelease, p_release, 3, 100, NORMAL, 1, 0); p_grainBox->pack_start(*m_dialRelease); p_grainFrame->add(*p_grainBox); p_mainWidget->pack_start(*p_grainFrame); Frame *p_textureFrame = manage(new Frame("Texture")); //p_gainFrame->set_shadow_type(Gtk::SHADOW_NONE); HBox *p_textureBox = manage(new HBox(true)); slot<void> p_slotGrainDensity = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_grainDensity), mem_fun(*this, &GranulatorMonoGUI::get_grainDensity)); m_dialGrainDensity = new LabeledDial("Grain Spacing (ms)", p_slotGrainDensity, p_grainDensity, 1, 10000, LOG, 1, 0); p_textureBox->pack_start(*m_dialGrainDensity); slot<void> p_slotGrainSpread = compose(bind<0>(mem_fun(*this, &GranulatorMonoGUI::write_control), p_grainSpread), mem_fun(*this, &GranulatorMonoGUI::get_grainSpread)); m_dialGrainSpread = new LabeledDial("Grain Spread", p_slotGrainSpread, p_grainSpread, 2, 10000, LOG, 1, 0); p_textureBox->pack_start(*m_dialGrainSpread); p_textureFrame->add(*p_textureBox); p_mainWidget->pack_start(*p_textureFrame); p_background->add(*p_mainWidget); p_background->set_size_request(200, 320); add(*p_background); Gtk::manage(p_background); }
void RLight::initGTK() { _optList.reset(new Gtk::VBox); { //Intensity Gtk::HBox* box = manage(new Gtk::HBox); box->show(); { Gtk::Label* label = manage(new Gtk::Label("Intensity and Color", 0.95, 0.5)); box->pack_start(*label, true, true); label->show(); } _intensityEntry.reset(new Gtk::Entry); box->pack_start(*_intensityEntry, false, false); _intensityEntry->show(); _intensityEntry->set_width_chars(7); _intensityEntry->set_text(boost::lexical_cast<std::string>(_intensity)); _intensityEntry->signal_changed() .connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_intensityEntry)); _intensityEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); { _lightColor.reset(new Gtk::ColorButton); _lightColor->set_use_alpha(false); Gdk::Color color; color.set_rgb(_color[0] * G_MAXUSHORT, _color[1] * G_MAXUSHORT, _color[2] * G_MAXUSHORT); _lightColor->set_color(color); box->pack_start(*_lightColor, false, false); _lightColor->show(); _lightColor->signal_color_set().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); } { Gtk::Label* label = manage(new Gtk::Label("Attenuation", 0.95, 0.5)); box->pack_start(*label, true, true); label->show(); } _attenuationEntry.reset(new Gtk::Entry); box->pack_start(*_attenuationEntry, false, false); _attenuationEntry->show(); _attenuationEntry->set_width_chars(7); _attenuationEntry->set_text(boost::lexical_cast<std::string>(_attenuation)); _attenuationEntry->signal_changed() .connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_attenuationEntry)); _attenuationEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); _optList->pack_start(*box, false, false); } { //Specular Gtk::HBox* box = manage(new Gtk::HBox); box->show(); { Gtk::Label* label = manage(new Gtk::Label("Specular Exponent", 0.95, 0.5)); box->pack_start(*label, true, true); label->show(); } _specularExponentEntry.reset(new Gtk::Entry); box->pack_start(*_specularExponentEntry, false, false); _specularExponentEntry->show(); _specularExponentEntry->set_width_chars(7); _specularExponentEntry->set_text(boost::lexical_cast<std::string>(_specularExponent)); _specularExponentEntry->signal_changed() .connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularExponentEntry)); _specularExponentEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); { Gtk::Label* label = manage(new Gtk::Label("Specular Strength", 0.95, 0.5)); box->pack_start(*label, true, true); label->show(); } _specularFactorEntry.reset(new Gtk::Entry); box->pack_start(*_specularFactorEntry, false, false); _specularFactorEntry->show(); _specularFactorEntry->set_width_chars(7); _specularFactorEntry->set_text(boost::lexical_cast<std::string>(_specularFactor)); _specularFactorEntry->signal_changed() .connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry)); _specularFactorEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); _optList->pack_start(*box, false, false); } { //Specular Gtk::HBox* box = manage(new Gtk::HBox); box->show(); { Gtk::Label* label = manage(new Gtk::Label("Position", 0.95, 0.5)); box->pack_start(*label, true, true); label->show(); } _positionXEntry.reset(new Gtk::Entry); box->pack_start(*_positionXEntry, false, false); _positionXEntry->show(); _positionXEntry->set_width_chars(7); _positionXEntry->set_text(boost::lexical_cast<std::string>(getEyeLocationObjSpace()[0])); _positionXEntry->signal_changed().connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry)); _positionXEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); _positionYEntry.reset(new Gtk::Entry); box->pack_start(*_positionYEntry, false, false); _positionYEntry->show(); _positionYEntry->set_width_chars(7); _positionYEntry->set_text(boost::lexical_cast<std::string>(getEyeLocationObjSpace()[1])); _positionYEntry->signal_changed().connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry)); _positionYEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); _positionZEntry.reset(new Gtk::Entry); box->pack_start(*_positionZEntry, false, false); _positionZEntry->show(); _positionZEntry->set_width_chars(7); _positionZEntry->set_text(boost::lexical_cast<std::string>(getEyeLocationObjSpace()[2])); _positionZEntry->signal_changed().connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry)); _positionZEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate)); _optList->pack_start(*box, false, false); } _optList->show(); guiUpdate(); }