//------------------------------------------------------------------------------ const IntColumn& ColumnsModel::append_int_column(const int bec_tm_idx, const std::string& name, const Editable editable) { Gtk::TreeModelColumn<int> *col = new Gtk::TreeModelColumn<int>; add(*col); add_bec_index_mapping(bec_tm_idx); int nr_of_cols; if ( editable == EDITABLE ) { nr_of_cols= _treeview->append_column_editable(bec::replace_string(name, "_", "__"), *col); Gtk::CellRendererText *cell = (Gtk::CellRendererText*)(_treeview->get_column_cell_renderer(nr_of_cols - 1)); cell->signal_edited().connect(sigc::bind (sigc::mem_fun(*_tmw ,&ListModelWrapper::after_cell_edit<int> ) , sigc::ref(*col) ) ); } else nr_of_cols= _treeview->append_column(bec::replace_string(name, "_", "__"), *col); _treeview->get_column(nr_of_cols-1)->set_resizable(true); _columns.push_back(col); return *col; }
ArbitratorPropertyWindow::ArbitratorPropertyWindow(MainWindow* parent, Manager* manager, ApplicationWindow* appWnd) { m_pParent = parent; m_pManager = manager; m_pAppWindow = appWnd; m_arbPort.clear(); /* Create a new scrolled window, with scrollbars only if needed */ set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); add(m_TreeView); /* create tree store */ m_refTreeModel = Gtk::TreeStore::create(m_Columns); m_TreeView.set_model(m_refTreeModel); //Add the Model’s column to the View’s columns: Gtk::CellRendererText* itemRenderer = Gtk::manage(new Gtk::CellRendererText()); itemRenderer->property_editable() = false; Gtk::TreeViewColumn* itemCol = Gtk::manage(new Gtk::TreeViewColumn("Property", *itemRenderer)); //itemCol->add_attribute(*itemRenderer, "background-gdk", m_Columns.m_col_color); itemCol->add_attribute(*itemRenderer, "text", m_Columns.m_col_name); itemCol->set_resizable(true); m_TreeView.append_column(*itemCol); Gtk::CellRendererText* valueRenderer = Gtk::manage(new Gtk::CellRendererText()); valueRenderer->property_editable() = false; Gtk::TreeViewColumn* valueCol = Gtk::manage(new Gtk::TreeViewColumn("Value", *valueRenderer)); valueCol->add_attribute(*valueRenderer, "foreground-gdk", m_Columns.m_col_color_value); valueCol->add_attribute(*valueRenderer, "text", m_Columns.m_col_value); valueCol->set_resizable(true); valueRenderer->property_editable() = true; //valueCol->set_cell_data_func(*valueRenderer, sigc::mem_fun(*this, // &ArbitratorPropertyWindow::onCellData) ); valueRenderer->signal_edited().connect( sigc::mem_fun(*this, &ArbitratorPropertyWindow::onCellEdited) ); m_TreeView.append_column(*valueCol); valueCol->add_attribute(*valueRenderer, "editable", m_Columns.m_col_editable); //m_TreeView.append_column_editable("Value", m_Columns.m_col_value); //m_TreeView.get_column(1)->set_resizable(true); //Tell the view column how to render the model values: m_TreeView.set_property("enable_grid_lines", true); show_all_children(); m_TreeView.set_grid_lines(Gtk::TREE_VIEW_GRID_LINES_BOTH); m_TreeView.set_rules_hint(true); }
const StringColumn& ColumnsModel::append_string_column(const int bec_tm_idx, const std::string& name, const Editable editable, const Iconic have_icon) { Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> > *icon= 0; Gtk::TreeViewColumn *column= Gtk::manage(new Gtk::TreeViewColumn(bec::replace_string(name, "_", "__"))); if ( have_icon == WITH_ICON ) { icon = new Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> >; add(*icon); add_bec_index_mapping(bec_tm_idx); column->pack_start(*icon, false); _columns.push_back(icon); } Gtk::TreeModelColumn<Glib::ustring> *col = new Gtk::TreeModelColumn<Glib::ustring>; add(*col); add_bec_index_mapping(bec_tm_idx); column->pack_start(*col); _columns.push_back(col); int nr_of_cols= _treeview->append_column(*column); _treeview->get_column(nr_of_cols-1)->set_resizable(true); if (editable == EDITABLE || editable == EDITABLE_WO_FIRST) { std::vector<Gtk::CellRenderer*> rends= column->get_cell_renderers(); Gtk::CellRendererText *cell = (Gtk::CellRendererText*)rends[icon ? 1 : 0]; cell->property_editable()= true; cell->signal_edited().connect(sigc::bind (sigc::mem_fun(*_tmw ,&ListModelWrapper::after_cell_edit<Glib::ustring> ) , sigc::ref(*col) ) ); if (editable == EDITABLE_WO_FIRST) column->set_cell_data_func(*cell, sigc::mem_fun(this, &ColumnsModel::disable_edit_first_row)); } return *col; }
//------------------------------------------------------------------------------ const StringColumn& ColumnsModel::append_combo_column(const int bec_tm_idx ,const std::string &name ,Glib::RefPtr<Gtk::ListStore> list_w ,const Editable editable ,bool popup_only) { Gtk::TreeModelColumn<Glib::ustring> *choosen = new Gtk::TreeModelColumn<Glib::ustring>; _columns.push_back(choosen); add(*choosen); add_bec_index_mapping(bec_tm_idx); Gtk::TreeView::Column *col = Gtk::manage(new Gtk::TreeViewColumn(bec::replace_string(name, "_", "__"))); Gtk::CellRendererCombo *cell = Gtk::manage(new Gtk::CellRendererCombo); col->pack_start(*cell); col->add_attribute(cell->property_text(), *choosen); cell->property_model() = list_w; cell->property_text_column() = 0; cell->property_editable() = editable; cell->property_has_entry() = !popup_only; Gtk::TreeModelColumn<Glib::RefPtr<Gtk::TreeModel> > *model_col = new Gtk::TreeModelColumn<Glib::RefPtr<Gtk::TreeModel> >(); add_bec_index_mapping(bec_tm_idx); add(*model_col); const int nr_of_cols = _treeview->append_column(*col); _columns.push_back(model_col); _treeview->get_column(nr_of_cols-1)->set_resizable(true); if ( editable == EDITABLE ) { Gtk::CellRendererText *cell = (Gtk::CellRendererText*)(_treeview->get_column_cell_renderer(nr_of_cols - 1)); cell->signal_edited().connect(sigc::bind (sigc::mem_fun(*_tmw ,&ListModelWrapper::after_cell_edit<Glib::ustring> ) , sigc::ref(*choosen) ) ); } return *choosen; }
void DomainIDataViewImpl::setTreeModel(Glib::RefPtr<Gtk::TreeModel> TreeModel, DomainIDataColumns* Columns) { mp_TreeView->remove_all_columns(); mp_TreeView->set_model(TreeModel); if (TreeModel->get_n_columns() < 2) return; mp_TreeView->append_column("Unit ID", *Columns->getIdColumn()); mp_TreeView->get_column(0)->set_sort_column(*Columns->getIdColumn()); std::map<std::string, Gtk::TreeModelColumn<std::string>*> ColumnsByTitle = Columns->getByTitleColumns(); for (std::map<std::string, Gtk::TreeModelColumn<std::string>*>::iterator it = ColumnsByTitle.begin(); it != ColumnsByTitle.end(); ++it) { int ColIndex = mp_TreeView->append_column_editable("", *it->second) - 1; /* * use of a widget label instead of a column title because * in column title, underscores have to be escaped by another one * (same as Label::set_use_underline(true)) */ Gtk::Label* TitleLabel = Gtk::manage(new Gtk::Label(it->first)); TitleLabel->set_visible(true); mp_TreeView->get_column(ColIndex)->set_widget(*TitleLabel); mp_TreeView->get_column(ColIndex)->set_sort_column(*it->second); Gtk::CellRendererText* CellRend = (Gtk::CellRendererText *) mp_TreeView->get_column_cell_renderer( ColIndex); CellRend->signal_edited().connect(sigc::bind<std::string>(sigc::mem_fun( *this, &DomainIDataViewImpl::onDataEdited), it->first)); } mp_TreeView->get_selection()->signal_changed().connect(sigc::mem_fun(*this, &DomainIDataViewImpl::onUnitSelectionChanged)); }
//TODO: klasse soll window extenden (schoener so) EwAccountsWin::EwAccountsWin() { EWLOG("In EwAccountsWin::EwAccountsWin()", 8); Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_file("data/EwAccountsWin.glade"); Gtk::Button *add, *del, *close; Gtk::ScrolledWindow *scrolledwindow; builder->get_widget("EwAccounts", window); builder->get_widget("add", add); builder->get_widget("delete", del); builder->get_widget("close", close); builder->get_widget("scrolledwindow", scrolledwindow); scrolledwindow->add(treeView); add->signal_clicked().connect(sigc::mem_fun(this, &EwAccountsWin::onAddBtnClicked)); del->signal_clicked().connect(sigc::mem_fun(this, &EwAccountsWin::onDelBtnClicked)); close->signal_clicked().connect(sigc::mem_fun(this, &EwAccountsWin::onCloseBtnClicked)); liststore = Gtk::ListStore::create(m_Columns); treeView.set_model(liststore); treeView.append_column("Enabled", m_Columns.m_col_enab); treeView.append_column_editable("Identifier", m_Columns.m_col_identifier); treeView.append_column("Use Https", m_Columns.m_col_https); Gtk::CellRendererText *crtu; Gtk::CellRendererToggle *crtenab, *crthttps; crtenab = dynamic_cast<Gtk::CellRendererToggle*>(treeView.get_column_cell_renderer(0)); crtenab->set_activatable(); crtenab->signal_toggled().connect(sigc::mem_fun(this, &EwAccountsWin::onColumnEnabledToggled)); crtu = dynamic_cast<Gtk::CellRendererText*>(treeView.get_column_cell_renderer(1)); crtu->signal_edited().connect(sigc::mem_fun(this, &EwAccountsWin::onColumnIdentifierChanged)); crthttps = dynamic_cast<Gtk::CellRendererToggle*>(treeView.get_column_cell_renderer(2)); crthttps->set_activatable(); crthttps->signal_toggled().connect(sigc::mem_fun(this, &EwAccountsWin::onColumnHttpsToggled)); std::list<EwAccountList::EwAccount> accounts = EwAccountList::Instance()->getAccounts(); for (std::list<EwAccountList::EwAccount>::iterator iter = accounts.begin(); iter != accounts.end(); iter++) { Gtk::TreeModel::Row row = *(liststore->append()); row[m_Columns.m_col_id] = (*iter).id; row[m_Columns.m_col_identifier] = (*iter).identifier; row[m_Columns.m_col_enab] = (*iter).enabled; row[m_Columns.m_col_https] = (*iter).https; } window->show_all_children(); Gtk::Main::run(*window); }
// Cringe. void GtkTorrentSideBar::setupColumns() { int cid = 0; Gtk::TreeViewColumn *col = nullptr; Gtk::CellRendererText *cell = Gtk::manage(new Gtk::CellRendererText()); Gtk::CellRendererPixbuf *cellp = Gtk::manage(new Gtk::CellRendererPixbuf()); cell->set_alignment(0, 0.5); cell->signal_edited().connect([this](const std::string& path,const std::string& name){ addedItem(path, name); }); cid = append_column(*Gtk::manage(new Gtk::TreeViewColumn("Name"))); col = get_column(cid - 1); col->pack_start(*cellp); col->pack_start(*cell); col->add_attribute(cell->property_markup(), m_cols.name); col->add_attribute(cell->property_editable(), m_cols.editable); col->add_attribute(cellp->property_pixbuf(), m_cols.icon); // This really isn't "setupColumns" anymore from this point. // TODO Move to own function m_torrent_row = *(m_liststore->append()); m_torrent_row[m_cols.name] = "Torrents"; m_torrent_row[m_cols.editable] = false; m_torrent_row[m_cols.clickCallback] = [](){}; // clicks on titles don't do shit auto torrent_icon = Gdk::Pixbuf::create_from_resource("/org/gtk/gtorrent/icon-torrent.png"); auto torrent_icon_scaled = torrent_icon->scale_simple(16, 16, Gdk::INTERP_BILINEAR); m_torrent_row[m_cols.icon] = torrent_icon_scaled; // XXX TMP WILL REMOVE AND REPLACE WITH PROPER FUNCTION // Yes this is horrible. Bear with it for now. auto g = Application::getSingleton()->getCore()->getAllTorrents(); Gtk::TreeModel::Row row = *(m_liststore->append(m_torrent_row.children())); row[m_cols.name] = "All"; row[m_cols.title] = "All"; row[m_cols.group] = g; row[m_cols.group_vector] = &g->m_torrents_all; Gtk::TreeModel::Row row2 = *(m_liststore->append(row.children())); row2[m_cols.name] = "Downloading"; row2[m_cols.title] = "Downloading"; row2[m_cols.group_vector] = &g->m_torrents_downloading; row2 = *(m_liststore->append(row.children())); row2[m_cols.name] = "Seeding"; row2[m_cols.title] = "Seeding"; row2[m_cols.group_vector] = &g->m_torrents_seeding; row2 = *(m_liststore->append(row.children())); row2[m_cols.name] = "Checking"; row2[m_cols.title] = "Checking"; row2[m_cols.group_vector] = &g->m_torrents_checking; row2 = *(m_liststore->append(row.children())); row2[m_cols.name] = "Finished"; row2[m_cols.title] = "Finished"; row2[m_cols.group_vector] = &g->m_torrents_finished; row2 = *(m_liststore->append(row.children())); row2[m_cols.name] = "Stopped"; row2[m_cols.title] = "Stopped"; row2[m_cols.group_vector] = &g->m_torrents_stopped; row2 = *(m_liststore->append(row.children())); row2[m_cols.name] = "Paused"; row2[m_cols.title] = "Paused"; row2[m_cols.group_vector] = &g->m_torrents_paused; // End of new horrible code // Continue horrible code from before //row = *(m_liststore->append(m_torrent_row.children())); //row[m_cols.name] = "Add a label"; //row[m_cols.editable] = true; //row[m_cols.icon] = Gtk::IconTheme::get_default()->lookup_icon("list-add-symbolic", 16, Gtk::ICON_LOOKUP_USE_BUILTIN).load_icon(); //row[m_cols.clickCallback] = [row](){}; m_rssfeed_row = *(m_liststore->append()); m_rssfeed_row[m_cols.name] = "RSS Feeds"; m_rssfeed_row[m_cols.editable] = false; m_rssfeed_row[m_cols.clickCallback] = [](){}; auto rss_icon = Gdk::Pixbuf::create_from_resource("/org/gtk/gtorrent/icon-rss.png"); auto rss_icon_scaled = rss_icon->scale_simple(16, 16, Gdk::INTERP_BILINEAR); m_rssfeed_row[m_cols.icon] = rss_icon_scaled; for(auto fg : Application::getSingleton()->getCore()->m_feeds) { row = *(m_liststore->append(m_rssfeed_row.children())); row[m_cols.name] = fg->name; row[m_cols.editable] = false; // TODO change icon to some sort of generic RSS icon row[m_cols.clickCallback] = [this, fg](){m_rss->run(fg->name);m_rss->hide();}; } row = *(m_liststore->append(m_rssfeed_row.children())); row[m_cols.name] = "Add an RSS group"; row[m_cols.editable] = true; row[m_cols.icon] = Gtk::IconTheme::get_default()->lookup_icon("list-add-symbolic", 16, Gtk::ICON_LOOKUP_USE_BUILTIN).load_icon(); row[m_cols.clickCallback] = [row](){}; //Maybe migrate settings there /* row = *(m_liststore->append()); row[m_cols.name] = "Settings"; row[m_cols.title] = true; row[m_cols.clickCallback] = [](){}; // clicks on titles don't do shit*/ }
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(); }
DocumentProperties::DocumentProperties ( RefWindow &refwin ) : win_ (refwin) { xml_ = Gtk::Builder::create_from_file (Utility::findDataFile ("documentproperties.ui")); xml_->get_widget ("DocumentProperties", dialog_); xml_->get_widget ("File", filechooser_); filechooser_->signal_selection_changed().connect ( sigc::mem_fun (*this, &DocumentProperties::onFileChanged)); xml_->get_widget ("Key", keyentry_); xml_->get_widget ("Icon", iconImage_); xml_->get_widget ("IconButton", iconButton_); iconButton_->signal_clicked().connect ( sigc::mem_fun (*this, &DocumentProperties::onIconButtonClicked)); xml_->get_widget ("Lookup", crossrefbutton_); crossrefbutton_->signal_clicked().connect( sigc::mem_fun (*this, &DocumentProperties::onMetadataLookup)); xml_->get_widget ("PasteBibtex", pastebibtexbutton_); pastebibtexbutton_->signal_clicked().connect( sigc::mem_fun (*this, &DocumentProperties::onPasteBibtex)); Gtk::Button *clearButton; xml_->get_widget ("Clear", clearButton); clearButton->signal_clicked().connect ( sigc::mem_fun (*this, &DocumentProperties::onClear)); xml_->get_widget ("ExtraFieldsExpander", extrafieldsexpander_); xml_->get_widget ("NewExtraField", newextrafieldbutton_); xml_->get_widget ("DeleteExtraField", deleteextrafieldbutton_); xml_->get_widget ("EditExtraField", editextrafieldbutton_); newextrafieldbutton_->signal_clicked ().connect ( sigc::mem_fun (*this, &DocumentProperties::onNewExtraField)); deleteextrafieldbutton_->signal_clicked ().connect ( sigc::mem_fun (*this, &DocumentProperties::onDeleteExtraField)); editextrafieldbutton_->signal_clicked ().connect ( sigc::mem_fun (*this, &DocumentProperties::onEditExtraField)); xml_->get_widget ("ExtraFields", extrafieldsview_); cols_.add (extrakeycol_); cols_.add (extravalcol_); extrafieldssel_ = extrafieldsview_->get_selection (); extrafieldssel_->signal_changed ().connect ( sigc::mem_fun (*this, &DocumentProperties::onExtraFieldsSelectionChanged)); extrafieldsstore_ = Gtk::ListStore::create (cols_); extrafieldsview_->set_model (extrafieldsstore_); extrafieldsview_->append_column (_("Name"), extrakeycol_); extrafieldsview_->append_column_editable (_("Value"), extravalcol_); typecombocols_.add (typebibtexnamecol_); typecombocols_.add (typelabelcol_); typecombostore_ = Gtk::ListStore::create (typecombocols_); // looks like watch for a cell-renderer is the only way // to get information that the cell(s) changed Gtk::CellRendererText* extrafieldsrenderer = dynamic_cast<Gtk::CellRendererText*> ( extrafieldsview_->get_column(1)->get_first_cell_renderer() ); extrafieldsrenderer->signal_edited ().connect ( sigc::mem_fun (*this, &DocumentProperties::onExtraFieldEdited)); ignoreTypeChanged_ = false; typeManager_ = DocumentTypeManager(); }