示例#1
0
/**
    \brief  Creates a combobox widget for an enumeration parameter
*/
Gtk::Widget *
ParamRadioButton::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal<void> * changeSignal)
{
    if (_gui_hidden) return NULL;

    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4));
    Gtk::VBox * vbox = Gtk::manage(new Gtk::VBox(false, 0));

    Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP));
    label->show();
    hbox->pack_start(*label, false, false);

    Gtk::ComboBoxText* cbt = 0;
    bool comboSet = false;
    if (_mode == MINIMAL) {
        cbt = Gtk::manage(new ComboWdg(this, doc, node));
        cbt->show();
        vbox->pack_start(*cbt, false, false);
    }

    // add choice strings as radiobuttons
    // and select last selected option (_value)
    Gtk::RadioButtonGroup group;
    for (GSList * list = choices; list != NULL; list = g_slist_next(list)) {
        optionentry * entr = reinterpret_cast<optionentry *>(list->data);
        Glib::ustring * text = entr->guitext;
        switch ( _mode ) {
        case MINIMAL:
        {
            cbt->append_text(*text);
            if (!entr->value->compare(_value)) {
                cbt->set_active_text(*text);
                comboSet = true;
            }
        }
        break;
        case COMPACT:
        case FULL:
        {
            ParamRadioButtonWdg * radio = Gtk::manage(new ParamRadioButtonWdg(group, *text, this, doc, node, changeSignal));
            radio->show();
            vbox->pack_start(*radio, true, true);
            if (!entr->value->compare(_value)) {
                radio->set_active();
            }
        }
        break;
        }
    }

    if ( (_mode == MINIMAL) && !comboSet) {
        cbt->set_active(0);
    }

    vbox->show();
    hbox->pack_end(*vbox, false, false);
    hbox->show();


    return dynamic_cast<Gtk::Widget *>(hbox);
}
示例#2
0
void ResViewerViewImpl::setFileContentsByName(std::map<std::string,
    Glib::RefPtr<Gtk::TextBuffer> > FileContents)
{
  Glib::ustring ExistingTabSelection = "";
  if (mp_Notebook->get_current())
    ExistingTabSelection = mp_Notebook->get_current()->get_tab_label_text();

  int TabToSelect = 0;

  while (mp_Notebook->get_n_pages() > 1)
    mp_Notebook->remove_page(1);

  for (std::map<std::string, Glib::RefPtr<Gtk::TextBuffer> >::iterator it =
      FileContents.begin(); it != FileContents.end(); ++it)
  {
    Gtk::TextView* TextView = Gtk::manage(new Gtk::TextView(it->second));
    TextView->set_editable(false);
    TextView->set_visible(true);

    Gtk::ScrolledWindow* Win = Gtk::manage(new Gtk::ScrolledWindow());
    Win->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
    Win->set_visible(true);
    Win->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
    Win->add(*TextView);

    Gtk::Label* TabLabel = Gtk::manage(new Gtk::Label(it->first));
    Gtk::Label* MenuLabel = Gtk::manage(new Gtk::Label(it->first,
        Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER));

    Gtk::Button* SingleGNUplotButton = Gtk::manage(new Gtk::Button(
        _("Plot file with GNUplot\n(All-in-one window)")));
    Gtk::Button* MultiGNUplotButton = Gtk::manage(new Gtk::Button(
        _("Plot file with GNUplot\n(Multiple windows)")));

    Gtk::VBox* RightButtonsBox = Gtk::manage(new Gtk::VBox());
    RightButtonsBox->pack_start(*SingleGNUplotButton, Gtk::PACK_SHRINK);
    RightButtonsBox->pack_start(*MultiGNUplotButton, Gtk::PACK_SHRINK, 5);
    RightButtonsBox->show_all_children(true);
    RightButtonsBox->set_visible(true);

#if WIN32
    SingleGNUplotButton->set_sensitive(false);
    MultiGNUplotButton->set_sensitive(false);
#else
    if (ViewWithGNUplot::IsGNUplotAvailable())
    {
      SingleGNUplotButton->signal_clicked().connect(sigc::bind<Glib::RefPtr<
          Gtk::TextBuffer>, std::string, std::string, std::string, bool>(
          sigc::mem_fun(*this, &ResViewerViewImpl::onGNUplotClicked),
          (Glib::RefPtr<Gtk::TextBuffer>) (it->second), m_DateFormat, m_ColSep,
          m_CommentChar, true));
      SingleGNUplotButton->set_sensitive(true);

      MultiGNUplotButton->signal_clicked().connect(sigc::bind<Glib::RefPtr<
          Gtk::TextBuffer>, std::string, std::string, std::string, bool>(
          sigc::mem_fun(*this, &ResViewerViewImpl::onGNUplotClicked),
          (Glib::RefPtr<Gtk::TextBuffer>) (it->second), m_DateFormat, m_ColSep,
          m_CommentChar, false));
      MultiGNUplotButton->set_sensitive(true);
    }
    else
    {
      SingleGNUplotButton->set_sensitive(false);
      MultiGNUplotButton->set_sensitive(false);
    }
#endif

    Gtk::HBox* MainHBox = Gtk::manage(new Gtk::HBox());
    MainHBox->pack_start(*Win, Gtk::PACK_EXPAND_WIDGET, 5);
    MainHBox->pack_start(*RightButtonsBox, Gtk::PACK_SHRINK, 5);
    MainHBox->set_border_width(8);
    MainHBox->set_visible(true);

    int PageNum = mp_Notebook->append_page(*MainHBox, *TabLabel, *MenuLabel);

    if (it->first == ExistingTabSelection)
      TabToSelect = PageNum;

    mp_Notebook->set_tab_reorderable(*Win, true);
  }

  mp_Notebook->set_current_page(TabToSelect);
}
示例#3
0
  void 
  DataSet::initGtk()
  {
    _gtkOptList.reset(new Gtk::VBox);

    {//The heading of the data set window
      Gtk::Frame* frame = Gtk::manage(new Gtk::Frame("Data Set Information")); frame->show();
      _gtkOptList->pack_start(*frame, false, true, 5);
      Gtk::VBox* vbox = Gtk::manage(new Gtk::VBox); vbox->show();
      frame->add(*vbox);

      _infolabel.reset(new Gtk::Label("Points: " + boost::lexical_cast<std::string>(_N))); 
      _infolabel->show();
      vbox->pack_start(*_infolabel, false, true, 5);	
    }

    //Glyph adding mechanism
    {
      Gtk::HBox* box = Gtk::manage(new Gtk::HBox); box->show();
      _gtkOptList->pack_start(*box, false, false, 5);

      _comboPointSet.reset(new Gtk::ComboBoxText); _comboPointSet->show();
      box->pack_start(*_comboPointSet, false, false, 5);

      //Check the combo box is correct
      _comboPointSet->get_model().clear();
      for (const auto& pointset: _pointSets)
	_comboPointSet->insert(-1, pointset.first);
      _comboPointSet->set_active(0);

      Gtk::Button* btn = Gtk::manage(new Gtk::Button("Add Glyphs"));
      btn->signal_clicked().connect(sigc::mem_fun(*this, &DataSet::addGlyphs));
      btn->show();
      box->pack_start(*btn, false, false, 5);

      _comboLinkSet.reset(new Gtk::ComboBoxText); _comboLinkSet->show();
      box->pack_start(*_comboLinkSet, false, false, 5);
      //Check the combo box is correct
      _comboLinkSet->get_model().clear();
      for (const auto& linkset: _linkSets)
	_comboLinkSet->insert(-1, linkset.first);
      _comboLinkSet->set_active(0);

      btn = Gtk::manage(new Gtk::Button("Add Links"));
      btn->signal_clicked().connect(sigc::mem_fun(*this, &DataSet::addLinkGlyphs));
      btn->show();
      box->pack_start(*btn, false, false, 5);
    }
    
    { 
      _attrcolumns.reset(new ModelColumns);
      _attrtreestore = Gtk::TreeStore::create(*_attrcolumns);
      _attrtreestore->set_sort_column(_attrcolumns->components, Gtk::SORT_DESCENDING);

      _attrview.reset(new Gtk::TreeView);
      _attrview->set_model(_attrtreestore);
      _attrview->append_column("Name", _attrcolumns->name);
      _attrview->append_column("Components", _attrcolumns->components);
      _attrview->append_column("Min Values", _attrcolumns->min);
      _attrview->append_column("Max Values", _attrcolumns->max);
      _attrview->show();
      Gtk::ScrolledWindow* win = Gtk::manage(new Gtk::ScrolledWindow);
      win->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
      win->add(*_attrview);

      Gtk::Frame* frame = Gtk::manage(new Gtk::Frame("Available Attributes")); frame->show();
      frame->add(*win);
      _gtkOptList->pack_start(*frame, true, true, 5);
      win->show();
    }

    {
      _positionSel.reset(new AttributeSelector(false));
      _gtkOptList->pack_start(*_positionSel, false, false);
    }

    _gtkOptList->show();
    rebuildGui();
  }
示例#4
0
WidgetExpanderBase::WidgetExpanderBase() :
  WidgetExpander()
{
  mp_ColorButton = Gtk::manage(new Gtk::ColorButton(getARandColor()));

  mp_WidthSpinButton = Gtk::manage(new Gtk::SpinButton());
  mp_WidthSpinButton->set_range(1, 100);
  mp_WidthSpinButton->set_increments(1, 10);
  mp_WidthSpinButton->set_numeric(true);
  mp_WidthSpinButton->set_value(1);

  mp_OpacityHScale = Gtk::manage(new Gtk::HScale(0, 101, 1));
  mp_OpacityHScale->set_value_pos(Gtk::POS_LEFT);
  mp_OpacityHScale->set_value(100);
  mp_OpacityHScale->set_update_policy(Gtk::UPDATE_DELAYED);

  mp_ShowIDCheckBox = Gtk::manage(new Gtk::CheckButton(_("Show units IDs")));
  //  mp_CheckButtonGraph = Gtk::manage(new Gtk::CheckButton(_("show graph")));

  Gtk::HBox* ColorButtonBox = Gtk::manage(new Gtk::HBox());
  ColorButtonBox->pack_start(*mp_ColorButton, Gtk::PACK_SHRINK);

  Gtk::HBox* WidthSpinButtonBox = Gtk::manage(new Gtk::HBox());
  WidthSpinButtonBox->pack_start(*mp_WidthSpinButton, Gtk::PACK_SHRINK);

  Gtk::Table* mp_MainTable = Gtk::manage(new Gtk::Table());
  mp_MainTable->set_col_spacings(5);
  mp_MainTable->attach(*Gtk::manage(new Gtk::Label(_("Color:"), 0, 0.5)), 0, 1,
      0, 1, Gtk::FILL, Gtk::SHRINK);
  mp_MainTable->attach(*Gtk::manage(new Gtk::Label(_("Width:"), 0, 0.5)), 0, 1,
      1, 2, Gtk::FILL, Gtk::SHRINK);
  mp_MainTable->attach(*Gtk::manage(new Gtk::Label(_("Opacity:"), 0, 0.5)), 0,
      1, 2, 3, Gtk::FILL, Gtk::SHRINK);
  mp_MainTable->attach(*ColorButtonBox, 1, 2, 0, 1, Gtk::FILL, Gtk::SHRINK);
  mp_MainTable->attach(*WidthSpinButtonBox, 1, 2, 1, 2, Gtk::FILL, Gtk::SHRINK);
  mp_MainTable->attach(*mp_OpacityHScale, 1, 2, 2, 3, Gtk::FILL | Gtk::EXPAND,
      Gtk::SHRINK);
  mp_MainTable->attach(*mp_ShowIDCheckBox, 0, 2, 3, 4, Gtk::FILL, Gtk::SHRINK);
  //  mp_MainTable->attach(*mp_CheckButtonGraph, 0, 2, 4, 5, Gtk::FILL, Gtk::SHRINK);

  Gtk::Alignment* MainTableAlign = Gtk::manage(new Gtk::Alignment());
  MainTableAlign->set_padding(10, 20, 20, 0);
  MainTableAlign->add(*mp_MainTable);

  mp_MainExpander->set_label(_("Style"));
  mp_MainExpander->add(*MainTableAlign);
  mp_MainExpander->show_all_children();

  //******************Signal connexion*********************

  mp_ColorButton->signal_color_set().connect(sigc::mem_fun(*this,
      &WidgetExpanderBase::onWidgetExpanderBaseChanged));
  mp_WidthSpinButton->signal_value_changed().connect(sigc::mem_fun(*this,
      &WidgetExpanderBase::onWidgetExpanderBaseChanged));
  mp_OpacityHScale->signal_value_changed().connect(sigc::mem_fun(*this,
      &WidgetExpanderBase::onWidgetExpanderBaseChanged));
  mp_ShowIDCheckBox->signal_toggled().connect(sigc::mem_fun(*this,
      &WidgetExpanderBase::onWidgetExpanderBaseChanged));
  //  mp_CheckButtonGraph->signal_toggled().connect(
  //      sigc::mem_fun(*this, &WidgetExpanderBase::onWidgetExpanderBaseChanged));
}
示例#5
0
HistorySubMenu::HistorySubMenu( const std::string& url_history )
    : Gtk::Menu(),
      m_url_history( url_history )
{
    Gtk::MenuItem* item;

    // メニュー項目作成

    // 履歴クリア
    Gtk::Menu* menu = Gtk::manage( new Gtk::Menu() );
    item = Gtk::manage( new Gtk::MenuItem( "クリアする(_C)", true ) );
    menu->append( *item );
    item->signal_activate().connect( sigc::mem_fun( *this, &HistorySubMenu::slot_clear ) ); 

    item = Gtk::manage( new Gtk::MenuItem( "履歴クリア(_C)", true ) );
    item->set_submenu( *menu );
    append( *item );

    item = Gtk::manage( new Gtk::MenuItem( "サイドバーに全て表示(_S)", true ) );
    append( *item );
    item->signal_activate().connect( sigc::mem_fun( *this, &HistorySubMenu::slot_switch_sideber ) );

    // セパレータ
    item = Gtk::manage( new Gtk::SeparatorMenuItem() );
    append( *item );

    // 履歴項目
    for( int i = 0; i < CONFIG::get_history_size(); ++i ){

        Gtk::Image* image = Gtk::manage( new Gtk::Image() );
        m_vec_images.push_back( image );

        Gtk::Label* label = Gtk::manage( new Gtk::Label( HIST_NONAME ) );
        m_vec_label.push_back( label );

        Gtk::Label *label_motion = Gtk::manage( new Gtk::Label() );
        if( i == 0 ) label_motion->set_text( CONTROL::get_str_motions( CONTROL::RestoreLastTab ) );

        Gtk::HBox* hbox = Gtk::manage( new Gtk::HBox() );
        hbox->set_spacing( SPACING_MENU );
        hbox->pack_start( *image, Gtk::PACK_SHRINK );
        hbox->pack_start( *label, Gtk::PACK_SHRINK );
        hbox->pack_end( *label_motion, Gtk::PACK_SHRINK );

        Gtk::MenuItem* item = Gtk::manage( new Gtk::MenuItem( *hbox ) );
        append( *item );
        item->signal_activate().connect( sigc::bind< int >( sigc::mem_fun( *this, &HistorySubMenu::slot_active ), i ) );
        item->signal_button_press_event().connect( sigc::bind< int >( sigc::mem_fun( *this, &HistorySubMenu::slot_button_press ), i ) );
    }

    // ポップアップメニュー作成
    m_popupmenu.signal_deactivate().connect( sigc::mem_fun( *this, &HistorySubMenu::deactivate ) );

    item = Gtk::manage( new Gtk::MenuItem( "タブで開く" ) );
    item->signal_activate().connect( sigc::mem_fun( *this, &HistorySubMenu::slot_open_history ) );
    m_popupmenu.append( *item );

    item = Gtk::manage( new Gtk::SeparatorMenuItem() );
    m_popupmenu.append( *item );

    item = Gtk::manage( new Gtk::MenuItem( "履歴から削除" ) );
    item->signal_activate().connect( sigc::mem_fun( *this, &HistorySubMenu::slot_remove_history ) );
    m_popupmenu.append( *item );

    item = Gtk::manage( new Gtk::SeparatorMenuItem() );
    m_popupmenu.append( *item );

    item = Gtk::manage( new Gtk::MenuItem( "プロパティ" ) );
    item->signal_activate().connect( sigc::mem_fun( *this, &HistorySubMenu::slot_show_property ) );
    m_popupmenu.append( *item );

    m_popupmenu.show_all_children();
}
void ModelStructureModule::compose()
{
  mp_MainPanel = Gtk::manage(new Gtk::VPaned());

  Gtk::VBox* ButtonsPanel = Gtk::manage(new Gtk::VBox());
  ButtonsPanel->pack_start(*mp_StructureListToolBox->asWidget(),Gtk::PACK_SHRINK);
  ButtonsPanel->set_visible(true);

  Gtk::HBox* TopPanel = Gtk::manage(new Gtk::HBox());
  TopPanel->set_border_width(5);
  TopPanel->pack_start(*mp_ModelStructureMVP->asWidget(),Gtk::PACK_EXPAND_WIDGET,5);
  TopPanel->pack_start(*ButtonsPanel, Gtk::PACK_SHRINK,5);
  TopPanel->pack_start(*mp_ModelFctDetailMVP->asWidget(),Gtk::PACK_SHRINK,5);
  TopPanel->set_visible(true);
  TopPanel->set_border_width(6);

  Gtk::HBox* BottomPanel = Gtk::manage(new Gtk::HBox());
  BottomPanel->set_border_width(5);
  BottomPanel->pack_start(*mp_ModelParamsPanel->asWidget());
  BottomPanel->set_visible(true);
  BottomPanel->set_border_width(6);

  BuilderFrame* TopFrame = Gtk::manage(new BuilderFrame());
  TopFrame->setLabelText(_("Model definition"));
  TopFrame->set_visible(true);
  TopFrame->add(*TopPanel);

  BuilderFrame* BottomFrame = Gtk::manage(new BuilderFrame());
  BottomFrame->setLabelText(_("Model parameters"));
  BottomFrame->set_visible(true);
  BottomFrame->add(*BottomPanel);

  mp_MainPanel->pack1(*TopFrame, true,false);
  mp_MainPanel->pack2(*BottomFrame, true,false);
  mp_MainPanel->set_visible(true);
}
示例#7
0
  void
  RVolume::initGTK()
  {
    _optList.reset(new Gtk::VBox);//The Vbox of options   

    {//Transfer function widget
      _transferFunction.reset(new magnet::gtk::TransferFunction
			      (magnet::function::MakeDelegate
			       (this, &RVolume::transferFunctionUpdated)));
      _transferFunction->set_size_request(-1, 100);
      
      _optList->add(*_transferFunction); _transferFunction->show();
      transferFunctionUpdated(); //Force an update of the transfer function now we have the widget
    }

    {//Volume renderer step size
      _stepSize.reset(new Gtk::Entry);
      Gtk::HBox* box = manage(new Gtk::HBox);	
      Gtk::Label* label = manage(new Gtk::Label("Raytrace Step Size"));
      box->pack_start(*label, false, false); label->show();
      box->pack_end(*_stepSize, false, false);
      _stepSize->show(); _stepSize->set_text("0.01");      
      _optList->add(*box); box->show();
    }

    {//Diffusive lighting
      Gtk::HBox* box = manage(new Gtk::HBox);	
      Gtk::Label* label = manage(new Gtk::Label("Diffuse Lighting"));
      box->pack_start(*label, false, false); label->show();
      _diffusiveLighting.reset(new Gtk::HScale);
      box->pack_end(*_diffusiveLighting, true, true);
      _diffusiveLighting->set_range(0,2);
      _diffusiveLighting->set_digits(3);
      _diffusiveLighting->show();      
      _diffusiveLighting->set_value(1.0);
      _optList->add(*box); box->show();
    }

    {//Specular lighting
      Gtk::HBox* box = manage(new Gtk::HBox);	
      Gtk::Label* label = manage(new Gtk::Label("Specular Lighting"));
      box->pack_start(*label, false, false); label->show();
      _specularLighting.reset(new Gtk::HScale);
      box->pack_end(*_specularLighting, true, true);
      _specularLighting->set_range(0,2);
      _specularLighting->set_digits(3);
      _specularLighting->show();      
      _specularLighting->set_value(1.0);
      _optList->add(*box); box->show();
    }

    {//Ray Dithering
      Gtk::HBox* box = manage(new Gtk::HBox);	
      Gtk::Label* label = manage(new Gtk::Label("Ray Dithering"));
      box->pack_start(*label, false, false); label->show();
      _ditherRay.reset(new Gtk::HScale);
      box->pack_end(*_ditherRay, true, true);
      _ditherRay->set_range(0, 1);
      _ditherRay->set_digits(3);
      _ditherRay->show();
      _ditherRay->set_value(1.0);
      _optList->add(*box); box->show();
    }
    
    _optList->show();
    //Callbacks
    _stepSize->signal_changed()
      .connect(sigc::bind<Gtk::Entry&>(&magnet::Gtk::forceNumericEntry, *_stepSize));
    _stepSize->signal_activate().connect(sigc::mem_fun(*this, &RVolume::guiUpdate));

    guiUpdate();
  }
示例#8
0
  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();
  }
示例#9
0
PreferencesDialogImpl::PreferencesDialogImpl() : Gtk::Dialog()
{
    m_editorEntry = NULL;
    m_ctagsEntry = NULL;

    // dialog properties
    set_title("Preferences");
    set_position(GTK_WIN_POS_CENTER);
    set_modal(true);
    set_border_width(10);
    set_policy(false, false, true);

    // create the Default button
    Gtk::Button* defaultButton = manage(new Gtk::Button("Default"));
    defaultButton->clicked.connect(SigC::slot(this, &PreferencesDialogImpl::defaultButtonCB));
    defaultButton->set_usize(80, -1);
    defaultButton->set_flags(GTK_CAN_DEFAULT);
    defaultButton->show();

    // create the Apply button
    Gtk::Button* applyButton = manage(new Gtk::Button("Apply"));
    applyButton->clicked.connect(SigC::slot(this, &PreferencesDialogImpl::applyButtonCB));
    applyButton->set_usize(80, -1);
    applyButton->set_flags(GTK_CAN_DEFAULT);
    applyButton->show();

    // create the OK button and make it default
    Gtk::Button* okButton = manage(new Gtk::Button("OK"));
    okButton->clicked.connect(SigC::slot(this, &PreferencesDialogImpl::okButtonCB));
    okButton->set_usize(80, -1);
    okButton->set_flags(GTK_CAN_DEFAULT);
    okButton->grab_default();
    okButton->show();

    // create the Cancel button
    Gtk::Button* cancelButton = manage(new Gtk::Button("Cancel"));
    cancelButton->clicked.connect(SigC::slot(this, &PreferencesDialogImpl::cancelButtonCB));
    cancelButton->set_usize(80, -1);
    cancelButton->set_flags(GTK_CAN_DEFAULT);
    cancelButton->show();

    // add the buttons to the hbox
    Gtk::HBox* hbox = get_action_area();
    hbox->set_spacing(10);
    hbox->pack_start(*defaultButton, false, false);
    hbox->pack_start(*applyButton, false, false);
    hbox->pack_start(*okButton, false, false);
    hbox->pack_start(*cancelButton, false, false);

    // editor stuff
    Gtk::HBox* editorBox = manage(new Gtk::HBox());
    Gtk::Label* editorLabel = manage(new Gtk::Label("Editor Command: "));
    editorLabel->show();
    editorBox->pack_start(*editorLabel, false, false);
    m_editorEntry = manage(new Gtk::Entry());
    m_editorEntry->set_text(g_configMap[Config::EDITOR[0]]);
    m_editorEntry->show();
    editorBox->pack_end(*m_editorEntry);
    editorBox->show();

    // ctags stuff
    Gtk::HBox* ctagsBox = manage(new Gtk::HBox());
    Gtk::Label* ctagsLabel = manage(new Gtk::Label("Ctags Command: "));
    ctagsLabel->show();
    ctagsBox->pack_start(*ctagsLabel, false, false);
    m_ctagsEntry = manage(new Gtk::Entry());
    m_ctagsEntry->set_text(g_configMap[Config::CTAGS[0]]);
    m_ctagsEntry->show();
    ctagsBox->pack_end(*m_ctagsEntry);
    ctagsBox->show();

    // add everything to the vbox
    Gtk::VBox* vbox = get_vbox();
    vbox->set_spacing(5);
    vbox->pack_start(*editorBox, false, false);
    vbox->pack_start(*ctagsBox, false, false);

    show();
    Gtk::Main::run();
}
ModelGeneratorCreationDialog::ModelGeneratorCreationDialog(
    openfluid::core::CoreRepository& CoreRepos,
    openfluid::machine::ModelInstance* ModelInstance) :
  mp_CoreRepos(&CoreRepos), mp_ModelInstance(ModelInstance)
{
  mp_VarNameEntry = Gtk::manage(new Gtk::Entry());
  mp_VarNameEntry->set_activates_default(true);
  mp_VarNameEntry->signal_changed().connect(sigc::mem_fun(*this,
      &ModelGeneratorCreationDialog::onVarNameEntryChanged));

  mp_ClassCombo = Gtk::manage(new Gtk::ComboBoxText());

  Gtk::RadioButton::Group RadioGrp;

  mp_ScalarRadio = Gtk::manage(
      new Gtk::RadioButton(RadioGrp, _("Double Value")));
  mp_VectorRadio = Gtk::manage(new Gtk::RadioButton(RadioGrp,
      _("Vector Value:") + std::string(" ")));

  mp_VarSizeSpin = Gtk::manage(new Gtk::SpinButton());
  mp_VarSizeSpin->set_numeric(true);
  mp_VarSizeSpin->set_increments(1, 1);
  mp_VarSizeSpin->set_range(2.0, 9.0);
  mp_VarSizeSpin->set_activates_default(true);

  Gtk::Table* GenInfoTable = Gtk::manage(new Gtk::Table());
  GenInfoTable->set_row_spacings(10);
  GenInfoTable->set_col_spacings(3);
  GenInfoTable->attach(
      *Gtk::manage(new Gtk::Label(_("Variable name"), 1, 0.5)), 0, 1, 0, 1,
      Gtk::FILL, Gtk::SHRINK);
  GenInfoTable->attach(*mp_VarNameEntry, 1, 2, 0, 1, Gtk::SHRINK, Gtk::SHRINK);
  GenInfoTable->attach(*Gtk::manage(new Gtk::Label(_("Unit class"), 1, 0.5)),
      0, 1, 1, 2, Gtk::FILL, Gtk::SHRINK);
  GenInfoTable->attach(*mp_ClassCombo, 1, 2, 1, 2, Gtk::FILL, Gtk::SHRINK);

  Gtk::HBox* VectorBox = Gtk::manage(new Gtk::HBox());
  VectorBox->pack_start(*mp_VectorRadio, Gtk::PACK_SHRINK);
  VectorBox->pack_start(*Gtk::manage(new Gtk::Label(_("Size"))),
      Gtk::PACK_SHRINK);
  VectorBox->pack_start(*mp_VarSizeSpin, Gtk::PACK_SHRINK);

  mp_Dialog = new Gtk::Dialog(_("Generator creation"));

  mp_InfoBarLabel = Gtk::manage(new Gtk::Label(""));

  mp_InfoBar = Gtk::manage(new Gtk::InfoBar());
  mp_InfoBar->set_message_type(Gtk::MESSAGE_WARNING);
  ((Gtk::Container*) mp_InfoBar->get_content_area())->add(*mp_InfoBarLabel);

  mp_Dialog->get_vbox()->pack_start(*mp_InfoBar, Gtk::PACK_SHRINK);
  mp_Dialog->get_vbox()->pack_start(*GenInfoTable, Gtk::PACK_SHRINK, 10);
  mp_Dialog->get_vbox()->pack_start(*mp_ScalarRadio, Gtk::PACK_SHRINK);
  mp_Dialog->get_vbox()->pack_start(*VectorBox, Gtk::PACK_SHRINK, 10);

  mp_Dialog->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
  mp_Dialog->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

  mp_Dialog->set_default_response(Gtk::RESPONSE_OK);

  mp_Dialog->show_all_children();

}
void StimResponseEditor::populateWindow()
{
	// Create the overall vbox
	_dialogVBox = Gtk::manage(new Gtk::VBox(false, 12));
	add(*_dialogVBox);

	// Create the notebook and add it to the vbox
	_notebook = Gtk::manage(new Gtk::Notebook);
	_dialogVBox->pack_start(*_notebook, true, true, 0);

	// The tab label items (icon + label)
	Gtk::HBox* stimLabelHBox = Gtk::manage(new Gtk::HBox(false, 0));
	stimLabelHBox->pack_start(
		*Gtk::manage(new Gtk::Image(
			GlobalUIManager().getLocalPixbufWithMask(ICON_STIM + SUFFIX_EXTENSION))),
    	false, false, 3
    );
	stimLabelHBox->pack_start(*Gtk::manage(new Gtk::Label(_("Stims"))), false, false, 3);

	Gtk::HBox* responseLabelHBox = Gtk::manage(new Gtk::HBox(false, 0));
	responseLabelHBox->pack_start(
		*Gtk::manage(new Gtk::Image(
			GlobalUIManager().getLocalPixbufWithMask(ICON_RESPONSE + SUFFIX_EXTENSION))),
    	false, false, 3
    );
	responseLabelHBox->pack_start(*Gtk::manage(new Gtk::Label(_("Responses"))), false, false, 3);

	Gtk::HBox* customLabelHBox = Gtk::manage(new Gtk::HBox(false, 0));
	customLabelHBox->pack_start(
		*Gtk::manage(new Gtk::Image(
			GlobalUIManager().getLocalPixbufWithMask(ICON_CUSTOM_STIM))),
    	false, false, 3
    );
	customLabelHBox->pack_start(*Gtk::manage(new Gtk::Label(_("Custom Stims"))), false, false, 3);

	// Show the widgets before using them as label, they won't appear otherwise
	stimLabelHBox->show_all();
	responseLabelHBox->show_all();
	customLabelHBox->show_all();

	// Cast the helper class to a widget and add it to the notebook page
	_stimPageNum = _notebook->append_page(*_stimEditor, *stimLabelHBox);
	_responsePageNum = _notebook->append_page(*_responseEditor, *responseLabelHBox);
	_customStimPageNum = _notebook->append_page(*_customStimEditor, *customLabelHBox);

	if (_lastShownPage == -1)
	{
		_lastShownPage = _stimPageNum;
	}

	// Pack in dialog buttons
	_dialogVBox->pack_start(createButtons(), false, false, 0);
}
示例#12
0
Example_markers::Example_markers()
{
  Gtk::VBox *vbox, *vbox2;
  Gtk::HBox *hbox;
  Gtk::RadioButton *rbutton;
  
  set_title("Line Markers Example");
  set_border_width(10);

  m_Viewport.canvas()->set_size( 500, 400 );

  vbox = Gtk::manage(new Gtk::VBox());
  vbox->pack_start( m_Viewport );
  m_line = Papyrus::Polyline::create();
  m_line->add_vertex(-100, 0);
  m_line->add_vertex(100, 0);
  m_line->set_stroke( Cairo::SolidPattern::create_rgb(0.0, 0.0, 1.0) );
  m_line->stroke()->set_width(3);

  m_line->set_marker(Papyrus::START_MARKER, Papyrus::Marker::create());
  m_line->marker(Papyrus::START_MARKER)->set_facing(Papyrus::Marker::LEFT);
  m_line->marker(Papyrus::START_MARKER)->stroke()->set_width(3);
  
  m_line->set_marker(Papyrus::END_MARKER, Papyrus::Marker::create());
  m_line->marker(Papyrus::END_MARKER)->set_facing(Papyrus::Marker::RIGHT);
  m_line->marker(Papyrus::END_MARKER)->stroke()->set_width(3);
  
  m_Viewport.canvas()->add( m_line );

  vbox->pack_start( *Gtk::manage( new Gtk::HSeparator() ) );

  hbox = Gtk::manage(new Gtk::HBox());
  vbox->pack_start( *hbox );

  vbox2 = Gtk::manage(new Gtk::VBox());
  vbox2->pack_start( *Gtk::manage(new Gtk::Label("Start Marker")) );
  vbox2->pack_start( m_start_combobox );
  Gtk::RadioButtonGroup start_facing_group;
  rbutton = Gtk::manage(new Gtk::RadioButton(start_facing_group, "Left"));
  rbutton->set_active();
  rbutton->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Example_markers::on_marker_facing_changed), Papyrus::START_MARKER, Papyrus::Marker::LEFT));
  vbox2->pack_start(*rbutton);
  rbutton = Gtk::manage(new Gtk::RadioButton(start_facing_group, "Right"));
  rbutton->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Example_markers::on_marker_facing_changed), Papyrus::START_MARKER, Papyrus::Marker::RIGHT));
  vbox2->pack_start(*rbutton);
  hbox->pack_start(*vbox2);

  vbox2 = Gtk::manage(new Gtk::VBox());
  vbox2->pack_start( *Gtk::manage(new Gtk::Label("End Marker")) );
  vbox2->pack_start( m_end_combobox );
  Gtk::RadioButtonGroup end_facing_group;
  rbutton = Gtk::manage(new Gtk::RadioButton(end_facing_group, "Left"));
  rbutton->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Example_markers::on_marker_facing_changed), Papyrus::END_MARKER, Papyrus::Marker::LEFT));
  vbox2->pack_start(*rbutton);
  rbutton = Gtk::manage(new Gtk::RadioButton(end_facing_group, "Right"));
  rbutton->set_active();
  rbutton->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Example_markers::on_marker_facing_changed), Papyrus::END_MARKER, Papyrus::Marker::RIGHT));
  vbox2->pack_start(*rbutton);
  hbox->pack_start(*vbox2);

  for (unsigned i=Papyrus::Marker::FIRST_STYLE; i < Papyrus::Marker::LAST_STYLE; i++)
  {
    m_start_combobox.append_text( Papyrus::Marker::style_strings[i] );
    m_end_combobox.append_text( Papyrus::Marker::style_strings[i] );
  }

  m_start_combobox.signal_changed().connect( sigc::bind(sigc::mem_fun(*this, &Example_markers::on_marker_style_changed), Papyrus::START_MARKER));

  m_start_combobox.set_active(Papyrus::Marker::NONE);

  m_end_combobox.signal_changed().connect( sigc::bind(sigc::mem_fun(*this, &Example_markers::on_marker_style_changed), Papyrus::END_MARKER));

  m_end_combobox.set_active(Papyrus::Marker::NONE);

  this->add( *vbox );

  show_all();
}
示例#13
0
Widget_Preview::Widget_Preview():
	Gtk::Table(1, 5),
	adj_time_scrub(Gtk::Adjustment::create(0, 0, 1000, 0, 10, 0)),
	scr_time_scrub(adj_time_scrub),
	b_loop(/*_("Loop")*/),
	currentindex(-100000),//TODO get the value from canvas setting or preview option
	timedisp(-1),
	audiotime(0),
	jackbutton(),
	offset_widget(),
	adj_sound(Gtk::Adjustment::create(0, 0, 4)),
	l_lasttime("0s"),
	playing(false),
	singleframe(),
	toolbarisshown(),
	zoom_preview(true),
	toolbar(),
	play_button(),
	pause_button(),
	jackdial(NULL),
	jack_enabled(false),
	jack_is_playing(false),
	jack_time(0),
	jack_offset(0),
	jack_initial_time(0)
#ifdef WITH_JACK
	,
	jack_client(NULL),
	jack_synchronizing(false)
#endif
{
	//catch key press event for shortcut keys
	signal_key_press_event().connect(sigc::mem_fun(*this, &Widget_Preview::on_key_pressed));

	//connect to expose events
	//signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Preview::redraw));

	//manage all the change in values etc...

	//1st row: preview content
	preview_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	//pack preview content into scrolled window
	preview_window.add(draw_area);

	//preview window background color - Not working anymore after version 3.16!
	//https://developer.gnome.org/gtk3/unstable/GtkWidget.html#gtk-widget-override-background-color
	Gdk::RGBA bg_color;
	bg_color.set_red(54*256);
	bg_color.set_blue(59*256);
	bg_color.set_green(59*256);
	draw_area.override_background_color(bg_color);

	adj_time_scrub->signal_value_changed().connect(sigc::mem_fun(*this, &Widget_Preview::slider_move));
	scr_time_scrub.signal_event().connect(sigc::mem_fun(*this, &Widget_Preview::scroll_move_event));
	draw_area.signal_draw().connect(sigc::mem_fun(*this, &Widget_Preview::redraw));

	scr_time_scrub.set_draw_value(0);

	Gtk::Button *button = 0;
	Gtk::Image  *icon   = 0;

	#if 1

	//2nd row: prevframe play/pause nextframe loop | halt-render re-preview erase-all
	toolbar = Gtk::manage(new class Gtk::HBox(false, 0));

	//prev rendered frame
	Gtk::Button *prev_framebutton;
	Gtk::Image *icon0 = manage(new Gtk::Image(Gtk::StockID("synfig-animate_seek_prev_frame"), Gtk::ICON_SIZE_BUTTON));
	prev_framebutton = manage(new class Gtk::Button());
	prev_framebutton->set_tooltip_text(_("Prev frame"));
	icon0->set_padding(0,0);
	icon0->show();
	prev_framebutton->add(*icon0);
	prev_framebutton->set_relief(Gtk::RELIEF_NONE);
	prev_framebutton->show();
	prev_framebutton->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &Widget_Preview::seek_frame), -1));

	toolbar->pack_start(*prev_framebutton, Gtk::PACK_SHRINK, 0);

	{ //play
		Gtk::Image *icon = manage(new Gtk::Image(Gtk::StockID("synfig-animate_play"), Gtk::ICON_SIZE_BUTTON));
		play_button = manage(new class Gtk::Button());
		play_button->set_tooltip_text(_("Play"));
		icon->set_padding(0,0);
		icon->show();
		play_button->add(*icon);
		play_button->set_relief(Gtk::RELIEF_NONE);
		play_button->show();
		play_button->signal_clicked().connect(sigc::mem_fun(*this, &Widget_Preview::on_play_pause_pressed));
		toolbar->pack_start(*play_button, Gtk::PACK_SHRINK, 0);
	}

	{ //pause
		Gtk::Image *icon = manage(new Gtk::Image(Gtk::StockID("synfig-animate_pause"), Gtk::ICON_SIZE_BUTTON));
		pause_button = manage(new class Gtk::Button());
		pause_button->set_tooltip_text(_("Pause"));
		icon->set_padding(0,0);
		icon->show();
		pause_button->add(*icon);
		pause_button->set_relief(Gtk::RELIEF_NONE);
		pause_button->signal_clicked().connect(sigc::mem_fun(*this, &Widget_Preview::on_play_pause_pressed));
		toolbar->pack_start(*pause_button, Gtk::PACK_SHRINK, 0);
	}


	//next rendered frame
	Gtk::Button *next_framebutton;
	Gtk::Image *icon2 = manage(new Gtk::Image(Gtk::StockID("synfig-animate_seek_next_frame"), Gtk::ICON_SIZE_BUTTON));
	next_framebutton = manage(new class Gtk::Button());
	next_framebutton->set_tooltip_text(_("Next frame"));
	icon2->set_padding(0,0);
	icon2->show();
	next_framebutton->add(*icon2);
	next_framebutton->set_relief(Gtk::RELIEF_NONE);
	next_framebutton->show();
	next_framebutton->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &Widget_Preview::seek_frame), 1));

	toolbar->pack_start(*next_framebutton, Gtk::PACK_SHRINK, 0);

	//spacing
	Gtk::Alignment *space = Gtk::manage(new Gtk::Alignment());
	space->set_size_request(8);
	toolbar->pack_start(*space, false, true);


	//loop
	button = &b_loop;
	IMAGIFY_BUTTON(button,"synfig-animate_loop", _("Loop"));
	toolbar->pack_start(b_loop, Gtk::PACK_SHRINK,0);

	//spacing
	Gtk::Alignment *space1 = Gtk::manage(new Gtk::Alignment());
	space1->set_size_request(24);
	toolbar->pack_start(*space1, false, true);


	//halt render
	button = manage(new Gtk::Button(/*_("Halt Render")*/));
	button->signal_clicked().connect(sigc::mem_fun(*this, &Widget_Preview::stoprender));
	IMAGIFY_BUTTON(button,Gtk::Stock::STOP, _("Halt render"));

	toolbar->pack_start(*button, Gtk::PACK_SHRINK, 0);

	//re-preview
	button = manage(new Gtk::Button(/*_("Re-Preview")*/));
	button->signal_clicked().connect(sigc::mem_fun(*this, &Widget_Preview::repreview));
	IMAGIFY_BUTTON(button, Gtk::Stock::EDIT, _("Re-preview"));

	toolbar->pack_start(*button, Gtk::PACK_SHRINK, 0);

	//erase all
	button = manage(new Gtk::Button(/*_("Erase All")*/));
	button->signal_clicked().connect(sigc::mem_fun(*this, &Widget_Preview::eraseall));
	IMAGIFY_BUTTON(button, Gtk::Stock::CLEAR, _("Erase all rendered frame(s)"));

	toolbar->pack_start(*button, Gtk::PACK_SHRINK, 0);

	//spacing
	Gtk::Alignment *space2 = Gtk::manage(new Gtk::Alignment());
	space1->set_size_request(24);
	toolbar->pack_start(*space2, false, true);

	//jack
	jackdial = Gtk::manage(new JackDial());
#ifdef WITH_JACK
	jack_dispatcher.connect(sigc::mem_fun(*this, &Widget_Preview::on_jack_sync));
	jack_dispatcher.connect(sigc::mem_fun(*this, &Widget_Preview::on_jack_sync));

	jackbutton = jackdial->get_toggle_jackbutton();
	jackdial->signal_toggle_jack().connect(sigc::mem_fun(*this, &studio::Widget_Preview::toggle_jack_button));
	jackdial->signal_offset_changed().connect(sigc::mem_fun(*this, &studio::Widget_Preview::on_jack_offset_changed));
#endif
	//FIXME: Hardcoded FPS!
	jackdial->set_fps(24.f);
	jackdial->set_offset(jack_offset);
	if ( !getenv("SYNFIG_DISABLE_JACK") )
		jackdial->show();
	toolbar->pack_start(*jackdial, false, true);

	//zoom preview
	factor_refTreeModel = Gtk::ListStore::create(factors);
	zoom_preview.set_model(factor_refTreeModel);
	zoom_preview.property_has_frame() = true;
	zoom_preview.signal_changed().connect(sigc::mem_fun(*this, &Widget_Preview::preview_draw));

	Gtk::TreeModel::Row row = *(factor_refTreeModel->append());
	row[factors.factor_id] = "1";
	row[factors.factor_value] = "25%";

	row = *(factor_refTreeModel->append());
	row[factors.factor_id] = "2";
	row[factors.factor_value] = "50%";

	row = *(factor_refTreeModel->append());
	row[factors.factor_id] = "3";
	row[factors.factor_value] = "100%";

	row = *(factor_refTreeModel->append());
	row[factors.factor_id]  = "4";
	row[factors.factor_value] = "200%";

	row = *(factor_refTreeModel->append());
	row[factors.factor_id] = "5";
	row[factors.factor_value] = _("Fit");
	zoom_preview.set_entry_text_column(factors.factor_value);

	Gtk::Entry* entry = zoom_preview.get_entry();
	entry->set_text("100%"); //default zoom level
	entry->set_icon_from_stock(Gtk::StockID("synfig-zoom"));
	entry->signal_activate().connect(sigc::mem_fun(*this, &Widget_Preview::on_zoom_entry_activated));

	//set the zoom widget width
	zoom_preview.set_size_request(100, -1);
	zoom_preview.show();

	toolbar->pack_end(zoom_preview, Gtk::PACK_SHRINK, 0);

	show_toolbar();

	//3rd row: previewing frame numbering and rendered frame numbering
	Gtk::HBox *status = manage(new Gtk::HBox);
	status->pack_start(l_currenttime, Gtk::PACK_SHRINK, 5);
	Gtk::Label *separator = manage(new Gtk::Label(" / "));
	status->pack_start(*separator, Gtk::PACK_SHRINK, 0);
	status->pack_start(l_lasttime, Gtk::PACK_SHRINK, 5);

	status->show_all();

	// attach all widgets
	attach(preview_window, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0);
	attach(scr_time_scrub, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
	attach(*toolbar,       0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL);
	attach(*status,        0, 1, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
	preview_window.show_all();
	scr_time_scrub.show_all();

	//if(draw_area.get_window()) gc_area = Gdk::GC::create(draw_area.get_window());
	#endif
}
PanelEscenario::PanelEscenario(string rutaNivel,
                               InformableSeleccion* informable,
                               int cantidadJugadores,
                               bool nivelNuevo) {
    this->cantidadJugadores = cantidadJugadores;
    this->rutaNivel = rutaNivel;
    this->informable = informable;
    cargarCaracteristicasNivel();
    int ancho = (int)(anchoFlotante * PIXELES_SOBRE_METRO);
    int alto = (int)(altoFlotante * PIXELES_SOBRE_METRO);
    // Inicializacion de los widgets propios
    lienzo = new Lienzo(ancho, alto, cantidadJugadores, rutaFondo, rutaSuelo, informable);
    paletaEscenario = new PaletaEscenario();
    eliminador = new EliminadorPosicionables(lienzo);
    entrada = new EntradaPajaros(anchoFlotante, altoFlotante);
    if (!nivelNuevo) {
        lienzo->cargarNivel(rutaNivel);
        entrada->cargarNivel(rutaNivel);
    }
    // Inicializacion del boton para guardar el nivel
    botonGuardar = new Gtk::Button();
    Gtk::Image* imagenGuardar = manage(new Gtk::Image(
                                           Gtk::StockID("gtk-floppy"), Gtk::IconSize(Gtk::ICON_SIZE_BUTTON)));
    botonGuardar->set_image(*imagenGuardar);
    Gtk::Label* etiquetaGuardar = manage(new Gtk::Label("Guardar nivel: "));
    // Inicializacion del boton para volver a la seleccion de niveles
    botonVolver = new Gtk::Button();
    Gtk::Image* imagenVolver = manage(new Gtk::Image(
                                          Gtk::StockID("gtk-go-back"), Gtk::IconSize(Gtk::ICON_SIZE_BUTTON)));
    botonVolver->set_image(*imagenVolver);
    botonVolver->set_tooltip_text("Volver al panel de mundos");
    // Contenedores
    Gtk::VBox* cajaVerticalUno = manage(new Gtk::VBox(false, 20));
    cajaVerticalUno->pack_start(*paletaEscenario);
    cajaVerticalUno->pack_start(*eliminador);
    Gtk::VButtonBox* cajaAuxiliarUno = manage(new Gtk::VButtonBox());
    cajaAuxiliarUno->set_layout(Gtk::BUTTONBOX_CENTER);
    cajaAuxiliarUno->pack_start(*botonGuardar, Gtk::PACK_SHRINK);
    Gtk::VButtonBox* cajaAuxiliarDos = manage(new Gtk::VButtonBox());
    cajaAuxiliarDos->set_layout(Gtk::BUTTONBOX_CENTER);
    cajaAuxiliarDos->pack_start(*botonVolver, Gtk::PACK_SHRINK);
    Gtk::HBox* cajaHorizontalUno = manage(new Gtk::HBox(false, 20));
    cajaHorizontalUno->pack_start(*etiquetaGuardar);
    cajaHorizontalUno->pack_start(*cajaAuxiliarUno);
    Gtk::VBox* cajaVerticalDos = manage(new Gtk::VBox(false, 20));
    cajaVerticalDos->pack_start(*entrada);
    cajaVerticalDos->pack_start(*cajaHorizontalUno, Gtk::PACK_SHRINK);
    cajaVerticalDos->pack_start(*cajaAuxiliarDos, Gtk::PACK_SHRINK);
    Gtk::HBox* cajaHorizontal = manage(new Gtk::HBox(false, 20));
    Gtk::VBox* cajaVerticalLienzo = manage(new Gtk::VBox(false, 0));
    cajaVerticalLienzo->pack_start(*lienzo, Gtk::PACK_SHRINK);
    cajaHorizontal->pack_start(*cajaVerticalUno);
    cajaHorizontal->pack_start(*cajaVerticalLienzo, Gtk::PACK_SHRINK);
    cajaHorizontal->pack_start(*cajaVerticalDos);
    add(*cajaHorizontal);
    // Seniales
    botonGuardar->signal_clicked().connect(sigc::mem_fun(*this,
                                           &PanelEscenario::botonGuardarClickeado));
    botonVolver->signal_clicked().connect(sigc::mem_fun(*this,
                                          &PanelEscenario::volverAPanelMundos));
}
示例#15
0
         preferencesDialog::preferencesDialog(int const _min_port, int const _max_port)
            : portrange_begin(0),
              beginPortRangeSpinbuttonAdj(0),
              portrange_end(0),
              endPortRangeSpinbuttonAdj(0),
              workPathEntry(0),
              outputPathEntry(0),
              leechModeCheckbutton(0),
              min_port(_max_port), max_port(_min_port),
              workPath(),
              outputPath(),
              leechmode(false),
              portrange_begin_intial_value(0),
              portrange_end_intial_value(0),
              workPath_initial_value(""),
              outputPath_initial_value(""),
              leechmode_initial_value(false),
              portrange_begin_signal(),
              portrange_end_signal(),
              save_btn_pressed(false)
         {
            Gtk::Label* workLabel      = Gtk::manage(new class Gtk::Label("Working directory"));
            Gtk::Label* outputLabel    = Gtk::manage(new class Gtk::Label("Output directory"));
            Gtk::Label* portRangeLabel = Gtk::manage(new class Gtk::Label("Port range"));
            Gtk::Label* leechModeLabel = Gtk::manage(new class Gtk::Label("Leech mode"));
            outputPathEntry            = Gtk::manage(new class Gtk::Entry());

            workPathEntry              = Gtk::manage(new class Gtk::Entry());

            leechModeCheckbutton       = Gtk::manage(new class Gtk::CheckButton("enabled"));
            Gtk::Table* settingsTable  = Gtk::manage(new class Gtk::Table(2, 2, false));

            // Ports:
            Gtk::Table* portTable       = Gtk::manage(new class Gtk::Table(2, 2, false));;
            Gtk::Label* beginPortLabel  = Gtk::manage(new class Gtk::Label("Begin Port"));
            Gtk::Label* endPortLabel    = Gtk::manage(new class Gtk::Label("End Port"));
            beginPortRangeSpinbuttonAdj = Gtk::manage(new class Gtk::Adjustment(_min_port, _min_port, _max_port, 1, 100, 10));
            portrange_begin             = Gtk::manage(new class Gtk::SpinButton(*beginPortRangeSpinbuttonAdj, 1, 0));
            endPortRangeSpinbuttonAdj   = Gtk::manage(new class Gtk::Adjustment(_min_port, _min_port, _max_port, 1, 100, 10));
            portrange_end               = Gtk::manage(new class Gtk::SpinButton(*endPortRangeSpinbuttonAdj, 1, 0));

            beginPortLabel->set_alignment(0,0.5);
            beginPortLabel->set_padding(5,5);
            beginPortLabel->set_justify(Gtk::JUSTIFY_LEFT);
            beginPortLabel->set_line_wrap(false);
            beginPortLabel->set_use_markup(false);
            beginPortLabel->set_selectable(false);

            endPortLabel->set_alignment(0,0.5);
            endPortLabel->set_padding(5,5);
            endPortLabel->set_justify(Gtk::JUSTIFY_LEFT);
            endPortLabel->set_line_wrap(false);
            endPortLabel->set_use_markup(false);
            endPortLabel->set_selectable(false);

            portrange_end->set_flags(Gtk::CAN_FOCUS);
            portrange_end->set_update_policy(Gtk::UPDATE_ALWAYS);
            portrange_end->set_numeric(false);
            portrange_end->set_digits(0);
            portrange_end->set_wrap(false);
            portrange_end->set_flags(Gtk::CAN_FOCUS);
            portrange_end->set_update_policy(Gtk::UPDATE_ALWAYS);
            portrange_end->set_numeric(true);
            portrange_end->set_digits(0);
            portrange_end->set_wrap(false);

            portrange_begin->set_flags(Gtk::CAN_FOCUS);
            portrange_begin->set_update_policy(Gtk::UPDATE_ALWAYS);
            portrange_begin->set_numeric(false);
            portrange_begin->set_digits(0);
            portrange_begin->set_wrap(false);
            portrange_begin->set_flags(Gtk::CAN_FOCUS);
            portrange_begin->set_update_policy(Gtk::UPDATE_ALWAYS);
            portrange_begin->set_numeric(true);
            portrange_begin->set_digits(0);
            portrange_begin->set_wrap(false);

            portTable->set_border_width(10);
            portTable->set_row_spacings(5);
            portTable->set_col_spacings(5);
            portTable->attach(*beginPortLabel, 0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            portTable->attach(*endPortLabel, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            portTable->attach(*portrange_end, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            portTable->attach(*portrange_begin, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);

            beginPortLabel->show();
            endPortLabel->show();
            portrange_begin->show();
            portrange_end->show();
            portTable->show();

            Gtk::VBox *preferencesVbox = Gtk::manage(new class Gtk::VBox(false, 10));

            outputLabel->set_alignment(0,0.5);
            outputLabel->set_padding(5,0);
            outputLabel->set_justify(Gtk::JUSTIFY_LEFT);
            outputLabel->set_line_wrap(false);
            outputLabel->set_use_markup(false);
            outputLabel->set_selectable(false);

            workLabel->set_alignment(0,0.5);
            workLabel->set_padding(5,0);
            workLabel->set_justify(Gtk::JUSTIFY_LEFT);
            workLabel->set_line_wrap(false);
            workLabel->set_use_markup(false);
            workLabel->set_selectable(false);



            portRangeLabel->set_alignment(0,0.5);
            portRangeLabel->set_padding(5,0);
            portRangeLabel->set_justify(Gtk::JUSTIFY_LEFT);
            portRangeLabel->set_line_wrap(false);
            portRangeLabel->set_use_markup(false);
            portRangeLabel->set_selectable(false);

            leechModeLabel->set_alignment(0,0.5);
            leechModeLabel->set_padding(5,0);
            leechModeLabel->set_justify(Gtk::JUSTIFY_LEFT);
            leechModeLabel->set_line_wrap(false);
            leechModeLabel->set_use_markup(false);
            leechModeLabel->set_selectable(false);

            Gtk::HBox* pathHbox     = Gtk::manage(new class Gtk::HBox(false, 10));
            Gtk::HBox* workPathHbox = Gtk::manage(new class Gtk::HBox(false, 10));

            outputPathEntry->set_flags(Gtk::CAN_FOCUS);
            outputPathEntry->set_visibility(true);
            outputPathEntry->set_editable(false);
            outputPathEntry->set_max_length(0);
            outputPathEntry->set_text("");
            outputPathEntry->set_has_frame(true);
            outputPathEntry->set_activates_default(false);

            workPathEntry->set_flags(Gtk::CAN_FOCUS);
            workPathEntry->set_visibility(true);
            workPathEntry->set_editable(false);
            workPathEntry->set_max_length(0);
            workPathEntry->set_text("");
            workPathEntry->set_has_frame(true);
            workPathEntry->set_activates_default(false);

            Gtk::Button* pathButton = Gtk::manage(new class Gtk::Button("Change Path"));
            Gtk::Button* workPathButton = Gtk::manage(new class Gtk::Button("Change Path"));

            pathHbox->pack_start(*outputPathEntry);
            pathHbox->pack_start(*pathButton, Gtk::PACK_SHRINK, 0);

            workPathHbox->pack_start(*workPathEntry);
            workPathHbox->pack_start(*workPathButton, Gtk::PACK_SHRINK, 0);

            leechModeCheckbutton->set_flags(Gtk::CAN_FOCUS);
            leechModeCheckbutton->set_relief(Gtk::RELIEF_NORMAL);
            leechModeCheckbutton->set_mode(true);
            leechModeCheckbutton->set_active(false);

            settingsTable->set_border_width(10);
            settingsTable->set_row_spacings(20);
            settingsTable->set_col_spacings(5);

            // left rigth top bottom

            /*
              table1->attach(*label1, 0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*label2, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*label3, 0, 1, 2, 3, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*label4, 0, 1, 3, 4, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*entry1, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*entry2, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*entry3, 1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
              table1->attach(*entry4, 1, 2, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            */

            settingsTable->attach(*workLabel,            0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            settingsTable->attach(*outputLabel,          0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            settingsTable->attach(*portRangeLabel,       0, 1, 2, 3, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            settingsTable->attach(*leechModeLabel,       0, 1, 3, 4, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            settingsTable->attach(*workPathHbox,         1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            settingsTable->attach(*pathHbox,             1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
            settingsTable->attach(*portTable,            1, 2, 2, 3, Gtk::FILL, Gtk::FILL, 0, 0);
            settingsTable->attach(*leechModeCheckbutton, 1, 2, 3, 4, Gtk::FILL, Gtk::AttachOptions(), 0, 0);

            preferencesVbox->pack_start(*settingsTable, Gtk::PACK_SHRINK, 0);

            set_title( GPD->sGUI_CLIENT() + " " + GPD->sFULLVERSION() + " / Preferences" );
            set_modal(true);
            property_window_position().set_value(Gtk::WIN_POS_CENTER);
            set_resizable(true);
            property_destroy_with_parent().set_value(false);
            set_has_separator(true);

            get_vbox()->pack_start(*preferencesVbox);

            set_default_size(300, 200);

            outputLabel->show();
            workLabel->show();
            portRangeLabel->show();
            leechModeLabel->show();
            outputPathEntry->show();
            pathButton->show();
            pathHbox->show();

            workPathEntry->show();
            workPathButton->show();
            workPathHbox->show();

            leechModeCheckbutton->show();
            settingsTable->show();

            preferencesVbox->show();

            // Create buttons and connect their signals.
            add_button("Save", 1);
            add_button("Cancel", 2);

            signal_response().connect(sigc::mem_fun(*this, &preferencesDialog::on_dialog_button_pressed));

            pathButton->signal_clicked().connect(sigc::mem_fun(*this, &preferencesDialog::on_path_select_button_pressed));

            workPathButton->signal_clicked().connect(sigc::mem_fun(*this, &preferencesDialog::on_work_path_select_button_pressed));

            get_vbox()->show();
         }
CreadorNivel::CreadorNivel(int idProximoNivel,
		InformableSeleccion* informable) {
	this->idProximoNivel = idProximoNivel;
	this->informable = informable;
	// Widgets sin funcionalidad
	Gtk::Label* etiquetaTamanio = manage(new Gtk::Label(
						"Seleccione el tamaño que tendra el escenario: "));
	Gtk::Label* etiquetaDuracion = manage(new Gtk::Label(
						"Seleccione la duración del nivel (en segundos): "));
	Gtk::Label* etiquetaImagen = manage(new Gtk::Label(
						"Seleccione la imagen de fondo del nivel: "));
	Gtk::Label* etiquetaImagenSuelo = manage(new Gtk::Label(
						"Seleccione la imagen del suelo del nivel: "));
	// Widgets con funcionalidad
	selectorTamanio.append_text("Chico");
	selectorTamanio.append_text("Mediano");
	selectorTamanio.append_text("Grande");
	selectorTamanio.set_active_text("Mediano");
	ajuste = new Gtk::Adjustment(1.0, 15.0, MAXIMA_DURACION_NIVEL);
	selectorDuracion = new Gtk::SpinButton(*ajuste);
	selectorDuracion->set_editable(false);
	archivoImagenFondo = new Gtk::Entry();
	archivoImagenSuelo = new Gtk::Entry();
	archivoImagenFondo->set_editable(false);
	archivoImagenSuelo->set_editable(false);
	botonExaminarFondo = new Gtk::Button("Examinar...");
	botonExaminarSuelo = new Gtk::Button("Examinar...");
	// Contenedores
	Gtk::HBox* cajaHorizontalUno = manage(new Gtk::HBox(false, 20));
	cajaHorizontalUno->pack_start(*etiquetaTamanio);
	cajaHorizontalUno->pack_start(selectorTamanio);
	Gtk::HBox* cajaHorizontalDos = manage(new Gtk::HBox(false, 20));
	cajaHorizontalDos->pack_start(*etiquetaDuracion);
	cajaHorizontalDos->pack_start(*selectorDuracion);
	Gtk::HBox* cajaHorizontalTres = manage(new Gtk::HBox(false, 20));
	cajaHorizontalTres->pack_start(*etiquetaImagen);
	cajaHorizontalTres->pack_start(*botonExaminarFondo);
	Gtk::HBox* cajaHorizontalCuatro = manage(new Gtk::HBox(false, 20));
	cajaHorizontalCuatro->pack_start(*etiquetaImagenSuelo);
	cajaHorizontalCuatro->pack_start(*botonExaminarSuelo);
	Gtk::VBox* cajaVerticalAuxiliar = manage(new Gtk::VBox(false, 20));
	cajaVerticalAuxiliar->pack_start(*cajaHorizontalTres);
	cajaVerticalAuxiliar->pack_start(*archivoImagenFondo);
	Gtk::VBox* cajaVerticalAuxiliarDos = manage(new Gtk::VBox(false, 20));
	cajaVerticalAuxiliarDos->pack_start(*cajaHorizontalCuatro);
	cajaVerticalAuxiliarDos->pack_start(*archivoImagenSuelo);
	Gtk::VBox* cajaVertical = manage(new Gtk::VBox(false, 30));
	cajaVertical->pack_start(*cajaHorizontalUno);
	cajaVertical->pack_start(*cajaHorizontalDos);
	cajaVertical->pack_start(*cajaVerticalAuxiliar);
	cajaVertical->pack_start(*cajaVerticalAuxiliarDos);
	add(*cajaVertical);
	// Seniales
	botonExaminarFondo->signal_clicked().connect(sigc::mem_fun(*this,
										&CreadorNivel::botonExaminarClickeado));
	botonExaminarSuelo->signal_clicked().connect(sigc::mem_fun(*this,
								&CreadorNivel::botonExaminarClickeadoSuelo));
}
示例#17
0
  void 
  RSphericalParticles::initGTK()
  {
    _optList.reset(new Gtk::VBox);//The Vbox of options
    _colorMap.reset(new magnet::gtk::ColorMapSelector);

    _singleColorMode.reset(new Gtk::RadioButton("Single Color"));
    _colorByIDMode.reset(new Gtk::RadioButton("Color by ID"));
    
    _RFixed.reset(new Gtk::SpinButton);
    _GFixed.reset(new Gtk::SpinButton);
    _BFixed.reset(new Gtk::SpinButton);
    _AFixed.reset(new Gtk::SpinButton);
    
    {
      _optList->add(*_colorMap); _colorMap->show();
      //Horizontal seperator
      Gtk::HSeparator* line = manage(new Gtk::HSeparator);
      line->show();
      _optList->add(*line);
    }
   
    {//Single color and RGBA boxes
      Gtk::HBox* box = manage(new Gtk::HBox);
      
      box->pack_start(*_singleColorMode, true, true);_singleColorMode->show();
      if (_mode == SINGLE_COLOR) _singleColorMode->set_active();
      
      Gtk::Label* label = manage(new Gtk::Label("RGBA"));
      box->pack_start(*label, false, false); label->show();
      
      _RFixed->set_increments(1.0, 1.0);
      _RFixed->set_range(0.0, 255.0);
      _RFixed->set_value(_colorFixed.s[0]);
      
      _GFixed->set_increments(1.0, 1.0);
      _GFixed->set_range(0.0, 255.0);
      _GFixed->set_value(_colorFixed.s[1]);
      
      _BFixed->set_increments(1.0, 1.0);
      _BFixed->set_range(0.0, 255.0);
      _BFixed->set_value(_colorFixed.s[2]);
      
      _AFixed->set_increments(1.0, 1.0);
      _AFixed->set_range(0.0, 255.0);
      _AFixed->set_value(_colorFixed.s[3]);      
      
      box->pack_start(*_RFixed, false, false); _RFixed->show();
      box->pack_start(*_GFixed, false, false); _GFixed->show();
      box->pack_start(*_BFixed, false, false); _BFixed->show();
      box->pack_start(*_AFixed, false, false); _AFixed->show();
      
      _optList->add(*box);
      box->show();
      
      //Horizontal seperator
      Gtk::HSeparator* line = manage(new Gtk::HSeparator);
      line->show();
      _optList->add(*line);
    }
    
    Gtk::RadioButton::Group group = _singleColorMode->get_group();
    
    {//Color by ID
      _colorByIDMode->set_group(group);
      _colorByIDMode->show();
      if (_mode == COLOR_BY_ID) _colorByIDMode->set_active();
      
      _optList->add(*_colorByIDMode);
      
      //Horizontal seperator
      Gtk::HSeparator* line = manage(new Gtk::HSeparator);
      line->show();
      _optList->add(*line);
    }
    
    _optList->show();
    
    _singleColorMode->signal_toggled()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));
    _colorMap->signal_changed()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));
    _RFixed->signal_value_changed()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));
    _GFixed->signal_value_changed()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));
    _BFixed->signal_value_changed()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));
    _AFixed->signal_value_changed()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));
    
    _colorByIDMode->signal_toggled()
      .connect(sigc::mem_fun(*this, &RSphericalParticles::guiUpdate));

    guiUpdate();
  }
示例#18
0
void FindAndReplaceShader::populateWindow()
{
	Gtk::VBox* dialogVBox = Gtk::manage(new Gtk::VBox(false, 6));
	add(*dialogVBox);

	Gtk::HBox* findHBox = Gtk::manage(new Gtk::HBox(false, 0));
    Gtk::HBox* replaceHBox = Gtk::manage(new Gtk::HBox(false, 0));

    // Pack these hboxes into an alignment so that they are indented
	Gtk::Alignment* alignment = Gtk::manage(new gtkutil::LeftAlignment(*findHBox, 18, 1.0f));
	Gtk::Alignment* alignment2 = Gtk::manage(new gtkutil::LeftAlignment(*replaceHBox, 18, 1.0f));

	dialogVBox->pack_start(*alignment, true, true, 0);
	dialogVBox->pack_start(*alignment2, true, true, 0);

	// Create the labels and pack them in the hbox
	Gtk::Label* findLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_(LABEL_FIND)));
	Gtk::Label* replaceLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_(LABEL_REPLACE)));

	findLabel->set_size_request(60, -1);
	replaceLabel->set_size_request(60, -1);

	findHBox->pack_start(*findLabel, false, false, 0);
	replaceHBox->pack_start(*replaceLabel, false, false, 0);

	_findEntry = Gtk::manage(new Gtk::Entry);
	_replaceEntry = Gtk::manage(new Gtk::Entry);

	_findEntry->signal_changed().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onFindChanged));
	_replaceEntry->signal_changed().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onReplaceChanged));

	findHBox->pack_start(*_findEntry, true, true, 6);
	replaceHBox->pack_start(*_replaceEntry, true, true, 6);

	// Create the icon buttons to open the ShaderChooser and override the size request
	_findSelectButton = Gtk::manage(
		new gtkutil::IconTextButton("", GlobalUIManager().getLocalPixbuf(FOLDER_ICON))
	);
	_findSelectButton->set_size_request(-1, -1);
	_findSelectButton->signal_clicked().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onChooseFind));

	_replaceSelectButton = Gtk::manage(
		new gtkutil::IconTextButton("", GlobalUIManager().getLocalPixbuf(FOLDER_ICON))
	);
	_replaceSelectButton->set_size_request(-1, -1);
	_replaceSelectButton->signal_clicked().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onChooseReplace));

	findHBox->pack_start(*_findSelectButton, false, false, 0);
	replaceHBox->pack_start(*_replaceSelectButton, false, false, 0);

	Gtk::Alignment* spacer = Gtk::manage(new Gtk::Alignment(0,0,0,0));
	spacer->set_size_request(10, 2);
	dialogVBox->pack_start(*spacer, false, false, 0);

	// The checkbox for "search selected only"
	_selectedOnly = Gtk::manage(new Gtk::CheckButton(_(LABEL_SELECTED_ONLY), true));

	Gtk::Alignment* alignment3 = Gtk::manage(new gtkutil::LeftAlignment(*_selectedOnly, 18, 1.0f));
	dialogVBox->pack_start(*alignment3, false, false, 0);

	// Finally, add the buttons
	dialogVBox->pack_start(createButtons(), false, false, 0);
}
示例#19
0
Simple::Simple():
    m_rotate_object(0),
    m_zoom_object(0)
{
  m_rect = Papyrus::Rectangle::create( );
  m_drawables[0] = m_rect;

  m_circle = Papyrus::Circle::create( );
  m_drawables[1] = m_circle;

  m_text = Papyrus::Text::create( );
  m_drawables[2] = m_text;

  m_lines = Papyrus::Polyline::create( );
  m_drawables[3] = m_lines;

  m_polygon = Papyrus::Polygon::create( );
  m_drawables[4] = m_polygon;

  m_png = Papyrus::Image::create( );
  m_drawables[5] = m_png;

  m_drawables[6] = m_viewport.canvas();

  set_title("Papyrus Group Transformation Demo");

  m_vbox.set_border_width(12);
  m_frame.set_shadow_type(Gtk::SHADOW_IN);

  m_slider.set_range(0, ROTATE_MAX);
  m_slider.set_increments(M_PI/8.0, M_PI/8.0);
  m_zoom.set_range(0.1, 4.0);
  m_zoom.set_increments(0.25, 0.25);
  m_zoom.set_value(1.0);

  m_viewport.set_size_request(INITIAL_SIZE, INITIAL_SIZE);

  adjust_canvas(INITIAL_SIZE, INITIAL_SIZE);

  // This is the method that demonstrates the Papyrus objects
  draw_scene();

  m_frame.add(m_viewport);
  m_vbox.pack_start(m_frame);

  m_slider.set_draw_value(false);
  m_slider.signal_value_changed().connect(sigc::mem_fun(*this, &Simple::slider_changed));
  m_vbox.pack_start(*Gtk::manage(new Gtk::Label("Rotate")), Gtk::PACK_SHRINK);
  m_vbox.pack_start(m_slider, Gtk::PACK_SHRINK);

  m_animate.set_label("Animate Rotation");
  m_animate.signal_toggled().connect(sigc::mem_fun(*this, &Simple::animate_toggled));
  m_vbox.pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_SHRINK);
  m_vbox.pack_start(m_animate, Gtk::PACK_SHRINK);

  m_zoom.signal_value_changed().connect(sigc::mem_fun(*this, &Simple::zoom_changed));
  m_vbox.pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_SHRINK);
  m_vbox.pack_start(*Gtk::manage(new Gtk::Label("Zoom")), Gtk::PACK_SHRINK);
  m_vbox.pack_start(m_zoom, Gtk::PACK_SHRINK);

  m_vbox.pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_SHRINK);
  Gtk::RadioButtonGroup button_group1, button_group2;
  Gtk::RadioButton* radio_button;
  Gtk::HBox* hbox = Gtk::manage(new Gtk::HBox());
  m_vbox.pack_start(*hbox);
  Gtk::VBox* vbox = Gtk::manage(new Gtk::VBox());
  hbox->pack_start(*vbox);
  vbox->pack_start(*Gtk::manage(new Gtk::Label("Rotation Object")));
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Rectangle"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 0));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Circle"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 1));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Text"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 2));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Lines"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 3));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Polygon"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 4));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Image"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 5));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group1, "Canvas"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_rotate_object_changed), 6));
  vbox->pack_start(*radio_button);

  vbox = Gtk::manage(new Gtk::VBox());
  hbox->pack_start(*vbox);
  vbox->pack_start(*Gtk::manage(new Gtk::Label("Zoom Object")));
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Rectangle"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 0));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Circle"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 1));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Text"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 2));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Lines"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 3));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Polygon"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 4));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Image"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 5));
  vbox->pack_start(*radio_button);
  radio_button = Gtk::manage(new Gtk::RadioButton(button_group2, "Canvas"));
  radio_button->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &Simple::on_zoom_object_changed), 6));
  vbox->pack_start(*radio_button);

  signal_size_allocate().connect(sigc::mem_fun(*this, &Simple::on_sig_size_allocate));

  add(m_vbox);
  m_vbox.show_all();
  show();
}
MEShowNodesWindow::MEShowNodesWindow(MEMapArea* mapArea)
   : m_selectedRow( NULL ), m_mapArea(mapArea)
{
   set_title("Show nodes");
   set_size_request(300, 400);      

   // Create the main-box where the frames are added. 
   Gtk::Box* mainbox = manage(new Gtk::VBox());
   Gtk::Frame* frame = NULL;
   //Gtk::Adjustment* adj = NULL;
   Gtk::Label* label = NULL;
   Gtk::Button* btn = NULL;

   m_fileSelector = manage(new Gtk::FileSelection("Select turn desc. file"));
   m_fileSelector->get_ok_button()->signal_clicked().connect(
               sigc::mem_fun(*this, &MEShowNodesWindow::on_fileSelOK));

   m_fileSelector->get_cancel_button()->signal_clicked().connect(
                sigc::mem_fun(*this, &MEShowNodesWindow::on_fileSelCancel));              


   m_fileSelector->hide_fileop_buttons();

   // Frame where to load file
   frame = manage(new Gtk::Frame("File"));
   Gtk::Box* box = manage(new Gtk::HBox());
   m_fileNameEntry = manage(new Gtk::Entry());
   box->pack_start(*m_fileNameEntry);
   btn = manage(new Gtk::Button("..."));
   btn->signal_clicked().connect(
            sigc::mem_fun(*this, &MEShowNodesWindow::on_selectFile));            
   box->pack_start(*btn, false, false); 
   btn = manage(new Gtk::Button("Load"));
   btn->signal_clicked().connect(
            sigc::mem_fun(*this, &MEShowNodesWindow::on_loadFile));    
   box->pack_start(*btn, false, false); 
   frame->add(*box);
   mainbox->pack_start(*frame, false, false);

   // Create ListStore and add to TreeView
   m_listStore = Gtk::ListStore::create(m_columns);
   m_treeView.set_model(m_listStore);
 
   m_treeView.append_column("From", m_columns.m_from);
   m_treeView.append_column("To", m_columns.m_to);
   m_treeView.append_column("Old turn", m_columns.m_oldTurn);
   m_treeView.append_column("Old CK", m_columns.m_oldCK);

   // Create selection object to handle selections
   m_selection = m_treeView.get_selection();
   
   if( m_selection )
   {
      m_selection->signal_changed().connect(
        sigc::mem_fun(*this, &MEShowNodesWindow::on_showNode));
   } else {
      // If this doesn't work we're in trouble.
      mc2log << error << "No selection object created for corresponding "
             << "TreeView" << endl;
      MC2_ASSERT(false);
   }

   // Set column size- and resize properties.
   Gtk::TreeViewColumn* tmpCol;
   tmpCol = m_treeView.get_column( 0 );
   tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
   tmpCol->set_fixed_width( 90 );   
   tmpCol->set_resizable( true );
 
   tmpCol = m_treeView.get_column( 1 );
   tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
   tmpCol->set_fixed_width( 90 );
   tmpCol->set_resizable( true );

   tmpCol = m_treeView.get_column( 2 );
   tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
   tmpCol->set_fixed_width( 70 );
   tmpCol->set_resizable( true ); 

   tmpCol = m_treeView.get_column( 3 );
   tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
   tmpCol->set_fixed_width( 70 );
   tmpCol->set_resizable( true ); 

   Gtk::ScrolledWindow* scrolledWin = manage(new Gtk::ScrolledWindow());
   scrolledWin->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
   scrolledWin->add(m_treeView);
   mainbox->pack_start( *scrolledWin, true, true ); 
   
   // Next and previous turn
   box = manage(new Gtk::HBox());
   btn = manage(new Gtk::Button("Prev"));
   btn->signal_clicked().connect(
            sigc::mem_fun(*this, &MEShowNodesWindow::on_clickPrev));    

   box->pack_start(*btn);
   btn = manage(new Gtk::Button("All"));
   btn->signal_clicked().connect(
            sigc::mem_fun(*this, &MEShowNodesWindow::on_clickShowAll));    
   box->pack_start(*btn);
   btn = manage(new Gtk::Button("Next"));
   btn->signal_clicked().connect(
            sigc::mem_fun(*this, &MEShowNodesWindow::on_clickNext));    
   box->pack_start(*btn);
   mainbox->pack_start(*box, false, false); 
   
   // Frame with information about the selected crossing/connection
   frame = manage(new Gtk::Frame("Selected crossing"));
   Gtk::HBox* hbox = manage(new Gtk::HBox());

   box = manage(new Gtk::VBox());
   label = manage(new Gtk::Label("Current values"));
   label->set_pattern(           "______________");
   box->pack_start(*label);
   m_curTurnDesc = manage(new Gtk::Label(""));
   box->pack_start(*m_curTurnDesc);
   m_curCrossingKind = manage(new Gtk::Label(""));
   box->pack_start(*m_curCrossingKind);
   hbox->pack_start(*box);
   
   box = manage(new Gtk::VBox());
   label = manage(new Gtk::Label("Old values"));
   label->set_pattern(           "__________");
   box->pack_start(*label);
   m_oldTurnDesc = manage(new Gtk::Label(""));
   box->pack_start(*m_oldTurnDesc);
   m_oldCrossingKind = manage(new Gtk::Label(""));
   box->pack_start(*m_oldCrossingKind);
   hbox->pack_start(*box);

   frame->add(*hbox);
   mainbox->pack_start(*frame, false, false); 

   add(*mainbox);
   show_all();
}
示例#21
0
文件: utils.cpp 项目: haobug/gnote
    HIGMessageDialog::HIGMessageDialog(Gtk::Window *parent,
                                       GtkDialogFlags flags, Gtk::MessageType msg_type, 
                                       Gtk::ButtonsType btn_type, const Glib::ustring & header,
                                       const Glib::ustring & msg)
      : Gtk::Dialog()
      , m_extra_widget(NULL)
    {
      set_border_width(5);
      set_resizable(false);
      set_title("");

      get_vbox()->set_spacing(12);
      get_action_area()->set_layout(Gtk::BUTTONBOX_END);

      m_accel_group = Glib::RefPtr<Gtk::AccelGroup>(Gtk::AccelGroup::create());
      add_accel_group(m_accel_group);

      Gtk::HBox *hbox = manage(new Gtk::HBox (false, 12));
      hbox->set_border_width(5);
      hbox->show();
      get_vbox()->pack_start(*hbox, false, false, 0);

      switch (msg_type) {
      case Gtk::MESSAGE_ERROR:
        m_image = new Gtk::Image (Gtk::Stock::DIALOG_ERROR,
                                  Gtk::ICON_SIZE_DIALOG);
        break;
      case Gtk::MESSAGE_QUESTION:
        m_image = new Gtk::Image (Gtk::Stock::DIALOG_QUESTION,
                                  Gtk::ICON_SIZE_DIALOG);
        break;
      case Gtk::MESSAGE_INFO:
        m_image = new Gtk::Image (Gtk::Stock::DIALOG_INFO,
                                  Gtk::ICON_SIZE_DIALOG);
        break;
      case Gtk::MESSAGE_WARNING:
        m_image = new Gtk::Image (Gtk::Stock::DIALOG_WARNING,
                                  Gtk::ICON_SIZE_DIALOG);
        break;
      default:
        m_image = new Gtk::Image ();
        break;
      }

      if (m_image) {
        Gtk::manage(m_image);
        m_image->show();
        m_image->property_yalign().set_value(0);
        hbox->pack_start(*m_image, false, false, 0);
      }

      Gtk::VBox *label_vbox = manage(new Gtk::VBox (false, 0));
      label_vbox->show();
      hbox->pack_start(*label_vbox, true, true, 0);

      std::string title = str(boost::format("<span weight='bold' size='larger'>%1%"
                                            "</span>\n") % header.c_str());

      Gtk::Label *label;

      label = manage(new Gtk::Label (title));
      label->set_use_markup(true);
      label->set_justify(Gtk::JUSTIFY_LEFT);
      label->set_line_wrap(true);
      label->set_alignment (0.0f, 0.5f);
      label->show();
      label_vbox->pack_start(*label, false, false, 0);

      label = manage(new Gtk::Label(msg));
      label->set_use_markup(true);
      label->set_justify(Gtk::JUSTIFY_LEFT);
      label->set_line_wrap(true);
      label->set_alignment (0.0f, 0.5f);
      label->show();
      label_vbox->pack_start(*label, false, false, 0);
      
      m_extra_widget_vbox = manage(new Gtk::VBox (false, 0));
      m_extra_widget_vbox->show();
      label_vbox->pack_start(*m_extra_widget_vbox, true, true, 12);

      switch (btn_type) {
      case Gtk::BUTTONS_NONE:
        break;
      case Gtk::BUTTONS_OK:
        add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK, true);
        break;
      case Gtk::BUTTONS_CLOSE:
        add_button (Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE, true);
        break;
      case Gtk::BUTTONS_CANCEL:
        add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL, true);
        break;
      case Gtk::BUTTONS_YES_NO:
        add_button (Gtk::Stock::NO, Gtk::RESPONSE_NO, false);
        add_button (Gtk::Stock::YES, Gtk::RESPONSE_YES, true);
        break;
      case Gtk::BUTTONS_OK_CANCEL:
        add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL, false);
        add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK, true);
        break;
      }

      if (parent){
        set_transient_for(*parent);
      }

      if ((flags & GTK_DIALOG_MODAL) != 0) {
        set_modal(true);
      }

      if ((flags & GTK_DIALOG_DESTROY_WITH_PARENT) != 0) {
        property_destroy_with_parent().set_value(true);
      }
    }
示例#22
0
/** \brief  Creates a new preference dialog for extension preferences
    \param  name  Name of the Extension whose dialog this is
    \param  help  The help string for the extension (NULL if none)
    \param  controls  The extension specific widgets in the dialog

    This function initializes the dialog with the name of the extension
    in the title.  It adds a few buttons and sets up handlers for
    them.  It also places the passed-in widgets into the dialog.
*/
PrefDialog::PrefDialog (Glib::ustring name, gchar const * help, Gtk::Widget * controls, Effect * effect) :
#if WITH_GTKMM_3_0
    Gtk::Dialog::Dialog(_(name.c_str()), true),
#else
    Gtk::Dialog::Dialog(_(name.c_str()), true, true),
#endif
    _help(help),
    _name(name),
    _button_ok(NULL),
    _button_cancel(NULL),
    _button_preview(NULL),
    _param_preview(NULL),
    _effect(effect),
    _exEnv(NULL)
{
    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox());
    if (controls == NULL) {
        if (_effect == NULL) {
            std::cout << "AH!!!  No controls and no effect!!!" << std::endl;
            return;
        }
        controls = _effect->get_imp()->prefs_effect(_effect, SP_ACTIVE_DESKTOP, &_signal_param_change, NULL);
        _signal_param_change.connect(sigc::mem_fun(this, &PrefDialog::param_change));
    }

    hbox->pack_start(*controls, true, true, 6);
    hbox->show();
    this->get_vbox()->pack_start(*hbox, true, true, 6);

    /*
    Gtk::Button * help_button = add_button(Gtk::Stock::HELP, Gtk::RESPONSE_HELP);
    if (_help == NULL)
        help_button->set_sensitive(false);
    */
    _button_cancel = add_button(_effect == NULL ? Gtk::Stock::CANCEL : Gtk::Stock::CLOSE, Gtk::RESPONSE_CANCEL);
    _button_cancel->set_use_stock(true);

    _button_ok = add_button(_effect == NULL ? Gtk::Stock::OK : Gtk::Stock::APPLY, Gtk::RESPONSE_OK);
    _button_ok->set_use_stock(true);
    set_default_response(Gtk::RESPONSE_OK);
    _button_ok->grab_focus();

    if (_effect != NULL && !_effect->no_live_preview) {
        if (_param_preview == NULL) {
            XML::Document * doc = sp_repr_read_mem(live_param_xml, strlen(live_param_xml), NULL);
            _param_preview = Parameter::make(doc->root(), _effect);
        }

        Gtk::HSeparator * sep = Gtk::manage(new Gtk::HSeparator());
        sep->show();
        this->get_vbox()->pack_start(*sep, true, true, 4);

        hbox = Gtk::manage(new Gtk::HBox());
        _button_preview = _param_preview->get_widget(NULL, NULL, &_signal_preview);
        _button_preview->show();
        hbox->pack_start(*_button_preview, true, true,6);
        hbox->show();
        this->get_vbox()->pack_start(*hbox, true, true, 6);

        Gtk::Box * hbox = dynamic_cast<Gtk::Box *>(_button_preview);
        if (hbox != NULL) {
#if WITH_GTKMM_3_0
            _checkbox_preview = dynamic_cast<Gtk::CheckButton *>(hbox->get_children().front());
#else
            _checkbox_preview = dynamic_cast<Gtk::CheckButton *>(hbox->children().back().get_widget());
#endif
        }

        preview_toggle();
        _signal_preview.connect(sigc::mem_fun(this, &PrefDialog::preview_toggle));
    }

    // Set window modality for effects that don't use live preview
    if (_effect != NULL && _effect->no_live_preview) {
        set_modal(false);
    }

    GtkWidget *dlg = GTK_WIDGET(gobj());
    sp_transientize(dlg);

    return;
}
示例#23
0
void uiFileDetailsTreeView::show_file_details(const Gtk::TreeModel::iterator& iter)
{
	Gtk::TreeModel::Row row = *iter;

	sqlite3_stmt *stmt = 0;
	const char query[] = "SELECT header FROM files WHERE animalID=? AND cellID=? AND fileID=?";
	sqlite3_prepare_v2(*db, query, strlen(query), &stmt, NULL);
	sqlite3_bind_text(stmt, 1, row.get_value(m_Columns.m_col_animalID).c_str(), -1, SQLITE_TRANSIENT);
	sqlite3_bind_int(stmt, 2, row.get_value(m_Columns.m_col_cellID));
	sqlite3_bind_int(stmt, 3, row.get_value(m_Columns.m_col_filenum));

	int r = sqlite3_step(stmt);

	if (r == SQLITE_ROW) {

		SpikeData sd;
		void *header = (void*)sqlite3_column_blob(stmt, 0);
		sd.setHeader(header);

		Gtk::Dialog dialog("File Details", true);
		dialog.set_transient_for(*m_parent);
		dialog.set_resizable(false);
		dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
		dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);

		Gtk::HBox hbTime;
		Gtk::Label lblTimeName("Recording Time: ");
		Gtk::Label lblTime(sd.iso8601(sd.m_head.cDateTime));
		hbTime.pack_start(lblTimeName);
		hbTime.pack_start(lblTime);
		dialog.get_vbox()->pack_start(hbTime);

		Gtk::CheckButton cbHidden("Hide file in file list");
		cbHidden.set_active(row.get_value(m_Columns.m_col_hidden));
		dialog.get_vbox()->pack_start(cbHidden);

		sqlite3_stmt *stmt2 = 0;
		const char query2[] = "SELECT tag FROM tags WHERE animalID=? AND cellID=? AND fileID=?";
		sqlite3_prepare_v2(*db, query2, -1, &stmt2, 0);
		sqlite3_bind_text(stmt2, 1, row.get_value(m_Columns.m_col_animalID).c_str(), -1, SQLITE_TRANSIENT);
		sqlite3_bind_int(stmt2, 2, row.get_value(m_Columns.m_col_cellID));
		sqlite3_bind_int(stmt2, 3, row.get_value(m_Columns.m_col_filenum));
		std::vector<Glib::ustring> tags;
		while (sqlite3_step(stmt2) == SQLITE_ROW) {
			Glib::ustring t = (char*)sqlite3_column_text(stmt2, 0);
			tags.push_back(t);
		}
		sqlite3_finalize(stmt2);
		Gtk::Frame frameTags("File Tags");
		uiTags tagsFile(m_parent);
		tagsFile.tags(tags);
		tagsFile.delete_assist = true;
		frameTags.add(tagsFile);
		dialog.get_vbox()->pack_start(frameTags);
		tagsFile.signal_deleted().connect(sigc::mem_fun(*this, &uiFileDetailsTreeView::on_tag_deleted));
		tagsFile.signal_added().connect(sigc::mem_fun(*this, &uiFileDetailsTreeView::on_tag_added));
		dialog.show_all_children();
		int result = dialog.run();


		switch (result) {
			case (Gtk::RESPONSE_OK):
				if (row.get_value(m_Columns.m_col_hidden) != cbHidden.get_active())
					m_signal_file_set_hidden.emit(cbHidden.get_active());
				break;
		}

	} else {
		Gtk::MessageDialog dialog(*m_parent, "Error loading file from database.", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK);
		dialog.set_secondary_text(sqlite3_errmsg(*db));
		dialog.run();
	}
	sqlite3_finalize(stmt);

}