//------------------------------------------------------------------------------ const StringColumn& ColumnsModel::append_markup_column(const int bec_tm_idx, const std::string& name, const Iconic have_icon) { Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf>>* icon = 0; Gtk::TreeViewColumn* column = Gtk::manage(new Gtk::TreeViewColumn(base::replaceString(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>; Gtk::CellRendererText* cell = Gtk::manage(new Gtk::CellRendererText()); add(*col); add_bec_index_mapping(bec_tm_idx); column->pack_start(*cell); column->add_attribute(cell->property_markup(), *col); _columns.push_back(col); int nr_of_cols = _treeview->append_column(*column); _treeview->get_column(nr_of_cols - 1)->set_resizable(true); return *col; }
int MidiRuleCtrlTrigger::append_note_column( const char* title, const Gtk::TreeModelColumn<Glib::ustring>& column) { Gtk::CellRendererSpin* renderer = Gtk::manage(new Gtk::CellRendererSpin()); renderer->property_editable() = true; renderer->signal_editing_started().connect( sigc::bind( sigc::mem_fun(*this, &MidiRuleCtrlTrigger::note_editing_started), renderer)); renderer->signal_edited().connect( sigc::bind( sigc::mem_fun(*this, &MidiRuleCtrlTrigger::note_edited), column)); #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2 renderer->property_adjustment() = new Gtk::Adjustment(0, 0, 127); #else renderer->property_adjustment() = Gtk::Adjustment::create(0, 0, 127); #endif int cols_count = tree_view.append_column(title, *renderer); Gtk::TreeViewColumn* col = tree_view.get_column(cols_count - 1); col->add_attribute(*renderer, "text", column); col->set_min_width(98); return cols_count; }
void PluginTreeView::ctor() { m_plugin_list = Gtk::ListStore::create(m_plugin_record); set_model(m_plugin_list); set_rules_hint(true); append_column("#", m_plugin_record.index); append_column_editable("Status", m_plugin_record.loaded); append_plugin_column(); on_name_clicked(); Gtk::TreeViewColumn *column = get_column(0); column->signal_clicked().connect(sigc::mem_fun(*this, &PluginTreeView::on_id_clicked)); column = get_column(1); column->signal_clicked().connect(sigc::mem_fun(*this, &PluginTreeView::on_status_clicked)); Gtk::CellRendererToggle* renderer; renderer = dynamic_cast<Gtk::CellRendererToggle*>( get_column_cell_renderer(1) ); renderer->signal_toggled().connect( sigc::mem_fun(*this, &PluginTreeView::on_status_toggled)); m_dispatcher.signal_connected().connect(sigc::mem_fun(*this, &PluginTreeView::on_connected)); m_dispatcher.signal_disconnected().connect(sigc::mem_fun(*this, &PluginTreeView::on_disconnected)); m_dispatcher.signal_message_received().connect(sigc::mem_fun(*this, &PluginTreeView::on_message_received)); }
ModuleWindow::ModuleWindow(Module* module, MainWindow* parent, Manager* manager) { m_pModule = module; m_pParent = parent; m_pManager = manager; /* 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* cellText = Gtk::manage(new Gtk::CellRendererText()); Gtk::CellRendererPixbuf* cellPix = Gtk::manage(new Gtk::CellRendererPixbuf()); Gtk::TreeViewColumn* col = Gtk::manage(new Gtk::TreeViewColumn("Item")); col->pack_start(*cellPix, false); col->pack_start(*cellText, true); col->add_attribute(*cellText, "text", 1); col->add_attribute(*cellPix, "pixbuf", 0); m_TreeView.append_column(*col); m_TreeView.get_column(0)->set_resizable(true); m_TreeView.append_column("Value", m_Columns.m_col_value); m_TreeView.get_column(1)->set_resizable(true); updateWidget(); show_all_children(); }
void GtkPeerTreeView::setupColumns() { int cid; Gtk::TreeViewColumn *col; cid = append_column("IP" , m_cols.m_col_ip); col = get_column(cid - 1); col->set_sort_column(m_cols.m_col_ip); append_column("Port", m_cols.m_col_port); cid = append_column("Client" , m_cols.m_col_client); col = get_column(cid - 1); col->set_sort_column(m_cols.m_col_client); append_column("Flags", m_cols.m_col_flags); append_column("%", m_cols.m_col_percent); append_column("Relevance", m_cols.m_col_relevance); cid = append_column("Down Speed", m_cols.m_col_down); col = get_column(cid - 1); col->set_sort_column(m_cols.m_col_down); cid = append_column("Up Speed" , m_cols.m_col_up); col = get_column(cid - 1); col->set_sort_column(m_cols.m_col_up); append_column("Reqs", m_cols.m_col_reqs); append_column("Waited", m_cols.m_col_waited); append_column("Downloaded", m_cols.m_col_downloaded); append_column("Uploaded", m_cols.m_col_uploaded); append_column("Hasherr", m_cols.m_col_hasherr); append_column("Peer Download Rate", m_cols.m_col_peer_download_rate); append_column("MaxDown", m_cols.m_col_max_down); append_column("MaxUp", m_cols.m_col_max_up); append_column("Queued", m_cols.m_col_queued); append_column("Inactive", m_cols.m_col_inactive); append_column("Debug", m_cols.m_col_debug); }
void ResViewerViewImpl::setColumns(ResViewerColumns* Columns) { mp_TreeView->remove_all_columns(); if (Columns) { Gtk::TreeViewColumn* CurrentCol; mp_TreeView->append_column(_("Time step"), *Columns->getStepColumn()); CurrentCol = mp_TreeView->get_column(0); CurrentCol->set_sort_column(*Columns->getStepColumn()); CurrentCol->set_resizable(true); CurrentCol->set_reorderable(true); mp_TreeView->append_column(_("Date-Time"), *Columns->getDateColumn()); CurrentCol = mp_TreeView->get_column(1); CurrentCol->set_sort_column(*Columns->getDateColumn()); CurrentCol->set_resizable(true); CurrentCol->set_reorderable(true); 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 ColNb = mp_TreeView->append_column(it->first, *it->second); CurrentCol = mp_TreeView->get_column(ColNb - 1); CurrentCol->set_sort_column(*it->second); CurrentCol->set_resizable(true); CurrentCol->set_reorderable(true); } } }
void statusRecord::appendToView(Gtk::TreeView* _treeview) { _treeview->append_column("Filename", filename); _treeview->append_column("Status", status); #if GTKMM_2_6_OR_BETTER // Add a progress bar, showing status. Gtk::CellRendererProgress* cell = Gtk::manage(new Gtk::CellRendererProgress); int last_count = _treeview->append_column("Progress", *cell); Gtk::TreeViewColumn* column = _treeview->get_column(last_count - 1); if (column) { column->add_attribute(cell->property_value(), done); column->add_attribute(cell->property_text(), doneText); } #else // Old gtkmm version, so use boring text. _treeview->append_column("Progress", done); #endif // GTKMM_2_6_OR_BETTER _treeview->append_column("Download", dn_rate); _treeview->append_column("Upload", ul_rate); _treeview->append_column("Filesize", filesize); _treeview->append_column("Peers l/s", peers); }
bool KeyframeTree::on_event(GdkEvent *event) { switch(event->type) { case GDK_BUTTON_PRESS: { Gtk::TreeModel::Path path; Gtk::TreeViewColumn *column; int cell_x, cell_y; int wx(round_to_int(event->button.x)),wy(round_to_int(event->button.y)); //tree_to_widget_coords (,, wx, wy); if(!get_path_at_pos( wx,wy, // x, y path, // TreeModel::Path& column, //TreeViewColumn*& cell_x,cell_y //int&cell_x,int&cell_y ) ) break; const Gtk::TreeRow row = *(get_model()->get_iter(path)); signal_user_click()(event->button.button,row,(ColumnID)column->get_sort_column_id()); if((ColumnID)column->get_sort_column_id()==COLUMNID_JUMP) { keyframe_tree_store_->canvas_interface()->set_time(row[model.time]); } } break; case GDK_2BUTTON_PRESS: { Gtk::TreeModel::Path path; Gtk::TreeViewColumn *column; int cell_x, cell_y; if(!get_path_at_pos( int(event->button.x),int(event->button.y), // x, y path, // TreeModel::Path& column, //TreeViewColumn*& cell_x,cell_y //int&cell_x,int&cell_y ) ) break; const Gtk::TreeRow row = *(get_model()->get_iter(path)); { keyframe_tree_store_->canvas_interface()->set_time(row[model.time]); return true; } } break; case GDK_BUTTON_RELEASE: break; default: break; } return false; }
void AttributesView::setNotificationsView() { columns_notif.add(col_notif); list_notif = Gtk::ListStore::create(columns_notif); view_notif->set_model(list_notif); int i = this->view_notif->append_column("Notificaciones", col_notif); Gtk::TreeViewColumn* pColumn = this->view_files->get_column(i); pColumn->set_resizable(true); }
/// @fn void LibraryView::fillTagsList() /// @brief Method responsible for loading tags list from library. void LibraryView::fillTagsList() { tags_list = core->getTagsList(); tags_view.set_model(tags_list); tags_view.append_column("Tags List", tags_columns.name); Gtk::TreeViewColumn *column = tags_view.get_column(0); if(column) column->set_expand(true); tags_view.append_column_editable("", tags_columns.selected); tags_view.signal_cursor_changed().connect(sigc::mem_fun(*this, &LibraryView::loadImagesByTags)); }
void Portfolio::reflesh() { //Fill the TreeView's model m_refTreeModel->clear(); m_TreeView.remove_all_columns(); //Add the TreeView's view columns: m_TreeView.append_column("Currency", m_Columns.m_col_currency); m_TreeView.append_column("Amount", m_Columns.m_col_amount); vector<AccountDatum*> accountData = OutgoingRequest::requestAccountData(); vector<double> in_yens; vector<double> percentages; double sum; for(size_t i=0; i<accountData.size(); i++) { string symbol = accountData.at(i)->currency; double rate = lexical_cast<double>(OutgoingRequest::requestLatestRate(symbol, "JPY")); double in_yen = accountData.at(i)->amount * rate; in_yens.push_back(in_yen); } sum = boost::accumulate(in_yens, 0); for(size_t i=0; i<accountData.size(); i++) { double percentage = in_yens.at(i)/sum * 100; percentages.push_back(percentage); } Gtk::TreeModel::Row row; for(size_t i=0; i<accountData.size(); i++){ row = *(m_refTreeModel->append()); row[m_Columns.m_col_currency] = accountData.at(i)->currency; row[m_Columns.m_col_amount] = accountData.at(i)->amount; row[m_Columns.m_col_percentage] = percentages.at(i); } Gtk::CellRendererProgress* cell = Gtk::manage(new Gtk::CellRendererProgress); int cols_count = m_TreeView.append_column("Percentage", *cell); Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count - 1); if(pColumn) { pColumn->add_attribute(cell->property_value(), m_Columns.m_col_percentage); } for(guint i = 0; i < 2; i++) { Gtk::TreeView::Column* pColumn = m_TreeView.get_column(i); pColumn->set_reorderable(); } show_all_children(); }
bool Dock_History::on_action_event(GdkEvent *event) { studio::HistoryTreeStore::Model model; switch(event->type) { case GDK_BUTTON_PRESS: case GDK_2BUTTON_PRESS: { Gtk::TreeModel::Path path; Gtk::TreeViewColumn *column; int cell_x, cell_y; if(!action_tree->get_path_at_pos( int(event->button.x),int(event->button.y), // x, y path, // TreeModel::Path& column, //TreeViewColumn*& cell_x,cell_y //int&cell_x,int&cell_y ) ) break; const Gtk::TreeRow row = *(action_tree->get_model()->get_iter(path)); //signal_user_click()(event->button.button,row,(ColumnID)column->get_sort_column_id()); if((ColumnID)column->get_sort_column_id()==COLUMNID_JUMP) { etl::handle<synfigapp::Action::Undoable> action(row[model.action]); try{ if((bool)row[model.is_undo]) { while(get_selected_instance()->undo_action_stack().size() && get_selected_instance()->undo_action_stack().front()!=action) if(get_selected_instance()->undo()==false) throw int(); } else if((bool)row[model.is_redo]) { while(get_selected_instance()->redo_action_stack().size() && get_selected_instance()->undo_action_stack().front()!=action) if(get_selected_instance()->redo()==false) throw int(); } } catch(int) { return true; } } break; } case GDK_BUTTON_RELEASE: break; default: break; } return false; }
void LiningAdjustmentDialog::init_ui() { builder_->get_widget( "combobox-chip", combobox_chip_); builder_->get_widget( "spinbutton-strip", spinbutton_strip_); builder_->get_widget( "spinbutton-code", spinbutton_code_); builder_->get_widget( "spinbutton-broadcast", spinbutton_broadcast_); builder_->get_widget( "toolbutton-load-from-file", menutoolbutton_load_from_file_); builder_->get_widget( "menuitem-restore-current", menuitem_restore_current_); builder_->get_widget( "menuitem-restore-all", menuitem_restore_all_); builder_->get_widget( "toolbutton-write-current", menutoolbutton_write_current_); builder_->get_widget( "menuitem-write-all", menuitem_write_all_); Glib::RefPtr<Glib::Object> obj; obj = builder_->get_object("liststore-strip-code"); liststore_strip_code_ = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(obj); // create items StripCodeVector codes; for ( int i = 0; i < SCANNER_STRIPS_PER_CHIP_REAL; ++i) { codes.push_back(StripCode( i + 1, 0)); } // add rows for ( StripCodeVector::const_iterator it = codes.begin(); it != codes.end(); ++ it) { Gtk::TreeRow row = *(liststore_strip_code_->append()); row[model_columns.strip] = it->first; row[model_columns.code] = it->second; } builder_->get_widget( "treeview-strip-code", treeview_strip_code_); selection_strip_code_ = treeview_strip_code_->get_selection(); selection_strip_code_->set_mode(Gtk::SELECTION_SINGLE); // add columns Gtk::TreeViewColumn* column; Gtk::CellRenderer* renderer; column = new Gtk::TreeView::Column( _("Strip"), model_columns.strip); column->set_alignment(Gtk::ALIGN_CENTER); renderer = column->get_first_cell_renderer(); renderer->property_xalign() = 1.; treeview_strip_code_->append_column(*Gtk::manage(column)); column = new Gtk::TreeView::Column( _("Code"), model_columns.code); column->set_alignment(Gtk::ALIGN_CENTER); renderer = column->get_first_cell_renderer(); renderer->property_xalign() = .5; treeview_strip_code_->append_column(*Gtk::manage(column)); }
/** * Append appropriate plugin column - depending on the GConf value */ void PluginTreeView::append_plugin_column() { #if GTKMM_MAJOR_VERSION > 2 || ( GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 14 ) bool description_as_tooltip = false; # ifdef HAVE_GCONFMM if ( __gconf ) { # ifdef GLIBMM_EXCEPTIONS_ENABLED description_as_tooltip = __gconf->get_bool(__gconf_prefix + "/description_as_tooltip"); # else std::auto_ptr<Glib::Error> error; description_as_tooltip = __gconf->get_bool(__gconf_prefix + "/description_as_tooltip", error); # endif } # endif #endif #if GTKMM_MAJOR_VERSION > 2 || ( GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 14 ) if (description_as_tooltip) { #endif append_column("Plugin", m_plugin_record.name); #if GTKMM_MAJOR_VERSION > 2 || ( GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 14 ) set_tooltip_column(2); } else { TwoLinesCellRenderer *twolines_renderer = new TwoLinesCellRenderer(); Gtk::TreeViewColumn *tlcol = new Gtk::TreeViewColumn("Plugin", *Gtk::manage(twolines_renderer)); append_column(*Gtk::manage(tlcol)); # ifdef GLIBMM_PROPERTIES_ENABLED tlcol->add_attribute(twolines_renderer->property_line1(), m_plugin_record.name); tlcol->add_attribute(twolines_renderer->property_line2(), m_plugin_record.description); # else tlcol->add_attribute(*twolines_renderer, "line1", m_plugin_record.name); tlcol->add_attribute(*twolines_renderer, "line2", m_plugin_record.description); # endif set_tooltip_column(-1); } #endif set_headers_clickable(); Gtk::TreeViewColumn *plugin_col = get_column(2); if (plugin_col) plugin_col->signal_clicked().connect(sigc::mem_fun(*this, &PluginTreeView::on_name_clicked)); }
void AttributesView::setFilesView() { columns_files.add(col_size_files); columns_files.add(col_path_files); list_files = Gtk::ListStore::create(columns_files); view_files->set_model(list_files); this->view_files->append_column("Ruta del Archivo", col_path_files); int cols_count = this->view_files->append_column("Tamaño", col_size_files); Gtk::TreeViewColumn* pColumn; for (int i = 0; i < cols_count; i++) { pColumn = this->view_files->get_column(i); pColumn->set_resizable(true); } }
/** Constructor. * @param cobject pointer to base object type * @param builder Gtk builder */ ConfigTreeView::ConfigTreeView(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder> &builder) : Gtk::TreeView(cobject) { m_dlg_edit = NULL; builder->get_widget_derived("dlgConfigEdit", m_dlg_edit); m_dlg_add = NULL; builder->get_widget_derived("dlgConfigAdd", m_dlg_add); m_dlg_remove = NULL; builder->get_widget_derived("dlgConfigRemove", m_dlg_remove); m_config_tree = Gtk::TreeStore::create(m_config_record); m_config_tree->set_sort_column(0, Gtk::SORT_ASCENDING); set_model(m_config_tree); append_column("Path", m_config_record.node); Gtk::TreeViewColumn *column = get_column(0); Gtk::CellRendererText *cell = #if GTK_VERSION_GE(3,0) (Gtk::CellRendererText *)column->get_first_cell(); #else (Gtk::CellRendererText *)column->get_first_cell_renderer(); #endif #ifdef GLIBMM_PROPERTIES_ENABLED column->add_attribute(cell->property_underline(), m_config_record.is_default); #else column->add_attribute(*cell, "underline", m_config_record.is_default); #endif append_column("Value", m_config_record.value_string); /* Gtk::Menu::MenuList& menulist = m_menu.items(); menulist.push_back( Gtk::Menu_Helpers::MenuElem("Edit", sigc::mem_fun( *this, &ConfigTreeView::on_menu_edit_selected) ) ); menulist.push_back( Gtk::Menu_Helpers::MenuElem("Remove", sigc::mem_fun( *this, &ConfigTreeView::on_menu_remove_selected) ) ); menulist.push_back( Gtk::Menu_Helpers::MenuElem("Add", sigc::mem_fun( *this, &ConfigTreeView::on_menu_add_selected) ) ); */ m_config = NULL; m_own_config = false; signal_button_press_event().connect_notify( sigc::mem_fun(*this, &ConfigTreeView::on_button_press_event_custom) ); }
void AttributesView::setPeersView() { columns_peers.add(col_name_peers); columns_peers.add(col_port_peers); columns_peers.add(col_type_peers); list_peers = Gtk::ListStore::create(columns_peers); view_peers->set_model(list_peers); this->view_peers->append_column("Nombre del Peer", col_name_peers); this->view_peers->append_column("Puerto", col_port_peers); int cols_count = this->view_peers->append_column("Tipo de Peer", col_type_peers); Gtk::TreeViewColumn* pColumn; for (int i = 0; i < cols_count; i++) { pColumn = this->view_peers->get_column(i); pColumn->set_resizable(true); } }
// TODO REFACTOR THE LIVING HELL OUT OF THIS ABOMINATION -- nyanpasu void GtkTorrentTreeView::setupColumns() { Gtk::TreeViewColumn *col = nullptr; Gtk::CellRendererProgress *cell = nullptr; vector<pair<int, int>> columns; //First element id second element size columns.push_back(make_pair(this->append_column("#", m_cols.m_col_queue), 30)); columns.push_back(make_pair(this->append_column("Status", m_cols.m_col_name), 200)); columns.push_back(make_pair(this->append_column("Name", m_cols.m_col_name), 200)); columns.push_back(make_pair(this->append_column("Size", m_cols.m_col_size), 80)); columns.push_back(make_pair(this->append_column("Down", m_cols.m_col_dl_speed), 60)); columns.push_back(make_pair(this->append_column("Up", m_cols.m_col_ul_speed), 60)); columns.push_back(make_pair(this->append_column("Ratio", m_cols.m_col_dl_ratio), 60)); columns.push_back(make_pair(this->append_column("Downloaded", m_cols.m_col_dl_total), 80)); get_column(columns.back().first - 1)->set_visible(false); columns.push_back(make_pair(this->append_column("Uploaded", m_cols.m_col_ul_total), 80)); get_column(columns.back().first - 1)->set_visible(false); columns.push_back(make_pair(this->append_column("Seed", m_cols.m_col_seeders), 60)); columns.push_back(make_pair(this->append_column("Leech", m_cols.m_col_leechers), 60)); columns.push_back(make_pair(this->append_column("Age", m_cols.m_col_age), 50)); columns.push_back(make_pair(this->append_column("ETA", m_cols.m_col_eta), 80)); cell = Gtk::manage(new Gtk::CellRendererProgress()); columns.push_back(make_pair(this->append_column("Progress", *cell), 160)); col = this->get_column(columns.back().first - 1); col->add_attribute(cell->property_value(), m_cols.m_col_percent); col->add_attribute(cell->property_text(), m_cols.m_col_percent_text); columns.push_back(make_pair(this->append_column("Remains", m_cols.m_col_remaining), 80)); get_column(columns.back().first - 1)->set_visible(false); for (pair<int, int> colpair : columns) { Gtk::Button *butt = get_column(colpair.first - 1)->get_button(); butt->signal_button_press_event().connect(sigc::mem_fun(*this, &GtkTorrentTreeView::torrentColumns_onClick)); get_column(colpair.first - 1)->set_sizing(Gtk::TreeViewColumnSizing::TREE_VIEW_COLUMN_FIXED); get_column(colpair.first - 1)->set_alignment(0.5f); get_column(colpair.first - 1)->set_clickable(); get_column(colpair.first - 1)->set_resizable(); get_column(colpair.first - 1)->set_reorderable(); get_column(colpair.first - 1)->set_fixed_width(colpair.second); } }
void setup_model(){ { //treeview treemodel = Gtk::ListStore::create(columns); treeview1->set_model(treemodel); treeview1->append_column("Filename", columns.Filename); treeview1->append_column("Url", columns.url); treeview1->append_column("Size", columns.size); treeview1->append_column("%", columns.percentage_complete); treeview1->append_column("Time Left", columns.time_left); treeview1->append_column("Action", columns.action); //make all columns resizeable and set width std::vector<Gtk::TreeViewColumn*> tv_columns = treeview1->get_columns(); std::vector<Gtk::TreeViewColumn*>::iterator iter = tv_columns.begin(); int count = 0; for (; iter!=tv_columns.end(); iter++, count++){ Gtk::TreeViewColumn* col = *iter; col->set_resizable(true); col->set_fixed_width(column_widths[count]); } Gtk::TreeModel::Row row = *(treemodel->append()); row[columns.Filename] = "33"; row[columns.url] = "SFDSD"; Gtk::TreeModel::Children children = treemodel->children(); for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter){ Gtk::TreeModel::Row row = *iter; row->set_value(0, (Glib::ustring)"asdfaksdhfakshdfklasjdfhklsafdhlaskjdhflksajdhfasdfads"); row->set_value(4, (Glib::ustring)"asdfads"); } } { comboboxmodel = Gtk::ListStore::create(combo_columns); combobox_size->set_model(comboboxmodel); Gtk::TreeModel::Row row = *(comboboxmodel->append()); combobox_size->set_id_column(0); Gtk::CellRendererText *cell = new Gtk::CellRendererText(); combobox_size->pack_start(*cell); combobox_size->add_attribute(*cell, "text", combo_columns.size); row[combo_columns.size] = "kB"; (*(comboboxmodel->append()))[combo_columns.size] = "MB"; combobox_size->set_active(0); } }
Gtk::Widget& DifficultyEditor::createTreeView() { // First, create the treeview _settingsView = Gtk::manage(new Gtk::TreeView(_settings->getTreeStore())); _settingsView->set_size_request(TREE_VIEW_MIN_WIDTH, -1); // Connect the tree view selection Glib::RefPtr<Gtk::TreeSelection> selection = _settingsView->get_selection(); selection->signal_changed().connect(sigc::mem_fun(*this, &DifficultyEditor::onSettingSelectionChange)); // Add columns to this view Gtk::CellRendererText* textRenderer = Gtk::manage(new Gtk::CellRendererText); Gtk::TreeViewColumn* settingCol = Gtk::manage(new Gtk::TreeViewColumn); settingCol->pack_start(*textRenderer, false); settingCol->set_title(_("Setting")); settingCol->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE); settingCol->set_spacing(3); _settingsView->append_column(*settingCol); settingCol->add_attribute(textRenderer->property_text(), _settings->getColumns().description); settingCol->add_attribute(textRenderer->property_foreground(), _settings->getColumns().colour); settingCol->add_attribute(textRenderer->property_strikethrough(), _settings->getColumns().isOverridden); Gtk::ScrolledWindow* frame = Gtk::manage(new gtkutil::ScrolledFrame(*_settingsView)); // Create the action buttons Gtk::HBox* buttonHBox = Gtk::manage(new Gtk::HBox(false, 6)); // Create button _createSettingButton = Gtk::manage(new Gtk::Button(Gtk::Stock::ADD)); _createSettingButton->signal_clicked().connect(sigc::mem_fun(*this, &DifficultyEditor::onSettingCreate)); // Delete button _deleteSettingButton = Gtk::manage(new Gtk::Button(Gtk::Stock::DELETE)); _deleteSettingButton->signal_clicked().connect(sigc::mem_fun(*this, &DifficultyEditor::onSettingDelete)); _refreshButton = Gtk::manage(new Gtk::Button(Gtk::Stock::REFRESH)); _refreshButton->signal_clicked().connect(sigc::mem_fun(*this, &DifficultyEditor::onRefresh)); buttonHBox->pack_start(*_createSettingButton, true, true, 0); buttonHBox->pack_start(*_deleteSettingButton, true, true, 0); buttonHBox->pack_start(*_refreshButton, true, true, 0); Gtk::VBox* vbox = Gtk::manage(new Gtk::VBox(false, 6)); vbox->pack_start(*frame, true, true, 0); vbox->pack_start(*buttonHBox, false, false, 0); vbox->set_border_width(12); return *vbox; }
void TorrentView::setTreeView(Gtk::TreeView *view_torrents) { this->view_torrents = view_torrents; //agrego la lista de torrents al tree view this->view_torrents->set_model(list_torrents); Gtk::TreeViewColumn* pColumn; int cols_count; //agrego columnas al Tree View this->view_torrents->append_column(COL_NAME, col_name); this->view_torrents->append_column(COL_SIZE, col_size); this->view_torrents->append_column(COL_STATUS, col_status); //mostrar una progress bar para el porcentaje de progreso Gtk::CellRendererProgress* cell = Gtk::manage(new Gtk::CellRendererProgress); cols_count = this->view_torrents->append_column(COL_PROGRESS, *cell); pColumn = this->view_torrents->get_column(cols_count - 1); if (pColumn) { #ifdef GLIBMM_PROPERTIES_ENABLED pColumn->add_attribute(cell->property_value(), col_progress); #else pColumn->add_attribute(*cell, "value", col_progress); #endif } this->view_torrents->append_column(COL_COMPLETED, col_completed); this->view_torrents->append_column(COL_REMAINING, col_remaining); this->view_torrents->append_column(COL_DOWNSPEED, col_downspeed); this->view_torrents->append_column(COL_UPSPEED, col_upspeed); cols_count = this->view_torrents->append_column(COL_TIME, col_time); for (int i = 0; i < cols_count; i++) { pColumn = this->view_torrents->get_column(i); pColumn->set_resizable(true); //hago que sean columnas redimensionables } this->view_torrents->columns_autosize(); selection = this->view_torrents->get_selection(); selection->signal_changed().connect(sigc::mem_fun(*this, &TorrentView::on_row_selected)); }
void MidiRuleCtrlTrigger::num_edited( const Glib::ustring& path, const Glib::ustring& new_text, const Gtk::TreeModelColumn<int>& column) { Gtk::TreeModel::Row row = *list_store->get_iter(path); Gtk::TreeModel::Path cpath; Gtk::TreeViewColumn* col; tree_view.get_cursor(cpath, col); int lower = 0; int upper = 127; const Gtk::CellRenderer* r = col->get_first_cell(); if (const Gtk::CellRendererSpin* renderer = dynamic_cast<const Gtk::CellRendererSpin*>(r)) { lower = renderer->property_adjustment().get_value()->get_lower(); upper = renderer->property_adjustment().get_value()->get_upper(); } row[column] = std::max(lower, std::min(atoi(new_text.c_str()), upper)); }
Gtk::Widget *SearchNotesWidget::make_notebooks_pane() { m_notebooksTree = Gtk::manage( new notebooks::NotebooksTreeView(m_manager, notebooks::NotebookManager::obj() .get_notebooks_with_special_items())); m_notebooksTree->get_selection()->set_mode(Gtk::SELECTION_SINGLE); m_notebooksTree->set_headers_visible(true); m_notebooksTree->set_rules_hint(false); Gtk::CellRenderer *renderer; Gtk::TreeViewColumn *column = manage(new Gtk::TreeViewColumn()); column->set_title(_("Notebooks")); column->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE); column->set_resizable(false); renderer = manage(new Gtk::CellRendererPixbuf()); column->pack_start(*renderer, false); column->set_cell_data_func(*renderer, sigc::mem_fun(*this, &SearchNotesWidget::notebook_pixbuf_cell_data_func)); Gtk::CellRendererText *text_renderer = manage(new Gtk::CellRendererText()); text_renderer->property_editable() = true; column->pack_start(*text_renderer, true); column->set_cell_data_func(*text_renderer, sigc::mem_fun(*this, &SearchNotesWidget::notebook_text_cell_data_func)); text_renderer->signal_edited().connect(sigc::mem_fun(*this, &SearchNotesWidget::on_notebook_row_edited)); m_notebooksTree->append_column(*column); m_notebooksTree->signal_row_activated() .connect(sigc::mem_fun(*this, &SearchNotesWidget::on_notebook_row_activated)); m_on_notebook_selection_changed_cid = m_notebooksTree->get_selection()->signal_changed() .connect(sigc::mem_fun(*this, &SearchNotesWidget::on_notebook_selection_changed)); m_notebooksTree->signal_button_press_event() .connect(sigc::mem_fun(*this, &SearchNotesWidget::on_notebooks_tree_button_pressed), false); m_notebooksTree->signal_key_press_event() .connect(sigc::mem_fun(*this, &SearchNotesWidget::on_notebooks_key_pressed)); m_notebooksTree->show(); Gtk::ScrolledWindow *sw = new Gtk::ScrolledWindow(); sw->property_hscrollbar_policy() = Gtk::POLICY_AUTOMATIC; sw->property_vscrollbar_policy() = Gtk::POLICY_AUTOMATIC; sw->add(*m_notebooksTree); sw->show(); return sw; }
ContactsTreeWidget::ContactsTreeWidget(BaseObjectType* baseObject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade) : Gtk::TreeView(baseObject) { appInstance->logEvent("ContactsTreeWidget::ContactsTreeWidget()", SEVERITY_DEBUG); treeModel = Gtk::TreeStore::create(columns); // sort by status codes. // STATUS_OFFLINE is 0, so it will always be at bottom of the list treeModel->set_sort_column(columns.contactStatus, Gtk::SORT_DESCENDING); set_model(treeModel); set_search_equal_func(sigc::mem_fun(*this, &ContactsTreeWidget::onSearchEqual)); // appending columns gint colCount; Gtk::TreeViewColumn* pColumn; Gtk::CellRenderer* renderer; Gtk::CellRendererPixbuf *avatarRenderer, *statusRenderer; Gtk::CellRendererText *textRenderer; statusRenderer = Gtk::manage(new Gtk::CellRendererPixbuf); statusRenderer->property_xalign() = 0.0; colCount = append_column(_("Status"), *statusRenderer); pColumn = get_column(colCount - 1); pColumn->add_attribute(statusRenderer->property_pixbuf(), columns.statusImage); textRenderer = Gtk::manage(new Gtk::CellRendererText); textRenderer->property_xalign() = 0.0; colCount = append_column(_("Nickname"), *textRenderer); pColumn = get_column(colCount - 1); pColumn->set_resizable(true); pColumn->add_attribute(textRenderer->property_markup(), columns.contactNickname); avatarRenderer = Gtk::manage(new Gtk::CellRendererPixbuf); avatarRenderer->property_xalign() = 1.0; avatarRenderer->property_xpad() = 10; colCount = append_column("", *avatarRenderer); pColumn = get_column(colCount - 1); pColumn->add_attribute(avatarRenderer->property_pixbuf(), columns.contactAvatar); // connecting signal handlers signal_row_activated().connect(sigc::mem_fun(*this, &ContactsTreeWidget::contactsTreeOnActivate)); appInstance->sigServer->signal_user_status().connect(sigc::mem_fun(*this, &ContactsTreeWidget::onStatusChange)); }
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); }
void GtkTorrentTreeView::setupColumns() { unsigned int cid = 0; Gtk::TreeViewColumn *col = nullptr; cid = this->append_column("Name", m_cols.m_col_name); col = this->get_column(cid - 1); col->set_fixed_width(250); cid = this->append_column("Seeders", m_cols.m_col_seeders); col = this->get_column(cid - 1); col->set_alignment(0.5); col->set_fixed_width(90); cid = this->append_column("Leechers", m_cols.m_col_leechers); col = this->get_column(cid - 1); col->set_alignment(0.5); col->set_fixed_width(90); cid = this->append_column("Rate (KB/s)", m_cols.m_col_dl_speed); col = this->get_column(cid - 1); col->set_alignment(0.5); col->set_fixed_width(95); Gtk::CellRendererProgress *cell = Gtk::manage(new Gtk::CellRendererProgress()); cid = this->append_column("Progress", *cell); col = this->get_column(cid - 1); if (col) { col->add_attribute(cell->property_value(), m_cols.m_col_percent); col->add_attribute(cell->property_text(), m_cols.m_col_percent_text); } for (auto &c : this->get_columns()) { c->set_sizing(Gtk::TreeViewColumnSizing::TREE_VIEW_COLUMN_FIXED); c->set_clickable(); c->set_resizable(); c->set_reorderable(); } }
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(base::replaceString(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_cells(); 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; }
// Create the objects panel (for manipulating the target_addobjectives objects) void ObjectivesEditor::setupEntitiesPanel() { // Tree view listing the target_addobjectives entities Gtk::TreeView* entityList = gladeWidget<Gtk::TreeView>( "entitiesTreeView" ); entityList->set_model(_objectiveEntityList); entityList->set_headers_visible(false); entityList->get_selection()->signal_changed().connect( sigc::mem_fun(*this, &ObjectivesEditor::_onEntitySelectionChanged) ); // Active-at-start column (checkbox) Gtk::CellRendererToggle* startToggle = Gtk::manage(new Gtk::CellRendererToggle); startToggle->signal_toggled().connect( sigc::mem_fun(*this, &ObjectivesEditor::_onStartActiveCellToggled) ); Gtk::TreeViewColumn* startCol = Gtk::manage(new Gtk::TreeViewColumn(_("Start"))); startCol->add_attribute(startToggle->property_active(), _objEntityColumns.startActive); entityList->append_column(*startCol); // Name column entityList->append_column(*Gtk::manage(new gtkutil::TextColumn("", _objEntityColumns.displayName))); // Connect button signals Gtk::Button* addButton = gladeWidget<Gtk::Button>("createEntityButton"); addButton->signal_clicked().connect( sigc::mem_fun(*this, &ObjectivesEditor::_onAddEntity) ); Gtk::Button* delButton = gladeWidget<Gtk::Button>("deleteEntityButton"); delButton->set_sensitive(false); // disabled at start delButton->signal_clicked().connect( sigc::mem_fun(*this, &ObjectivesEditor::_onDeleteEntity) ); }
CheatListDialog::CheatListDialog(GtkDialog* _pstDialog, const Glib::RefPtr<Gtk::Builder>& refBuilder) : Gtk::Dialog(_pstDialog) { refBuilder->get_widget("CheatOpenButton", m_poCheatOpenButton); refBuilder->get_widget("CheatSaveButton", m_poCheatSaveButton); refBuilder->get_widget("CheatAddButton", m_poCheatAddButton); refBuilder->get_widget("CheatRemoveButton", m_poCheatRemoveButton); refBuilder->get_widget("CheatRemoveAllButton", m_poCheatRemoveAllButton); refBuilder->get_widget("CheatMarkAllButton", m_poCheatMarkAllButton); refBuilder->get_widget("CheatTreeView", m_poCheatTreeView); // Tree View model m_poCheatListStore = Gtk::ListStore::create(m_oRecordModel); m_poCheatTreeView->set_model(m_poCheatListStore); Gtk::CellRendererToggle* pRenderer = Gtk::manage(new Gtk::CellRendererToggle()); int cols_count = m_poCheatTreeView->append_column("", *pRenderer); pRenderer->signal_toggled().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatToggled)); Gtk::TreeViewColumn* pColumn = m_poCheatTreeView->get_column(cols_count - 1); if (pColumn) pColumn->add_attribute(pRenderer->property_active(), m_oRecordModel.bEnabled); m_poCheatTreeView->append_column("Description", m_oRecordModel.uDesc); m_poCheatOpenButton->signal_clicked().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatListOpen)); m_poCheatSaveButton->signal_clicked().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatListSave)); m_poCheatAddButton->signal_clicked().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatAdd)); m_poCheatRemoveButton->signal_clicked().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatRemove)); m_poCheatRemoveAllButton->signal_clicked().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatRemoveAll)); m_poCheatMarkAllButton->signal_clicked().connect(sigc::mem_fun(*this, &CheatListDialog::vOnCheatMarkAll)); bMark = false; }
// TODO REFACTOR THE LIVING HELL OUT OF THIS ABOMINATION -- nyanpasu void GtkTorrentTreeView::setupColumns() { unsigned int cid = 0; Gtk::TreeViewColumn *col = nullptr; Gtk::CellRendererProgress *cell = nullptr; this->append_column("Queue", m_cols.m_col_queue); this->append_column("Age", m_cols.m_col_age); this->append_column("ETA", m_cols.m_col_eta); this->append_column("Name", m_cols.m_col_name); this->append_column("Seed", m_cols.m_col_seeders); this->append_column("Leech", m_cols.m_col_leechers); this->append_column("Upload Speed", m_cols.m_col_ul_speed); this->append_column("Download Speed", m_cols.m_col_dl_speed); this->append_column("Uploaded", m_cols.m_col_ul_total); this->append_column("Downloaded", m_cols.m_col_dl_total); this->append_column("Size", m_cols.m_col_size); this->append_column("Remains", m_cols.m_col_remaining); this->append_column("Ratio", m_cols.m_col_dl_ratio); cell = Gtk::manage(new Gtk::CellRendererProgress()); cid = this->append_column("Progress", *cell); col = this->get_column(cid - 1); col->add_attribute(cell->property_value(), m_cols.m_col_percent); col->add_attribute(cell->property_text(), m_cols.m_col_percent_text); for (auto & c : this->get_columns()) { Gtk::Button *butt = c->get_button(); butt->signal_button_press_event().connect(sigc::mem_fun(*this, &GtkTorrentTreeView::torrentColumns_onClick)); c->set_sizing(Gtk::TreeViewColumnSizing::TREE_VIEW_COLUMN_FIXED); c->set_alignment(0.5f); c->set_clickable(); c->set_resizable(); c->set_reorderable(); c->set_fixed_width(96); } }