//------------------------------------------------------------------------------
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;
}
ClassEditor::TypeSelectorWidgets ClassEditor::createStimTypeSelector()
{
TypeSelectorWidgets widgets;
// Type Selector
widgets.hbox = Gtk::manage(new Gtk::HBox(false, 0));
widgets.label = Gtk::manage(new gtkutil::LeftAlignedLabel(_("Type:")));
// Cast the helper class onto a ListStore and create a new treeview
widgets.list = Gtk::manage(new Gtk::ComboBox(_stimTypes.getListStore()));
widgets.list->set_size_request(-1, -1);
// Add the cellrenderer for the name
Gtk::CellRendererText* nameRenderer = Gtk::manage(new Gtk::CellRendererText);
Gtk::CellRendererPixbuf* iconRenderer = Gtk::manage(new Gtk::CellRendererPixbuf);
widgets.list->pack_start(*iconRenderer, false);
widgets.list->pack_start(*nameRenderer, true);
widgets.list->add_attribute(iconRenderer->property_pixbuf(), _stimTypes.getColumns().icon);
widgets.list->add_attribute(nameRenderer->property_text(), _stimTypes.getColumns().captionPlusID);
iconRenderer->set_fixed_size(26, -1);
widgets.hbox->pack_start(*widgets.label, false, false, 0);
widgets.hbox->pack_start(*Gtk::manage(new gtkutil::LeftAlignment(*widgets.list, 12, 1.0f)),
true, true, 0
);
// Set the combo box to use two-column
widgets.list->set_wrap_width(2);
widgets.list->set_active(0);
return widgets;
}
//------------------------------------------------------------------------------
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;
}
FontSizeComboBox::FontSizeComboBox(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder) :
Gtk::ComboBox( cobject )
{
font_size_tree_model_ = Gtk::ListStore::create(columns_);
font_size_tree_model_->set_sort_column(columns_.font_size, Gtk::SORT_ASCENDING);
set_model(font_size_tree_model_);
Gtk::TreeModel::Row row = *(font_size_tree_model_->append()); row[columns_.font_size] = 6;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 8;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 10;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 11;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 12;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 14;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 16;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 18;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 24;
row = *(font_size_tree_model_->append()); row[columns_.font_size] = 32;
Gtk::CellRendererText* renderer = Gtk::manage (new Gtk::CellRendererText());
pack_start (*renderer, true);
add_attribute(renderer->property_text(), columns_.font_size);
}
void Frame_FilesTab::treeviewcolumn_filepriority(Gtk::CellRenderer* renderer, const Gtk::TreeModel::iterator& iter)
{
if(iter)
{
Gtk::TreeModel::Row row = *iter;
int model_value = row[FilesColumns.Priority];
string Priority = "[unknown]";
switch(model_value)
{
case 0:
Priority = "Don't Download";
break;
case 1:
Priority = "Low Priority";
break;
case 2:
Priority = "Normal Priority";
break;
case 3:
Priority = "High Priority";
break;
}
Gtk::CellRendererText *crt = dynamic_cast<Gtk::CellRendererText*>(renderer);
crt->property_text() = Priority;
}
}
ProjectDashboard::ProjectDashboard()
{
mref_TreeModel = Gtk::ListStore::create(m_Columns);
mp_TreeView = Gtk::manage(new Gtk::TreeView(mref_TreeModel));
Gtk::TreeView::Column* pColumn = Gtk::manage(new Gtk::TreeView::Column(
"Project Dashboard"));
pColumn->pack_start(m_Columns.m_StateIcon, false);
pColumn->pack_start(m_Columns.m_Title, false);
mp_TreeView->append_column(*pColumn);
mp_TreeView->append_column("", m_Columns.m_StateInfo);
Gtk::CellRendererText* InfoCell =
((Gtk::CellRendererText*) mp_TreeView->get_column_cell_renderer(1));
InfoCell->property_wrap_mode() = Pango::WRAP_WORD;
InfoCell->property_wrap_width() = 200;
mp_TreeView->set_visible(true);
mp_MainWin = Gtk::manage(new Gtk::ScrolledWindow());
mp_MainWin->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
mp_MainWin->add(*mp_TreeView);
mp_MainWin->set_visible(true);
m_RedIcon = BuilderGraphicsHelper::createPixbufFromFile("red.png");
m_OrangeIcon = BuilderGraphicsHelper::createPixbufFromFile("orange.png");
m_GreenIcon = BuilderGraphicsHelper::createPixbufFromFile("green.png");
}
void PluginDisplay::display_type(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
PortDesc *q = it->get_value(port_liststore->col.port);
Gtk::CellRendererText *tcell = dynamic_cast<Gtk::CellRendererText*>(cell);
if (q->is_set(ChangeableValues::tp_set)) {
tcell->property_foreground().set_value("red");
} else {
tcell->property_foreground_set().set_value(false);
}
}
//------------------------------------------------------------------------------
void ColumnsModel::disable_edit_first_row(Gtk::CellRenderer* cell, const Gtk::TreeIter& iter) {
Gtk::CellRendererText* txt = (Gtk::CellRendererText*)cell;
if (txt) {
Gtk::TreeModel::Path path = this->_treeview->get_model()->get_path(iter);
if (path[0] == 0)
txt->property_editable() = false;
else
txt->property_editable() = true;
}
}
void PresentationTreeView::initialize() {
// We only need single copies of these renderers since all instances of PresentationTreeView have
// identical properties. Cannot make them global though as that would require them to be
// initialized before the call to the GTK initialization and so leads to an initialization error.
// Having them in this scope means they are not initialized until the first instance of a
// PresentationTreeView is made which is after the GTK+ system is initialized.
static Gtk::CellRendererText font_style_renderer;
static Gtk::CellRendererText visibility_renderer;
static Gtk::CellRendererText sample_text_renderer;
static Gtk::CellRendererText file_name_renderer;
PresentationListStore::ColumnRecord const & column_record{PresentationListStore::get_column_record()};
font_style_column.pack_start(font_style_renderer, true);
font_style_column.set_title(_("Font Style"));
font_style_column.add_attribute(font_style_renderer.property_text(), column_record.style_name);
visibility_column.pack_start(visibility_renderer, true);
visibility_column.set_title(" ");
visibility_column.add_attribute(visibility_renderer.property_text(), column_record.visibility);
sample_text_column.pack_start(sample_text_renderer, true);
sample_text_column.set_title(_("Sample Text"));
sample_text_column.add_attribute(sample_text_renderer.property_font_desc(), column_record.font_description);
sample_text_column.add_attribute(sample_text_renderer.property_text(), column_record.sample_text);
file_name_column.pack_start(file_name_renderer, true);
file_name_column.set_title(_("File Name"));
file_name_column.add_attribute(file_name_renderer.property_text(), column_record.file_name);
append_column(font_style_column);
append_column(visibility_column);
append_column(sample_text_column);
append_column(file_name_column);
for (auto i = 0; i < 4; ++i) { get_column(i)->set_resizable(true); }
Registry::registry.insert(this);
}
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 Frame_FilesTab::treeviewcolumn_filesize(Gtk::CellRenderer* renderer, const Gtk::TreeModel::iterator& iter)
{
if(iter)
{
tools_formatsize fs;
Gtk::TreeModel::Row row = *iter;
int model_value = row[FilesColumns.Size];
Gtk::CellRendererText *crt = dynamic_cast<Gtk::CellRendererText*>(renderer);
crt->property_text() = fs.format(model_value);
}
}
Gtk::TreeView::Column* Chooser::addTextColumn( const Glib::ustring& name, Gtk::TreeModelColumnBase& column )
{
Gtk::CellRendererText* renderer = Gtk::manage( new Gtk::CellRendererText );
Gtk::TreeView::Column* col = Gtk::manage( new Gtk::TreeView::Column( name, *renderer ) );
col->add_attribute( renderer->property_text(), column );
/*col->add_attribute( renderer->property_cell_background(), f_columns.background_color );
col->add_attribute( renderer->property_foreground(), f_columns.foreground_color );
col->add_attribute( renderer->property_style(), f_columns.style );
col->add_attribute( renderer->property_sensitive(), f_columns.sensitive );*/
col->set_resizable( true );
col->set_alignment( 0.5 );
col->set_sort_column( column );
append_column( *col );
return col;
}
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;
}
void Frame_FilesTab::treeviewcolumn_filetype(Gtk::CellRenderer* renderer, const Gtk::TreeModel::iterator& iter)
{
if(iter)
{
Gtk::TreeModel::Row row = *iter;
string model_value = row[FilesColumns.Name];
string FileType = model_value.substr(model_value.find_last_of(".") + 1);
if(model_value.compare(FileType) == 0) FileType = "[None]";
std::transform(FileType.begin(), FileType.end(), FileType.begin(), ::tolower);
Gtk::CellRendererText *crt = dynamic_cast<Gtk::CellRendererText*>(renderer);
crt->property_text() = FileType;
}
}
/** 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 PluginDisplay::display_upper(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) {
PortDesc *q = it->get_value(port_liststore->col.port);
Gtk::CellRendererText *tcell = dynamic_cast<Gtk::CellRendererText*>(cell);
tcell->property_foreground_set().set_value(false);
tcell->property_background_set().set_value(false);
DisplayType tp = q->get_tp();
if (tp == tp_toggle || tp == tp_display_toggle || tp == tp_none) {
cell->property_visible().set_value(false);
return;
}
cell->property_visible().set_value(true);
if (q->is_set(ChangeableValues::up_set)) {
tcell->property_foreground().set_value("red");
} else if (q->fake_up) {
tcell->property_background().set_value("grey");
}
}
// Actor Argument
ActorArgument::ActorArgument(
const conversation::ArgumentInfo& argInfo,
const Glib::RefPtr<Gtk::ListStore>& actorStore,
const ActorColumns& actorColumns) :
CommandArgumentItem(argInfo),
_actorColumns(actorColumns),
_actorStore(actorStore)
{
// Cast the helper class onto a ListStore and create a new treeview
_comboBox = Gtk::manage(new Gtk::ComboBox(Glib::RefPtr<Gtk::TreeModel>::cast_static(_actorStore)));
// Add the cellrenderer for the name
Gtk::CellRendererText* nameRenderer = Gtk::manage(new Gtk::CellRendererText);
_comboBox->pack_start(*nameRenderer, true);
_comboBox->add_attribute(nameRenderer->property_text(), _actorColumns.caption);
}
void EffectEditor::populateWindow()
{
// Create the overall vbox
_dialogVBox = Gtk::manage(new Gtk::VBox(false, 3));
add(*_dialogVBox);
Gtk::HBox* effectHBox = Gtk::manage(new Gtk::HBox(false, 0));
_effectTypeCombo = Gtk::manage(new Gtk::ComboBox(static_cast<const Glib::RefPtr<Gtk::TreeModel>&>(_effectStore)));
// Add the cellrenderer for the caption
Gtk::CellRendererText* captionRenderer = Gtk::manage(new Gtk::CellRendererText);
_effectTypeCombo->pack_start(*captionRenderer, false);
_effectTypeCombo->add_attribute(captionRenderer->property_text(), _effectColumns.caption);
Gtk::Label* effectLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_("Effect:")));
effectHBox->pack_start(*effectLabel, false, false, 0);
effectHBox->pack_start(*Gtk::manage(new gtkutil::LeftAlignment(*_effectTypeCombo, 12, 1.0f)),
true, true, 0
);
_dialogVBox->pack_start(*effectHBox, false, false, 3);
_stateToggle = Gtk::manage(new Gtk::CheckButton(_("Active")));
_stateToggle->signal_toggled().connect(sigc::mem_fun(*this, &EffectEditor::onStateToggle));
_dialogVBox->pack_start(*_stateToggle, false, false, 3);
Gtk::Label* argLabel =
Gtk::manage(new gtkutil::LeftAlignedLabel(std::string("<b>") + _("Arguments") + "</b>"));
_dialogVBox->pack_start(*argLabel, false, false, 0);
Gtk::Button* saveButton = Gtk::manage(new Gtk::Button(Gtk::Stock::APPLY));
saveButton->signal_clicked().connect(sigc::mem_fun(*this, &EffectEditor::onSave));
Gtk::Button* cancelButton = Gtk::manage(new Gtk::Button(Gtk::Stock::CANCEL));
cancelButton->signal_clicked().connect(sigc::mem_fun(*this, &EffectEditor::onCancel));
Gtk::HBox* buttonHBox = Gtk::manage(new Gtk::HBox(false, 0));
buttonHBox->pack_end(*saveButton, false, false, 0);
buttonHBox->pack_end(*cancelButton, false, false, 6);
_dialogVBox->pack_end(*buttonHBox, false, false, 3);
}
//------------------------------------------------------------------------------
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);
}
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));
}
ValidationPanel::ValidationPanel()
: Gtk::Box(Gtk::ORIENTATION_VERTICAL), _label_box(0), _label(_("<small>Validations</small>")) {
_label.set_use_markup(true);
_model = ListModelWrapper::create(&_be, &_tv, "ValidationModel");
_model->model().append_string_column(bec::ValidationMessagesBE::Description, _("Description"), RO, WITH_ICON);
_tv.set_fixed_height_mode(false);
_tv.set_model(_model);
add(_tv);
show_all();
std::vector<Gtk::CellRenderer*> cells = _tv.get_column(0)->get_cells();
Gtk::CellRendererText* ct = dynamic_cast<Gtk::CellRendererText*>(cells[1]);
ct->property_wrap_width() = 120;
ct->property_wrap_mode() = Pango::WRAP_WORD;
_tv.signal_size_allocate().connect(sigc::mem_fun(this, &ValidationPanel::size_request_slot));
scoped_connect(_be.tree_changed_signal(), sigc::mem_fun(this, &ValidationPanel::refresh));
}
ClassEditor::ClassEditor(StimTypes& stimTypes) :
Gtk::VBox(false, 6),
_stimTypes(stimTypes),
_updatesDisabled(false)
{
set_border_width(6);
_list = Gtk::manage(new Gtk::TreeView);
_list->set_size_request(TREE_VIEW_WIDTH, TREE_VIEW_HEIGHT);
// Connect the signals to the callbacks
_list->get_selection()->signal_changed().connect(sigc::mem_fun(*this, &ClassEditor::onSRSelectionChange));
_list->signal_key_press_event().connect(sigc::mem_fun(*this, &ClassEditor::onTreeViewKeyPress), false);
_list->signal_button_release_event().connect(
sigc::bind(sigc::mem_fun(*this, &ClassEditor::onTreeViewButtonRelease), _list));
// Add the columns to the treeview
// ID number
Gtk::TreeViewColumn* numCol = Gtk::manage(new Gtk::TreeViewColumn("#"));
Gtk::CellRendererText* numRenderer = Gtk::manage(new Gtk::CellRendererText);
numCol->pack_start(*numRenderer, false);
numCol->add_attribute(numRenderer->property_text(), SREntity::getColumns().index);
numCol->add_attribute(numRenderer->property_foreground(), SREntity::getColumns().colour);
_list->append_column(*numCol);
// The S/R icon
Gtk::TreeViewColumn* classCol = Gtk::manage(new Gtk::TreeViewColumn(_("S/R")));
Gtk::CellRendererPixbuf* pixbufRenderer = Gtk::manage(new Gtk::CellRendererPixbuf);
classCol->pack_start(*pixbufRenderer, false);
classCol->add_attribute(pixbufRenderer->property_pixbuf(), SREntity::getColumns().srClass);
_list->append_column(*classCol);
// The Type
Gtk::TreeViewColumn* typeCol = Gtk::manage(new Gtk::TreeViewColumn(_("Type")));
Gtk::CellRendererPixbuf* typeIconRenderer = Gtk::manage(new Gtk::CellRendererPixbuf);
typeCol->pack_start(*typeIconRenderer, false);
typeCol->add_attribute(typeIconRenderer->property_pixbuf(), SREntity::getColumns().icon);
Gtk::CellRendererText* typeTextRenderer = Gtk::manage(new Gtk::CellRendererText);
typeCol->pack_start(*typeTextRenderer, false);
typeCol->add_attribute(typeTextRenderer->property_text(), SREntity::getColumns().caption);
typeCol->add_attribute(typeTextRenderer->property_foreground(), SREntity::getColumns().colour);
_list->append_column(*typeCol);
}
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);
}
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());
cellText->property_style() = Pango::STYLE_ITALIC;
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);
Gtk::CellRendererText* cellValue = Gtk::manage(new Gtk::CellRendererText());
cellValue->property_editable() = false;
cellValue->property_wrap_mode() = Pango::WRAP_WORD;
cellValue->property_style() = Pango::STYLE_ITALIC;
//cellValue->property_wrap_width() = m_Columns.m_col_width;
Gtk::TreeViewColumn* valueCol = Gtk::manage(new Gtk::TreeViewColumn("Value", *cellValue));
valueCol->add_attribute(*cellValue, "text", m_Columns.m_col_value);
valueCol->add_attribute(*cellValue, "wrap_width", m_Columns.m_col_width);
valueCol->set_resizable(true);
m_TreeView.append_column(*valueCol);
//m_TreeView.set_rules_hint(true);
updateWidget();
show_all_children();
}
void SearchNotesWidget::notebook_text_cell_data_func(Gtk::CellRenderer * renderer,
const Gtk::TreeIter & iter)
{
Gtk::CellRendererText *crt = dynamic_cast<Gtk::CellRendererText*>(renderer);
crt->property_ellipsize() = Pango::ELLIPSIZE_END;
notebooks::Notebook::Ptr notebook;
iter->get_value(0, notebook);
if(!notebook) {
crt->property_text() = "";
return;
}
crt->property_text() = notebook->get_name();
if(dynamic_pointer_cast<notebooks::SpecialNotebook>(notebook)) {
// Bold the "Special" Notebooks
crt->property_markup() = Glib::ustring::compose("<span weight=\"bold\">%1</span>",
notebook->get_name());
}
else {
crt->property_text() = notebook->get_name();
}
}
/** greebo: Creates all the widgets
*/
void CustomStimEditor::populatePage()
{
set_border_width(6);
// Setup a treemodel filter to display the custom stims only
_customStimStore = Gtk::TreeModelFilter::create(_stimTypes.getListStore());
_customStimStore->set_visible_column(_stimTypes.getColumns().isCustom);
_list = Gtk::manage(new Gtk::TreeView(_customStimStore));
_list->set_size_request(TREE_VIEW_WIDTH, TREE_VIEW_HEIGHT);
// Connect the signals to the callbacks
_list->get_selection()->signal_changed().connect(sigc::mem_fun(*this, &CustomStimEditor::onSelectionChange));
_list->signal_button_release_event().connect(sigc::mem_fun(*this, &CustomStimEditor::onTreeViewButtonRelease));
// Add the columns to the treeview
// ID number
Gtk::TreeViewColumn* numCol = Gtk::manage(new Gtk::TreeViewColumn(_("ID")));
Gtk::CellRendererText* numRenderer = Gtk::manage(new Gtk::CellRendererText);
numCol->pack_start(*numRenderer, false);
numCol->add_attribute(numRenderer->property_text(), _stimTypes.getColumns().id);
_list->append_column(*numCol);
// The Type
Gtk::TreeViewColumn* typeCol = Gtk::manage(new Gtk::TreeViewColumn(_("Type")));
Gtk::CellRendererPixbuf* typeIconRenderer = Gtk::manage(new Gtk::CellRendererPixbuf);
typeCol->pack_start(*typeIconRenderer, false);
Gtk::CellRendererText* typeTextRenderer = Gtk::manage(new Gtk::CellRendererText);
typeCol->pack_start(*typeTextRenderer, false);
typeCol->add_attribute(typeTextRenderer->property_text(), _stimTypes.getColumns().caption);
typeCol->add_attribute(typeIconRenderer->property_pixbuf(), _stimTypes.getColumns().icon);
_list->append_column(*typeCol);
Gtk::VBox* listVBox = Gtk::manage(new Gtk::VBox(false, 6));
listVBox->pack_start(*Gtk::manage(new gtkutil::ScrolledFrame(*_list)), true, true, 0);
listVBox->pack_start(createListButtons(), false, false, 0);
pack_start(*listVBox, false, false, 0);
_propertyWidgets.vbox = Gtk::manage(new Gtk::VBox(false, 6));
pack_start(*_propertyWidgets.vbox, true, true, 0);
// The name widgets
Gtk::HBox* nameHBox = Gtk::manage(new Gtk::HBox(false, 6));
_propertyWidgets.nameLabel = Gtk::manage(new Gtk::Label(_("Name:")));
_propertyWidgets.nameEntry = Gtk::manage(new Gtk::Entry);
nameHBox->pack_start(*_propertyWidgets.nameLabel, false, false, 0);
nameHBox->pack_start(*_propertyWidgets.nameEntry, true, true, 0);
// Connect the entry field
_propertyWidgets.nameEntry->signal_changed().connect(sigc::mem_fun(*this, &CustomStimEditor::onEntryChanged));
_propertyWidgets.vbox->pack_start(*nameHBox, false, false, 0);
Gtk::Label* infoText = Gtk::manage(new gtkutil::LeftAlignedLabel(
_("<b>Note:</b> Please beware that deleting custom stims may\n"
"affect other entities as well. So check before you delete.")
));
_propertyWidgets.vbox->pack_start(*infoText, false, false, 0);
}
Gtk::Widget& DifficultyEditor::createEditingWidgets()
{
_editorPane = Gtk::manage(new Gtk::VBox(false, 6));
_editorPane->set_border_width(12);
// The "Settings" label
Gtk::Label* settingsLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(std::string("<b>") + _("Setting") + "</b>"));
_editorPane->pack_start(*settingsLabel, false, false, 0);
// The table aligning the editing widgets
Gtk::Table* table = Gtk::manage(new Gtk::Table(3, 2, false));
table->set_col_spacings(12);
table->set_row_spacings(6);
_editorPane->pack_start(*Gtk::manage(new gtkutil::LeftAlignment(*table, 18, 1.0)), false, false, 0);
// ===== CLASSNAME ======
Gtk::Label* classNameLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_("Classname:")));
// Add classname widget
_classCombo = Gtk::manage(new Gtk::ComboBoxEntry(
ClassNameStore::Instance().getModel(),
ClassNameStore::Instance().getColumns().classname
));
// Add completion functionality to the combobox entry
Glib::RefPtr<Gtk::EntryCompletion> completion = Gtk::EntryCompletion::create();
completion->set_model(ClassNameStore::Instance().getModel());
completion->set_text_column(ClassNameStore::Instance().getColumns().classname);
_classCombo->get_entry()->set_completion(completion);
table->attach(*classNameLabel, 0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(0), 0, 0);
table->attach(*_classCombo, 1, 2, 0, 1);
// ===== SPAWNARG ======
_spawnArgEntry = Gtk::manage(new Gtk::Entry);
Gtk::Label* spawnArgLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_("Spawnarg:")));
table->attach(*spawnArgLabel, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(0), 0, 0);
table->attach(*_spawnArgEntry, 1, 2, 1, 2);
// ===== ARGUMENT ======
_argumentEntry = Gtk::manage(new Gtk::Entry);
Gtk::Label* argumentLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_("Argument:")));
// The appType chooser
_appTypeCombo = Gtk::manage(new Gtk::ComboBox(difficulty::Setting::getAppTypeStore()));
_appTypeCombo->signal_changed().connect(sigc::mem_fun(*this, &DifficultyEditor::onAppTypeChange));
// Add the cellrenderer for the apptype text
Gtk::CellRendererText* appTypeRenderer = Gtk::manage(new Gtk::CellRendererText);
_appTypeCombo->pack_start(*appTypeRenderer, false);
_appTypeCombo->add_attribute(appTypeRenderer->property_text(), difficulty::Setting::getTreeModelColumns().name);
// Pack the argument entry and the appType dropdown field together
Gtk::HBox* argHBox = Gtk::manage(new Gtk::HBox(false, 6));
argHBox->pack_start(*_argumentEntry, true, true, 0);
argHBox->pack_start(*_appTypeCombo, false, false, 0);
table->attach(*argumentLabel, 0, 1, 2, 3, Gtk::FILL, Gtk::AttachOptions(0), 0, 0);
table->attach(*argHBox, 1, 2, 2, 3);
// Save button
Gtk::HBox* buttonHbox = Gtk::manage(new Gtk::HBox(false, 6));
_saveSettingButton = Gtk::manage(new Gtk::Button(Gtk::Stock::SAVE));
_saveSettingButton->signal_clicked().connect(sigc::mem_fun(*this, &DifficultyEditor::onSettingSave));
buttonHbox->pack_start(*_saveSettingButton, false, false, 0);
_editorPane->pack_start(*Gtk::manage(new gtkutil::RightAlignment(*buttonHbox)), false, false, 0);
// The "note" text
_noteText = Gtk::manage(new Gtk::Label);
_noteText->set_line_wrap(true);
_editorPane->pack_start(*Gtk::manage(new gtkutil::LeftAlignment(*_noteText)), false, false, 6);
return *_editorPane;
}
// 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*/
}
