/** * Creates a combobox widget for an enumeration parameter. */ Gtk::Widget *ParamComboBox::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::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_START)); label->show(); hbox->pack_start(*label, false, false, _indent); ParamComboBoxEntry * combo = Gtk::manage(new ParamComboBoxEntry(this, doc, node, changeSignal)); // add choice strings: Glib::ustring settext; for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { enumentry * entr = reinterpret_cast<enumentry *>(list->data); Glib::ustring text = entr->guitext; combo->append(text); if ( _value && !entr->value.compare(_value) ) { settext = entr->guitext; } } if (!settext.empty()) { combo->set_active_text(settext); } combo->show(); hbox->pack_start(*combo, true, true); hbox->show(); return dynamic_cast<Gtk::Widget *>(hbox); }
// Read column header text and create a label with that text, set it as column's custom widget. Gtk::Widget* app_gtkmm_labelize_column(Gtk::TreeViewColumn& column) { Gtk::Label* label = Gtk::manage(new Gtk::Label(column.get_title())); label->show(); column.set_widget(*label); return label; }
/** \brief Create a label for the description */ Gtk::Widget * ParamDescription::get_widget (SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal<void> * /*changeSignal*/) { if (_gui_hidden) { return NULL; } Glib::ustring newguitext; if (_context != NULL) { newguitext = g_dpgettext2(NULL, _context, _value); } else { newguitext = _(_value); } Gtk::Label * label; int padding = 12 + _indent; if (_mode == HEADER) { label = Gtk::manage(new Gtk::Label(Glib::ustring("<b>") +newguitext + Glib::ustring("</b>"), Gtk::ALIGN_START)); label->set_padding(0,5); label->set_use_markup(true); padding = _indent; } else { label = Gtk::manage(new Gtk::Label(newguitext, Gtk::ALIGN_START)); } label->set_line_wrap(); label->show(); Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); hbox->pack_start(*label, true, true, padding); hbox->show(); return hbox; }
void Extension::add_val(Glib::ustring labelstr, Glib::ustring valuestr, Gtk::Table * table, int * row) { Gtk::Label * label; Gtk::Label * value; (*row)++; label = Gtk::manage(new Gtk::Label(labelstr)); value = Gtk::manage(new Gtk::Label(valuestr)); table->attach(*label, 0, 1, (*row) - 1, *row); table->attach(*value, 1, 2, (*row) - 1, *row); label->show(); value->show(); return; }
void set_path(const Raul::Path& path) { remove(); const char* text = (path.is_root()) ? "/" : path.symbol(); Gtk::Label* lab = manage(new Gtk::Label(text)); lab->set_padding(0, 0); lab->show(); add(*lab); if (_view && _view->graph()->path() != path) _view.reset(); }
void SPAttributeTable::set_object(SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent) { g_return_if_fail (!object || SP_IS_OBJECT (object)); g_return_if_fail (!object || !labels.empty() || !attributes.empty()); g_return_if_fail (labels.size() == attributes.size()); clear(); _object = object; if (object) { blocked = true; // Set up object modified_connection = object->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_attribute_table_object_modified), this)); release_connection = object->connectRelease (sigc::bind<1>(sigc::ptr_fun(&sp_attribute_table_object_release), this)); // Create table table = new Gtk::Table (attributes.size(), 2, false); if (!(parent == NULL)) { gtk_container_add (GTK_CONTAINER (parent),(GtkWidget*)table->gobj()); } // Fill rows _attributes = attributes; for (guint i = 0; i < (attributes.size()); i++) { Gtk::Label *ll = new Gtk::Label (_(labels[i].c_str())); ll->show(); ll->set_alignment (1.0, 0.5); table->attach (*ll, 0, 1, i, i + 1, Gtk::FILL, (Gtk::EXPAND | Gtk::FILL), XPAD, YPAD ); Gtk::Entry *ee = new Gtk::Entry(); ee->show(); const gchar *val = object->getRepr()->attribute(attributes[i].c_str()); ee->set_text (val ? val : (const gchar *) ""); table->attach (*ee, 1, 2, i, i + 1, (Gtk::EXPAND | Gtk::FILL), (Gtk::EXPAND | Gtk::FILL), XPAD, YPAD ); _entries.push_back(ee); g_signal_connect ( ee->gobj(), "changed", G_CALLBACK (sp_attribute_table_entry_changed), this ); } /* Show table */ table->show (); blocked = false; } }
ColorMapSelector(): _min(0), _max(1) { m_refTreeModel = ::Gtk::ListStore::create(m_Columns); _comboBox.set_model(m_refTreeModel); buildEntry(SEBASTIAN, "Heat"); buildEntry(HSV, "HSV"); buildEntry(MARCUS, "Grayscale safe"); _comboBox.pack_start(m_Columns.m_col_name, true); _comboBox.pack_start(m_Columns.m_col_icon, false); _comboBox.signal_changed().connect(sigc::mem_fun(*this, &ColorMapSelector::on_combobox_changed)); _comboBox.set_active(0); _comboBox.show(); show(); _minValue.set_text("0"); _minValue.set_width_chars(5); _minValue.show(); _minValue.signal_changed().connect(sigc::mem_fun(*this, &ColorMapSelector::on_limits_changed)); _maxValue.set_text("1.0"); _maxValue.set_width_chars(5); _maxValue.show(); _maxValue.signal_changed().connect(sigc::mem_fun(*this, &ColorMapSelector::on_limits_changed)); Gtk::Label* label = Gtk::manage(new Gtk::Label("Range")); label->show(); pack_start(*label, false, false, 5); pack_start(_minValue, false, false, 5); label = Gtk::manage(new Gtk::Label(":")); label->show(); pack_start(*label, false, false, 2); pack_start(_maxValue, false, false, 5); label = Gtk::manage(new Gtk::Label("Scale")); label->show(); label->set_alignment(0.95, 0.5); pack_start(*label, true, true, 5); pack_start(_comboBox, false, false, 5); }
void Gobby::PreferencesDialog::Security::set_file_error(Gtk::Label& label, const GError* error) { if(error != NULL) { label.set_text(Glib::ustring::compose( _("Error reading file: %1"), error->message)); label.show(); } else { label.hide(); } }
DateFilter::DateFilter() { m_startdate.clear(); m_enddate.clear(); set_spacing(12); // filtertype button m_filter_type = manage(new Gtk::ComboBoxText); m_filter_type->append_text(gettext("None")); m_filter_type->append_text(gettext("Today")); m_filter_type->append_text(gettext("Yesterday")); m_filter_type->append_text(gettext("Date")); m_filter_type->append_text(gettext("Range")); m_filter_type->set_active_text(gettext("None")); m_filter_type->signal_changed().connect(sigc::mem_fun(*this, &DateFilter::on_filtertype_changed)); m_filter_type->show(); // date selection m_filter_date = manage(new Gtk::HBox); m_filter_popup_from = manage(new Gtk::Button); m_filter_popup_from->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &DateFilter::on_select_date), true)); m_filter_popup_from->show(); m_filter_date->pack_start(*m_filter_popup_from, Gtk::PACK_SHRINK); // date range m_filter_range = manage(new Gtk::HBox); m_filter_popup_to = manage(new Gtk::Button); m_filter_popup_to->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &DateFilter::on_select_date), false)); m_filter_popup_to->show(); Gtk::Label* label = manage(new Gtk::Label("-")); label->set_padding(12,0); label->show(); m_filter_range->pack_start(*label, Gtk::PACK_SHRINK); m_filter_range->pack_start(*m_filter_popup_to, Gtk::PACK_SHRINK); // container for date/range selection Gtk::HBox* type_container = manage(new Gtk::HBox); type_container->pack_start(*m_filter_date, Gtk::PACK_SHRINK); type_container->pack_start(*m_filter_range, Gtk::PACK_SHRINK); type_container->show(); // add all widgets pack_start(*m_filter_type, Gtk::PACK_SHRINK); pack_start(*type_container, Gtk::PACK_SHRINK); }
void PremDialog::accept_clicked(){ std::string prem_exp = this->premiseText->get_text(); int i = this->model->getNumPremises(); try{ this->model->addPremise(prem_exp); ShortTruthTables::ParsedExpression* new_exp = this->model->getPremise(i); Gtk::Grid* prem_grid = Gtk::manage(new Gtk::Grid()); Gtk::Box* premises_box; refBuilder->get_widget("premise_box", premises_box); premises_box->pack_start(*prem_grid, true, true); premises_box->show(); std::string inorder = new_exp->getInOrderExp(); for(int j = 0; j < inorder.size(); j++){ if(new_exp->expressionAtPosition(j) == NULL){ Gtk::Label* temp = Gtk::manage(new Gtk::Label(std::string(1,inorder[j]))); temp->show(); prem_grid->add(*temp); }else{ ExpressionButton* temp = Gtk::manage(new ExpressionButton(new_exp->expressionAtPosition(j), prem_grid, this->model)); temp->set_exp_num_and_pos(i, j); temp->show(); prem_grid->add(*temp); if(new_exp->isTopLevel(new_exp->expressionAtPosition(j))){ Gtk::Label* true_label = Gtk::manage(new Gtk::Label("T")); true_label->show(); prem_grid->attach_next_to(*true_label, *temp, Gtk::POS_BOTTOM ,1,1); } if(inorder[j] == '<'){ j+=2; } else if(inorder[j] == '-'){ j+=1; } } } prem_grid->show(); premises_box->show(); premDialog->hide(); }catch(std::invalid_argument e){ this->premiseText->set_text("Poorly Formatted Expression"); } }
int NetLogGuiGtkWindow::on_service_added(fawkes::NetworkService *service) { if ( ntb_logviewers.get_n_pages() == 0 ) { lab_no_connection->hide(); //Gtk::Container *thiscon = this; //thiscon->remove(lab_no_connection); //add(ntb_logviewers); ntb_logviewers.show(); } Gtk::HBox *hbox = Gtk::manage(new Gtk::HBox(false, 4)); Gtk::Button *button = Gtk::manage(new Gtk::Button()); Gtk::Image *image = Gtk::manage(new Gtk::Image(Gtk::Stock::CONNECT, Gtk::ICON_SIZE_BUTTON)); button->add(*image); button->set_relief(Gtk::RELIEF_NONE); Gtk::Label *label = Gtk::manage(new Gtk::Label()); label->set_markup(Glib::ustring("<b>") + service->host() + "</b>\n" + service->addr_string()); label->set_line_wrap(); Gtk::Label *invisible = Gtk::manage(new Gtk::Label(Glib::ustring(service->name()) + "::" + service->type() + "::" + service->domain())); Gtk::ScrolledWindow *scrolled = Gtk::manage(new Gtk::ScrolledWindow()); scrolled->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); LogView *logview = Gtk::manage(new LogView(service->addr_string().c_str(), service->port())); //scrolled->add(*logview); hbox->pack_start(*button); hbox->pack_start(*label); hbox->pack_start(*invisible); button->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &NetLogGuiGtkWindow::on_connbut_clicked), image, logview)); logview->get_connection_dispatcher()->signal_connected().connect(sigc::bind(sigc::mem_fun(*this, &NetLogGuiGtkWindow::on_connected), image)); logview->get_connection_dispatcher()->signal_disconnected().connect(sigc::bind(sigc::mem_fun(*this, &NetLogGuiGtkWindow::on_disconnected), image)); scrolled->show(); label->show(); image->show(); button->show(); logview->show(); hbox->show(); int rv = ntb_logviewers.append_page(*logview, *hbox); return rv; }
void Gobby::PreferencesDialog::Security::set_file_error(Gtk::Label& label, const GError* error) { if(error != NULL) { label.set_markup( //"<span style='color: red;'>" + "<span foreground='red'>" + std::string(_("Error reading file:")) + " " + Glib::Markup::escape_text(error->message) + "</span>"); label.show(); } else { label.hide(); } }
Gtk::VBox * Extension::get_help_widget(void) { Gtk::VBox * retval = Gtk::manage(new Gtk::VBox()); if (_help == NULL) { Gtk::Label * content = Gtk::manage(new Gtk::Label(_("Currently there is no help available for this Extension. Please look on the Inkscape website or ask on the mailing lists if you have questions regarding this extension."))); retval->pack_start(*content, true, true, 5); content->set_line_wrap(true); content->show(); } else { } retval->show(); return retval; }
/** \brief Creates a Float Adjustment for a float parameter Builds a hbox with a label and a float adjustment in it. */ Gtk::Widget * ParamFloat::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::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT)); label->show(); hbox->pack_start(*label, true, true); ParamFloatAdjustment * fadjust = Gtk::manage(new ParamFloatAdjustment(this, doc, node, changeSignal)); Gtk::SpinButton * spin = Gtk::manage(new Gtk::SpinButton(*fadjust, 0.1, _precision)); spin->show(); hbox->pack_start(*spin, false, false); hbox->show(); return dynamic_cast<Gtk::Widget *>(hbox); }
void WebDavSyncServiceAddin::add_row(Gtk::Table *table, Gtk::Widget *widget, const Glib::ustring & labelText, uint row) { Gtk::Label *l = new Gtk::Label(labelText); l->set_use_underline(true); l->property_xalign() = 0.0f; l->show(); table->attach(*l, 0, 1, row, row + 1, Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0); widget->show(); table->attach(*widget, 1, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0); l->set_mnemonic_widget(*widget); // TODO: Tooltips }
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(); }
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); } }
// Creates buttons with labels. Sets butBox elements to have the same size, // with 10 pixels between widgets View::View(Controller *c, Model *m) : model_(m), controller_(c), hand_(true,10), table_(true,10), gameBox_(false,10) { nullCardPixbuf_ = deck_.getNullCardImage(); // Sets some properties of the window. set_title( "Straights UI" ); //Gtk::JUSTIFY_CENTER set_default_size( 750, 500 ); add ( gameBox_ ); Gtk::HBox* menu = Gtk::manage( new Gtk::HBox() ); // Make the start button startButton_.signal_clicked().connect( sigc::mem_fun( *this, &View::on_start_game_clicked_) ); startButton_.add_label("Start New Game"); endButton_.signal_clicked().connect( sigc::mem_fun( *this, &View::on_end_game_clicked_) ); endButton_.add_label("End Current Game"); menu->pack_start( startButton_); menu->pack_start( endButton_); gameBox_.pack_start( *menu, Gtk::PACK_SHRINK ); Gtk::VBox* cardArea = Gtk::manage( new Gtk::VBox() ); Gtk::Label *cardLabel = new Gtk::Label( "Cards on the table:" ); cardLabel->set_alignment( Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP ); cardArea->pack_start( *cardLabel); gameBox_.pack_start( *cardArea, Gtk::PACK_SHRINK ); cardLabel->show(); for (int j = 0; j < 4; j++) { for (int i = 0; i < 13; i++ ) { cards_[j][i] = new Gtk::Image( nullCardPixbuf_ ); suit_[j].pack_start( *cards_[j][i] ); } table_.pack_start( suit_[j], Gtk::PACK_SHRINK, true, 0 ); } gameBox_.pack_start( table_, Gtk::PACK_SHRINK, true, 0 ); /* for (int i = 0; i < 4; i++ ) { pScore_.push_back(0); pDiscards_.push_back(0); } */ for ( int i = 0; i < 4; i++ ) { Gtk::VBox* playerArea = Gtk::manage( new Gtk::VBox(true, 0 ) ); playerRagequit_[i].set_label( "Rage!" ); playerRagequit_[i].signal_clicked().connect( sigc::bind(sigc::mem_fun( *this, &View::on_rage_clicked_ ), i) ); stringstream temp_i; temp_i << (i+1); Gtk::Label *playerLabel = new Gtk::Label( "Player " + temp_i.str() ); playerRagequit_[i].set_sensitive(false); playerLabel->set_alignment( Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP ); //stringstream temp_score; temp_score << pScore_[i]; pScore_.push_back(0); playerScore_[i] = new Gtk::Label( "0 points" ); //stringstream temp_disc; temp_disc << pDiscards_[i]; pDiscards_.push_back(0); playerDiscards_[i] = new Gtk::Label( " 0 discards" ); playerArea->pack_start( *playerLabel ); playerArea->pack_start( playerRagequit_[i] ); playerArea->pack_start( *playerScore_[i] ); playerArea->pack_start( *playerDiscards_[i] ); playerFrame_[i].add( *playerArea ); player_.pack_start( playerFrame_[i]); } gameBox_.pack_start( player_, Gtk::PACK_SHRINK, true, 0 ); Gtk::VBox* handArea = Gtk::manage( new Gtk::VBox() ); Gtk::Label *handLabel = new Gtk::Label( "Your Hand:" ); handLabel->set_alignment( Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP ); handArea->pack_start( *handLabel); gameBox_.pack_start( *handArea, Gtk::PACK_SHRINK ); handLabel->show(); //Display empty 13 cards for (int i = 0; i < 13; i++) { Gtk::Image *image = Gtk::manage( new Gtk::Image ( nullCardPixbuf_ ) ); currentHand_[i].set_image( *image ); currentHand_[i].set_sensitive(false); currentHand_[i].signal_clicked().connect( sigc::bind(sigc::mem_fun( *this, &View::on_card_clicked_ ), i) ); hand_.pack_start( currentHand_[i], Gtk::PACK_SHRINK, true, 0 ); } gameBox_.pack_start( hand_, Gtk::PACK_SHRINK); Gtk::VBox* playerLegalCardsArea = Gtk::manage( new Gtk::VBox() ); playerLegalCards_ = new Gtk::Label( "" ); playerLegalCards_->set_padding ( 10, 10 ); playerLegalCardsArea->pack_start( *playerLegalCards_ ); gameBox_.pack_start( *playerLegalCardsArea ); Gtk::VBox* playerTurnArea = Gtk::manage( new Gtk::VBox() ); playerTurn_ = new Gtk::Label( "" ); // playerTurn_->override_color(Gdk::RGBA("red")); playerTurn_->set_padding ( 15, 15 ); playerTurnArea->pack_start( *playerTurn_ ); gameBox_.pack_start( *playerTurnArea ); // Register view as observer of model model_->subscribe(this); // The final step is to display the buttons (they display themselves) show_all(); }
/** \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); }
Gobby::StatusBar::MessageHandle Gobby::StatusBar::add_message(Gobby::StatusBar::MessageType type, const Glib::ustring& message, const Glib::ustring& dialog_message, unsigned int timeout) { if(m_visible_messages >= 12) { for(MessageHandle iter = m_list.begin(); iter != m_list.end(); ++iter) { if(*iter) { if((*iter)->is_error()) remove_message(iter); else // only hide message because whoever // installed it is expecting to be // able to call remove_message on it hide_message(iter); break; } } } Gtk::Grid* grid = Gtk::manage(new Gtk::Grid()); grid->set_column_spacing(6); grid->set_margin_start(2); grid->set_margin_end(2); Gtk::Image* image = Gtk::manage(new Gtk::Image); image->set_from_icon_name(message_type_to_icon_name(type), Gtk::ICON_SIZE_MENU); grid->attach(*image, 0, 0, 1, 1); image->show(); Gtk::Label* label = Gtk::manage( new Gtk::Label(message, Gtk::ALIGN_START)); label->set_ellipsize(Pango::ELLIPSIZE_END); // If we set halign instead, the label will not behave correctly // when ellipsized, because then it has always all space around it // allocated, and the alignment "jumps" around whin resizing the // window due to new characters appearing or disappearing as a result // of the ellipsization. #if GTK_CHECK_VERSION(3, 16, 0) gtk_label_set_xalign(label->gobj(), 0.0); #else label->set_alignment(0.0, 0.0); #endif label->show(); grid->attach(*label, 1, 0, 1, 1); Gtk::Frame* frame = Gtk::manage(new Gtk::Frame); m_list.push_back(0); Gobby::StatusBar::MessageHandle iter(--m_list.end()); sigc::connection timeout_conn; if(timeout) { timeout_conn = Glib::signal_timeout().connect_seconds( sigc::bind( sigc::bind_return( sigc::mem_fun( *this, &StatusBar::remove_message), false), iter), timeout); } *iter = new Message(frame, message, dialog_message, timeout_conn); ++m_visible_messages; if(dialog_message.empty()) { frame->add(*grid); } else { Gtk::EventBox *eventbox = Gtk::manage(new Gtk::EventBox); frame->add(*eventbox); eventbox->add(*grid); eventbox->signal_button_press_event().connect( sigc::bind_return(sigc::bind( sigc::mem_fun( *this, &StatusBar::on_message_clicked), iter), false)); eventbox->show(); } grid->show(); // Insert at front gtk_grid_attach_next_to( gobj(), GTK_WIDGET(frame->gobj()), NULL, GTK_POS_LEFT, 1, 1); frame->set_halign(Gtk::ALIGN_START); frame->set_hexpand(false); frame->set_shadow_type(Gtk::SHADOW_NONE); frame->show(); return iter; }
limitDialog::limitDialog() : limit_interval(5), limit_selected(false), selected_upload_disable(false), selected_download_disable(false), selected_seed_percent_disable(false), selected_seed_timer_disable(false), uploadCombo(0), downloadCombo(0), seedPercentSpin(0), seedTimeSpin(0), selected_upload_limit(-1), selected_download_limit(-1) { Gtk::Label *uploadLabel = Gtk::manage(new class Gtk::Label("Upload")); Gtk::Label *downloadLabel = Gtk::manage(new class Gtk::Label("Download")); uploadCombo = Gtk::manage(new class Gtk::ComboBoxText()); downloadCombo = Gtk::manage(new class Gtk::ComboBoxText()); Gtk::Label *seedPercentLabel = Gtk::manage(new class Gtk::Label("Seed %")); Gtk::Label *seedTimeLabel = Gtk::manage(new class Gtk::Label("Seed Time")); Gtk::Adjustment *seedPercentAdjustment = Gtk::manage(new class Gtk::Adjustment(1, 0, 100, 1, 10, 10)); seedPercentSpin = Gtk::manage(new class Gtk::SpinButton(*seedPercentAdjustment, 1, 0)); Gtk::Adjustment *seedTimeAdjustment = Gtk::manage(new class Gtk::Adjustment(1, 0, 100, 1, 10, 10)); seedTimeSpin = Gtk::manage(new class Gtk::SpinButton(*seedTimeAdjustment, 1, 0)); Gtk::Table *settingsTable = Gtk::manage(new class Gtk::Table(4, 2, false)); Gtk::VBox *limitVbox = Gtk::manage(new class Gtk::VBox(false, 10)); uploadLabel->set_alignment(0,0.5); uploadLabel->set_padding(5,0); uploadLabel->set_justify(Gtk::JUSTIFY_LEFT); uploadLabel->set_line_wrap(false); uploadLabel->set_use_markup(false); uploadLabel->set_selectable(false); downloadLabel->set_alignment(0,0.5); downloadLabel->set_padding(5,0); downloadLabel->set_justify(Gtk::JUSTIFY_LEFT); downloadLabel->set_line_wrap(false); downloadLabel->set_use_markup(false); downloadLabel->set_selectable(false); seedPercentLabel->set_alignment(0,0.5); seedPercentLabel->set_padding(5,0); seedPercentLabel->set_justify(Gtk::JUSTIFY_LEFT); seedPercentLabel->set_line_wrap(false); seedPercentLabel->set_use_markup(false); seedPercentLabel->set_selectable(false); seedTimeLabel->set_alignment(0,0.5); seedTimeLabel->set_padding(5,0); seedTimeLabel->set_justify(Gtk::JUSTIFY_LEFT); seedTimeLabel->set_line_wrap(false); seedTimeLabel->set_use_markup(false); seedTimeLabel->set_selectable(false); seedPercentSpin->set_flags(Gtk::CAN_FOCUS); seedPercentSpin->set_update_policy(Gtk::UPDATE_ALWAYS); seedPercentSpin->set_numeric(false); seedPercentSpin->set_digits(0); seedPercentSpin->set_wrap(false); seedPercentSpin->set_range(0, MaxSeedProcent); seedTimeSpin->set_flags(Gtk::CAN_FOCUS); seedTimeSpin->set_update_policy(Gtk::UPDATE_ALWAYS); seedTimeSpin->set_numeric(false); seedTimeSpin->set_digits(0); seedTimeSpin->set_wrap(false); seedTimeSpin->set_range(0, MaxSeedTimeout); uploadCombo->append_text("disable"); downloadCombo->append_text("disable"); for (t_int i=limit_interval; i<=200; i=i+limit_interval) { using namespace std; using namespace btg::core; string s = convertToString<int>(i) + " KiB/sec"; uploadCombo->append_text(s); downloadCombo->append_text(s); } uploadCombo->set_active(0); downloadCombo->set_active(0); settingsTable->set_border_width(10); settingsTable->set_row_spacings(20); settingsTable->set_col_spacings(5); /* */ settingsTable->attach(*uploadLabel, 0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*downloadLabel, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*seedPercentLabel, 0, 1, 2, 3, Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*seedTimeLabel, 0, 1, 3, 4, Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*seedPercentSpin, 1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*seedTimeSpin, 1, 2, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*uploadCombo, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0); settingsTable->attach(*downloadCombo, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0); limitVbox->pack_start(*settingsTable, Gtk::PACK_SHRINK, 0); set_title( GPD->sGUI_CLIENT() + " " + GPD->sVERSION() + " / Limit" ); 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(*limitVbox); set_default_size(300, 200); uploadLabel->show(); downloadLabel->show(); seedPercentLabel->show(); seedTimeLabel->show(); uploadCombo->show(); downloadCombo ->show(); seedPercentSpin->show(); seedTimeSpin->show(); settingsTable->show(); limitVbox->show(); // Create buttons and connect their signals. add_button("Set", 1); add_button("Cancel", 2); signal_response().connect(sigc::mem_fun(*this, &limitDialog::on_button_pressed)); get_vbox()->show(); show(); }
PluginDisplay::PluginDisplay(gx_engine::GxMachineBase& machine_, Glib::RefPtr<Gdk::Pixbuf> icon, sigc::slot<void, bool, bool> finished_callback_) : machine(machine_), pluginlist(), current_plugin(0), old_state(0), bld(), change_count(0), actiongroup(Gtk::ActionGroup::create("ladspa_window")), uimanager(), enum_liststore(new EnumListStore), port_liststore(new PortListStore), plugin_liststore(new PluginListStore), masteridx_liststore(new MasterIdxListStore), on_reordered_conn(), display_type_list(), display_type_list_sr(), output_type_list(), finished_callback(finished_callback_) { std::vector<std::string> old_not_found; machine.load_ladspalist(old_not_found, pluginlist); bld = gx_gui::GxBuilder::create_from_file(machine.get_options().get_builder_filepath("ladspaliste.glade")); bld->get_toplevel("window1", window); bld->find_widget("treeview1", treeview1); bld->find_widget("treeview2", treeview2); bld->find_widget("treeview3", treeview3); bld->find_widget("ladspa_category", ladspa_category); bld->find_widget("ladspa_maker", ladspa_maker); bld->find_widget("ladspa_uniqueid", ladspa_uniqueid); bld->find_widget("search_entry", search_entry); bld->find_widget("combobox_mono_stereo", combobox_mono_stereo); bld->find_widget("selected_only", selected_only); bld->find_widget("changed_only", changed_only); bld->find_widget("ladspa_only", ladspa_only); bld->find_widget("lv2_only", lv2_only); bld->find_widget("show_all", show_all); bld->find_widget("details_box", details_box); bld->find_widget("plugin_name", plugin_name); bld->find_widget("plugin_category", plugin_category); bld->find_widget("plugin_quirks", plugin_quirks); bld->find_widget("master_slider_idx", master_slider_idx); bld->find_widget("master_slider_name", master_slider_name); bld->find_widget("cellrenderer_master", cellrenderer_master); bld->find_widget("cellrenderer_newrow", cellrenderer_newrow); bld->find_widget("cellrenderer_caption", cellrenderer_caption); bld->find_widget("cellrenderer_active", cellrenderer_active); bld->find_widget("cellrenderer_category", cellrenderer_category); bld->find_widget("cellrenderer_quirks", cellrenderer_quirks); set_title(); actiongroup->add(Gtk::Action::create("FileMenuAction",_("_File"))); save_action = Gtk::Action::create("SaveAction", _("_Ok")); actiongroup->add(save_action, sigc::mem_fun(this, &PluginDisplay::on_save)); apply_action = Gtk::Action::create("ApplyAction", _("_Apply")); actiongroup->add(apply_action, sigc::mem_fun(this, &PluginDisplay::on_apply)); quit_action = Gtk::Action::create("QuitAction", _("_Quit")); actiongroup->add(quit_action, sigc::mem_fun(this, &PluginDisplay::on_quit)); select_all_action = Gtk::Action::create("SelectAllAction", _("_Select All")); actiongroup->add(select_all_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), true)); select_none_action = Gtk::Action::create("SelectNoneAction", _("Select _None")); actiongroup->add(select_none_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), false)); actiongroup->add(Gtk::Action::create("ViewMenuAction", _("_View"))); Glib::RefPtr<Gtk::Action> act = Gtk::Action::create("FindAction", _("_Find")); actiongroup->add(act, sigc::mem_fun(this, &PluginDisplay::on_find)); uimanager = Gtk::UIManager::create(); uimanager->insert_action_group(actiongroup, 0); uimanager->add_ui_from_string(menudef); //uimanager->get_widget("/ladspalist"); //Gtk::HBox *ww; bld->find_widget("menubox", ww); ww->pack_start(*uimanager->get_widget("/ladspalist")); window->add_accel_group(uimanager->get_accel_group()); window->signal_delete_event().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_event)); bld->find_widget("show_details", show_details); show_details->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_show_details)); treeview3->get_selection()->set_mode(Gtk::SELECTION_BROWSE); treeview3->set_model(enum_liststore); Gtk::CellRendererText *r; bld->find_widget("cellrenderer_label", r); r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_label_edited)); Gtk::TreeViewColumn *c; bld->find_widget("treeviewcolumn_label", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_label)); bld->find_widget("dry_wet_button", dry_wet_button); dry_wet_button->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_add_dry_wet_controller)); // dry_wet_button->set_active(current_plugin->add_wet_dry); Glib::RefPtr<Gtk::TreeSelection> sel = treeview2->get_selection(); sel->set_mode(Gtk::SELECTION_BROWSE); sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_parameter_selection_changed)); on_reordered_conn = port_liststore->signal_row_deleted().connect(sigc::mem_fun(this, &PluginDisplay::on_reordered)); treeview2->set_model(port_liststore); CellRendererComboDerived *rd; bld->find_widget_derived("cellrenderer_type", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder)); rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_type_edited)); bld->find_widget("treeviewcolumn_type", c); c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_type)); bld->find_widget_derived("cellrenderer_step", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder)); rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_step_edited)); bld->find_widget("treeviewcolumn_step", c); c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_step)); cellrenderer_newrow->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_newrow_toggled)); Gtk::Label *label = new Gtk::Label("N"); label->set_tooltip_text(_("start a new row of controls in the rackbox unit")); label->show(); bld->find_widget("treeviewcolumn_newrow", c); c->set_widget(*manage(label)); c->set_cell_data_func(*cellrenderer_newrow, sigc::mem_fun(this, &PluginDisplay::display_newrow)); cellrenderer_caption->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_caption_toggled)); label = new Gtk::Label("C"); label->set_tooltip_text(_("display the name as caption above the control")); label->show(); bld->find_widget("treeviewcolumn_caption", c); c->set_widget(*manage(label)); c->set_cell_data_func(*cellrenderer_caption, sigc::mem_fun(this, &PluginDisplay::display_caption)); bld->find_widget("cellrenderer_name", r); r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_name_edited)); bld->find_widget("treeviewcolumn_name", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_name)); bld->find_widget("cellrenderer_dflt", r); r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_dflt_edited)); bld->find_widget("treeviewcolumn_dflt", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_default)); bld->find_widget("cellrenderer_low", r); r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_low_edited)); bld->find_widget("treeviewcolumn_low", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_lower)); bld->find_widget("cellrenderer_up", r); r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_up_edited)); bld->find_widget("treeviewcolumn_up", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_upper)); bld->find_widget("cellrenderer_idx", r); bld->find_widget("treeviewcolumn_idx", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_idx)); bld->find_widget("treeviewcolumn_SR", c); label = new Gtk::Label("SR"); label->set_tooltip_text(_("marked rows: range depends on samplerate; using 44100 as fixed value")); label->show(); c->set_widget(*manage(label)); Gtk::CellRendererToggle *t; bld->find_widget("cellrenderer_SR", t); c->set_cell_data_func(*t, sigc::mem_fun(this, &PluginDisplay::display_SR)); Gtk::TreeModelColumnRecord recdef; Gtk::TreeModelColumn<Glib::ustring> strcol; Gtk::TreeModelColumn<DisplayType> intcol; recdef.add(strcol); recdef.add(intcol); display_type_list = Gtk::ListStore::create(recdef); append_displaytype(display_type_list, tp_scale); append_displaytype(display_type_list, tp_scale_log); append_displaytype(display_type_list, tp_toggle); append_displaytype(display_type_list, tp_int); append_displaytype(display_type_list, tp_enum); append_displaytype(display_type_list, tp_none); display_type_list_sr = Gtk::ListStore::create(recdef); append_displaytype(display_type_list_sr, tp_scale); append_displaytype(display_type_list_sr, tp_scale_log); append_displaytype(display_type_list_sr, tp_none); output_type_list = Gtk::ListStore::create(recdef); append_displaytype(output_type_list, tp_display); append_displaytype(output_type_list, tp_display_toggle); append_displaytype(output_type_list, tp_none); treeview1->signal_row_activated().connect(sigc::mem_fun(this, &PluginDisplay::on_row_activated)); treeview1->set_search_equal_func(sigc::mem_fun(this,&PluginDisplay::search_equal)); Gtk::Entry *e; bld->find_widget("search_entry", e); e->signal_activate().connect(sigc::mem_fun(this, &PluginDisplay::on_search_entry_activate)); treeview1->set_search_entry(*e); sel = treeview1->get_selection(); sel->set_mode(Gtk::SELECTION_BROWSE); sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::selection_changed)); treeview1->set_model(plugin_liststore); cellrenderer_active->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_active_toggled)); bld->find_widget("cellrenderer_ladspa", r); bld->find_widget("treeviewcolumn_ladspa", c); c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_ladspa)); Gtk::ComboBox *cb; bld->find_widget("plugin_category", cb); cb->set_cell_data_func(*cellrenderer_category, sigc::mem_fun(this, &PluginDisplay::display_category)); bld->find_widget("plugin_quirks", cb); cb->set_cell_data_func(*cellrenderer_quirks, sigc::mem_fun(this, &PluginDisplay::display_quirks)); master_slider_idx->set_cell_data_func(*cellrenderer_master, sigc::mem_fun(this, &PluginDisplay::display_master_idx)); master_slider_idx->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::set_master_text)); selected_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), selected_only)); changed_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), changed_only)); ladspa_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), ladspa_only)); lv2_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), lv2_only)); show_all->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), show_all)); bld->find_widget("combobox_mono_stereo", cb); cb->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_mono_stereo_changed)); cb->set_active(0); Gtk::Button *b; bld->find_widget("reset_changes", b); b->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_changes)); bld->find_widget("master_slider_idx", cb); cb->set_model(masteridx_liststore); bld->find_widget("button_cancel", b); gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("QuitAction")->gobj()); bld->find_widget("button_apply", b); gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("ApplyAction")->gobj()); bld->find_widget("button_save", b); gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SaveAction")->gobj()); bld->find_widget("select_all", b); gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectAllAction")->gobj()); bld->find_widget("select_none", b); gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectNoneAction")->gobj()); window->set_icon(icon); window->show(); }
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(); }
aboutDialog::aboutDialog() { Gtk::Dialog *ad = this; Gtk::Button *okbutton = Gtk::manage(new class Gtk::Button("ok")); Gtk::Label *aboutLabel = Gtk::manage(new class Gtk::Label( "About " + GPD->sGUI_CLIENT() + " " + GPD->sVERSION() + ", build " + GPD->sBUILD() )); Gtk::TextView *textview = Gtk::manage(new class Gtk::TextView()); Gtk::ScrolledWindow *scrolledwindow = Gtk::manage(new class Gtk::ScrolledWindow()); Gtk::VBox *vbox = Gtk::manage(new class Gtk::VBox(false, 0)); okbutton->set_flags(Gtk::CAN_FOCUS); okbutton->set_relief(Gtk::RELIEF_NORMAL); ad->get_action_area()->property_layout_style().set_value(Gtk::BUTTONBOX_END); ad->set_default_size(300, 200); aboutLabel->set_alignment(0.5,0.5); aboutLabel->set_padding(0,0); aboutLabel->set_justify(Gtk::JUSTIFY_LEFT); aboutLabel->set_line_wrap(false); aboutLabel->set_use_markup(false); aboutLabel->set_selectable(false); textview->set_flags(Gtk::CAN_FOCUS); textview->set_editable(true); textview->set_cursor_visible(true); textview->set_pixels_above_lines(0); textview->set_pixels_below_lines(0); textview->set_pixels_inside_wrap(0); textview->set_left_margin(0); textview->set_right_margin(0); textview->set_indent(0); textview->set_wrap_mode(Gtk::WRAP_NONE); textview->set_justification(Gtk::JUSTIFY_LEFT); using namespace std; string text; text += "btg Copyright (C) 2005 Michael Wojciechowski."; text += GPD->sNEWLINE(); text += "This program is free software; you can redistribute it and/or modify"; text += GPD->sNEWLINE(); text += "it under the terms of the GNU General Public License as published by "; text += GPD->sNEWLINE(); text += "the Free Software Foundation; either version 2 of the License, or "; text += GPD->sNEWLINE(); text += "(at your option) any later version."; text += GPD->sNEWLINE(); text += "This program is distributed in the hope that it will be useful, "; text += GPD->sNEWLINE(); text += "but WITHOUT ANY WARRANTY; without even the implied warranty of "; text += GPD->sNEWLINE(); text += "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "; text += GPD->sNEWLINE(); text += "GNU General Public License for more details."; text += GPD->sNEWLINE(); text += "You should have received a copy of the GNU General Public License "; text += GPD->sNEWLINE(); text += "along with this program; if not, write to the Free Software "; text += GPD->sNEWLINE(); text += "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA"; text += GPD->sNEWLINE(); textview->get_buffer()->set_text(text); scrolledwindow->set_flags(Gtk::CAN_FOCUS); scrolledwindow->set_shadow_type(Gtk::SHADOW_IN); scrolledwindow->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); scrolledwindow->property_window_placement().set_value(Gtk::CORNER_TOP_LEFT); scrolledwindow->add(*textview); vbox->pack_start(*aboutLabel, Gtk::PACK_SHRINK, 0); vbox->pack_start(*scrolledwindow); ad->get_vbox()->set_homogeneous(false); ad->get_vbox()->set_spacing(0); ad->get_vbox()->pack_start(*vbox); //ad->set_title( "About " + GPD->sGUI_CLIENT() + " " + GPD->sVERSION() ); ad->set_title( GPD->sGUI_CLIENT() + " " + GPD->sVERSION() + " / About" ); ad->set_modal(true); ad->property_window_position().set_value(Gtk::WIN_POS_CENTER); ad->set_resizable(true); ad->property_destroy_with_parent().set_value(false); ad->set_has_separator(true); ad->add_action_widget(*okbutton, -5); okbutton->show(); aboutLabel->show(); textview->show(); scrolledwindow->show(); vbox->show(); okbutton->signal_clicked().connect(sigc::mem_fun(*this, &aboutDialog::on_ok_clicked)); // ad->show(); }
sessionSelectionDialog::sessionSelectionDialog(std::string const& _title, t_longList const& _sessionIDs, t_strList const& _sessionsNames, bool const _disableSelection) : disableSelection_(_disableSelection), selected(false), session(Command::INVALID_SESSION), cbt(0) { Gtk::Button* cancelbutton = Gtk::manage(new class Gtk::Button(Gtk::StockID("gtk-cancel"))); Gtk::Button* okbutton = Gtk::manage(new class Gtk::Button(Gtk::StockID("gtk-ok"))); Gtk::Label* label = Gtk::manage(new class Gtk::Label(_title)); cbt = Gtk::manage(new class Gtk::ComboBoxText()); Gtk::VBox* vbox = Gtk::manage(new class Gtk::VBox(false, 0)); cancelbutton->set_flags(Gtk::CAN_FOCUS); cancelbutton->set_relief(Gtk::RELIEF_NORMAL); okbutton->set_flags(Gtk::CAN_FOCUS); okbutton->set_relief(Gtk::RELIEF_NORMAL); get_action_area()->property_layout_style().set_value(Gtk::BUTTONBOX_END); label->set_alignment(0.5,0.5); label->set_padding(0,0); label->set_justify(Gtk::JUSTIFY_LEFT); label->set_line_wrap(false); label->set_use_markup(false); label->set_selectable(false); vbox->pack_start(*label, Gtk::PACK_SHRINK, 0); vbox->pack_start(*cbt); get_vbox()->set_homogeneous(false); get_vbox()->set_spacing(0); get_vbox()->pack_start(*vbox); set_title(_title); set_modal(true); property_window_position().set_value(Gtk::WIN_POS_NONE); set_resizable(true); property_destroy_with_parent().set_value(false); set_has_separator(true); add_action_widget(*cancelbutton, -6); add_action_widget(*okbutton, -5); /// Fill the combobox with session ids. t_strListCI sessionNameIter = _sessionsNames.begin(); for (t_longListCI sessionIter = _sessionIDs.begin(); sessionIter != _sessionIDs.end(); sessionIter++) { std::string session_descr = convertToString<t_long>(*sessionIter); session_descr += " ("; session_descr += *sessionNameIter; session_descr += ")"; cbt->append_text(session_descr); sessionNameIter++; } // Select the first session id. cbt->set_active(0); if (!disableSelection_) { cancelbutton->show(); } okbutton->show(); label->show(); cbt->show(); vbox->show(); show(); // Connect buttons to handlers. okbutton->signal_clicked().connect(sigc::mem_fun(*this, &sessionSelectionDialog::on_ok_clicked)); if (!disableSelection_) { cancelbutton->signal_clicked().connect(sigc::mem_fun(*this, &sessionSelectionDialog::on_cancel_clicked)); } }
Gobby::StatusBar::MessageHandle Gobby::StatusBar::add_message(Gobby::StatusBar::MessageType type, const Glib::ustring& message, const Glib::ustring& dialog_message, unsigned int timeout) { if(m_visible_messages >= 12) { for(MessageHandle iter = m_list.begin(); iter != m_list.end(); ++iter) { if(*iter) { if((*iter)->is_error()) remove_message(iter); else // only hide message because whoever // installed it is expecting to be // able to call remove_message on it hide_message(iter); break; } } } Gtk::HBox* bar = Gtk::manage(new Gtk::HBox); Gtk::Image* image = Gtk::manage(new Gtk::Image( message_type_to_stock_id(type), Gtk::ICON_SIZE_MENU)); bar->pack_start(*image, Gtk::PACK_SHRINK); image->show(); Gtk::Label* label = Gtk::manage( new Gtk::Label(message, GtkCompat::ALIGN_LEFT)); label->set_ellipsize(Pango::ELLIPSIZE_END); bar->pack_start(*label, Gtk::PACK_EXPAND_WIDGET); label->show(); GtkShadowType shadow_type; gtk_widget_style_get(GTK_WIDGET(m_bar_position.gobj()), "shadow-type", &shadow_type, NULL); Gtk::Frame* frame = Gtk::manage(new Gtk::Frame); m_list.push_back(0); Gobby::StatusBar::MessageHandle iter(--m_list.end()); sigc::connection timeout_conn; if(timeout) { timeout_conn = Glib::signal_timeout().connect_seconds( sigc::bind( sigc::bind_return( sigc::mem_fun( *this, &StatusBar::remove_message), false), iter), timeout); } *iter = new Message(frame, message, dialog_message, timeout_conn); ++m_visible_messages; if(dialog_message.empty()) { frame->add(*bar); } else { Gtk::EventBox *eventbox = Gtk::manage(new Gtk::EventBox); frame->add(*eventbox); eventbox->add(*bar); eventbox->signal_button_press_event().connect( sigc::bind_return(sigc::bind( sigc::mem_fun( *this, &StatusBar::on_message_clicked), iter), false)); eventbox->show(); } frame->set_shadow_type(static_cast<Gtk::ShadowType>(shadow_type)); bar->show(); pack_start(*frame, Gtk::PACK_EXPAND_WIDGET); reorder_child(*frame, 0); frame->show(); return iter; }
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(); }
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(); }
/*! Constructor * \param[in] el the configuration element to display * \param[in] differ shall the changes be applied later using apply_changes()? */ ConfigElement::ConfigElement(crn::ConfigElement &el, bool differ): value(el.GetValue()), tmpvalue(el.GetValue()) { if (!value) throw crn::ExceptionUninitialized(_("The element was not initialized.")); if (differ) tmpvalue = crn::Clone(*value); if (std::dynamic_pointer_cast<crn::Int>(tmpvalue)) typ = U"Int"; else if (std::dynamic_pointer_cast<crn::Real>(tmpvalue)) typ = U"Real"; else if (std::dynamic_pointer_cast<crn::Prop3>(tmpvalue)) typ = U"Prop3"; else if (std::dynamic_pointer_cast<crn::String>(tmpvalue)) typ = U"String"; else if (std::dynamic_pointer_cast<crn::StringUTF8>(tmpvalue)) typ = U"StringUTF8"; else if (std::dynamic_pointer_cast<crn::Path>(tmpvalue)) typ = U"Path"; Gtk::Label *lab = Gtk::manage(new Gtk::Label(el.GetName().CStr())); lab->show(); pack_start(*lab, false, true, 2); if (typ == U"Prop3") { Prop3 *p = Gtk::manage(new Prop3(Gtk::ICON_SIZE_BUTTON, el.GetValue<crn::Prop3>())); p->signal_value_changed().connect(sigc::mem_fun(this, &ConfigElement::on_p3_changed)); p->show(); pack_start(*p, true, true, 2); } else if (!el.GetAllowedValues().IsEmpty()) { // any Int, Real, String, StringUTF8 or Path Gtk::ComboBoxText *cb = Gtk::manage(new Gtk::ComboBoxText); const std::vector<crn::StringUTF8> values(el.GetAllowedValues<crn::StringUTF8>()); for (const crn::StringUTF8 &val : values) #ifdef CRN_USING_GTKMM3 cb->append(val.CStr()); #else /* CRN_USING_GTKMM3 */ cb->append_text(val.CStr()); #endif /* CRN_USING_GTKMM3 */ cb->set_active_text(el.GetValue<crn::StringUTF8>().CStr()); cb->signal_changed().connect(sigc::bind(sigc::mem_fun(this, &ConfigElement::on_combo_changed), cb)); cb->show(); pack_start(*cb, true, true, 2); } else if (typ == U"Int") { if (el.HasMinValue() && el.HasMaxValue()) { // has finite range, use a slider #ifdef CRN_USING_GTKMM3 auto *s = Gtk::manage(new Gtk::Scale(Gtk::ORIENTATION_HORIZONTAL)); s->set_range(el.GetMinValue<int>(), el.GetMaxValue<int>() + 1); s->set_increments(1, 1); #else Gtk::HScale *s = Gtk::manage(new Gtk::HScale(el.GetMinValue<int>(), el.GetMaxValue<int>() + 1, 1)); #endif s->set_value(el.GetValue<int>()); s->signal_value_changed().connect(sigc::bind(sigc::mem_fun(this, &ConfigElement::on_range_changed), s)); s->show(); pack_start(*s, true, true, 2); } else { // has at least one infinite (maxed) bound, use a spin button Gtk::SpinButton *s = Gtk::manage(new Gtk::SpinButton); int m = std::numeric_limits<int>::min(), M = std::numeric_limits<int>::max(); if (el.HasMinValue()) m = el.GetMinValue<int>(); if (el.HasMaxValue()) M = el.GetMaxValue<int>(); s->set_range(m, M); s->set_increments(1, 10); s->set_value(el.GetValue<int>()); s->signal_value_changed().connect(sigc::bind(sigc::mem_fun(this, &ConfigElement::on_spin_changed), s)); s->show(); pack_start(*s, true, true, 2); } } else if (typ == U"Real") { if (el.HasMinValue() && el.HasMaxValue()) { // has finite range, use a slider #ifdef CRN_USING_GTKMM3 auto *s = Gtk::manage(new Gtk::Scale(Gtk::ORIENTATION_HORIZONTAL)); s->set_range(el.GetMinValue<double>(), el.GetMaxValue<double>() + 0.01); s->set_increments(0.01, 0.01); #else Gtk::HScale *s = Gtk::manage(new Gtk::HScale(el.GetMinValue<double>(), el.GetMaxValue<double>() + 0.01, 0.01)); #endif s->set_digits(2); s->set_value(el.GetValue<double>()); s->signal_value_changed().connect(sigc::bind(sigc::mem_fun(this, &ConfigElement::on_range_changed), s)); s->show(); pack_start(*s, true, true, 2); } else { // has at least one infinite (maxed) bound, use a spin button Gtk::SpinButton *s = Gtk::manage(new Gtk::SpinButton(0, 2)); double m = -std::numeric_limits<double>::max(), M = std::numeric_limits<double>::max(); if (el.HasMinValue()) m = el.GetMinValue<double>(); if (el.HasMaxValue()) M = el.GetMaxValue<double>(); s->set_range(m, M); s->set_increments(0.01, 1); s->set_value(el.GetValue<double>()); s->signal_value_changed().connect(sigc::bind(sigc::mem_fun(this, &ConfigElement::on_spin_changed), s)); s->show(); pack_start(*s, true, true, 2); } } else // string types { Gtk::Entry *e = Gtk::manage(new Gtk::Entry); e->set_text(el.GetValue<crn::StringUTF8>().CStr()); e->signal_changed().connect(sigc::bind(sigc::mem_fun(this, &ConfigElement::on_entry_changed), e)); e->show(); pack_start(*e, true, true, 2); } lab = Gtk::manage(new Gtk::Label("?")); lab->show(); lab->set_tooltip_text(el.GetDescription().CStr()); pack_start(*lab, false, true, 2); }
void dv_selector_widget::set_source_count(unsigned count) { if (count > thumbnails_.size()) { resize(count, 1); mixer::source_id first_new_source_id = thumbnails_.size(); try { thumbnails_.resize(count); for (mixer::source_id i = first_new_source_id; i != count; ++i) { unsigned column = 1; unsigned row = i * row_multiplier; if (0)//(i != 0 && i != count - 1) { Gtk::HSeparator * sep = manage(new Gtk::HSeparator); sep->show(); attach(*sep, column - 1, column, row, row + row_multiplier, Gtk::FILL, Gtk::FILL, 0, 0); } dv_thumb_display_widget * thumb = manage(new dv_thumb_display_widget); thumb->show(); attach(*thumb, column + column_display, column + column_display + 1, row, row + row_multiplier, Gtk::FILL, Gtk::FILL, 0, 0); thumbnails_[i] = thumb; char label_text[4]; snprintf(label_text, sizeof(label_text), (i < 9) ? "_%u" : "%u", unsigned(1 + i)); Gtk::Label * label = manage(new Gtk::Label(label_text, true)); label->show(); attach(*label, column + column_labels, column + column_labels + 1, row + row_text_label, row + row_text_label + 1, Gtk::FILL, Gtk::FILL, 0, 0); Gtk::RadioButton * pri_video_button = create_radio_button(pri_video_button_group_, pri_video_source_pixbuf_); pri_video_button->signal_pressed().connect( sigc::bind( sigc::mem_fun(*this, &dv_selector_widget::on_pri_video_selected), i)); pri_video_button->show(); attach(*pri_video_button, column + column_labels, column + column_labels + 1, row + row_pri_video_button, row + row_pri_video_button + 1, Gtk::FILL, Gtk::FILL, 0, 0); Gtk::RadioButton * audio_button = create_radio_button(audio_button_group_, audio_source_pixbuf_); audio_button_list_.push_back(audio_button); // disable by default, if not in expert mode audio_button->set_sensitive(expert_mode ? true : false); audio_button->signal_pressed().connect( sigc::bind( sigc::mem_fun(*this, &dv_selector_widget::on_audio_selected), i)); audio_button->show(); attach(*audio_button, column + column_labels, column + column_labels + 1, row + row_audio_button, row + row_audio_button + 1, Gtk::FILL, Gtk::FILL, 0, 0); if (i < 9) { // Make the mnemonic on the label work. Also make // the numeric keypad and Alt-keys work. label->set_mnemonic_widget(*pri_video_button); pri_video_button->add_accelerator("activate", accel_group_, GDK_KP_1 + i, Gdk::ModifierType(0), Gtk::AccelFlags(0)); pri_video_button->signal_activate().connect( sigc::bind( sigc::mem_fun( *this, &dv_selector_widget::on_pri_video_selected), i)); audio_button->add_accelerator("activate", accel_group_, '1' + i, Gdk::MOD1_MASK, Gtk::AccelFlags(0)); audio_button->add_accelerator("activate", accel_group_, GDK_KP_1 + i, Gdk::MOD1_MASK, Gtk::AccelFlags(0)); audio_button->signal_activate().connect( sigc::bind( sigc::mem_fun( *this, &dv_selector_widget::on_audio_selected), i)); } } } catch (std::exception & e) { // Roll back size changes thumbnails_.resize(first_new_source_id); std::cerr << "ERROR: Failed to add source display: " << e.what() << "\n"; } } }