/**
* 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";
}
}
}