void PluginDisplay::load() { int a = combobox_mono_stereo->get_model()->get_path(combobox_mono_stereo->get_active())[0]; bool s = selected_only->get_active(); bool c = changed_only->get_active(); bool d = ladspa_only->get_active(); bool e = lv2_only->get_active(); plugin_liststore->clear(); for (std::vector<PluginDesc*>::iterator v = pluginlist.begin(); v != pluginlist.end(); ++v) { if (s && !(*v)->active) { continue; } else if (c && !(*v)->has_settings) { continue; } else if (d && (*v)->is_lv2) { continue; } else if (e && !(*v)->is_lv2) { continue; } if ((a == 1 && (*v)->tp != 0) || (a == 2 && (*v)->tp != 1)) { continue; } Gtk::TreeIter it = plugin_liststore->append(); it->set_value(plugin_liststore->col.name, ustring((*v)->Name)); it->set_value(plugin_liststore->col.active, (*v)->active); it->set_value(plugin_liststore->col.pdesc, *v); } }
void jobManWindow::on_job_selected_handler() { //g_message("aha"); Gtk::TreeIter iter = treeView.get_selection()->get_selected(); if (iter) { //std::cout << iter->get_value(modelColumns.jobName) << std::endl; //std::cout << iter->get_value(modelColumns.completeDescription) << std::endl; detailsLabel.set_markup(iter->get_value(modelColumns.completeDescription)); selectedJob = iter->get_value(modelColumns.job); if (selectedJob.someInstanceRunning) { buttonStop.set_sensitive(true); buttonRestart.set_sensitive(true); buttonStart.set_sensitive(false); } else { buttonStop.set_sensitive(false); buttonRestart.set_sensitive(false); buttonStart.set_sensitive(true); } if (selectedJob.canBeSetToManual) { if (selectedJob.manual) { buttonSetManual.set_label("Enable (remove manual)"); } else { buttonSetManual.set_label("Disable (set manual)"); } buttonSetManual.set_sensitive(true); } else { //buttonSetManual.set_label("") buttonSetManual.set_sensitive(false); } } }
void SelectInstance::on_avahi_changed() { std::vector<Glib::ustring> r; av.get_service_names(r); if (!win->is_visible()) { if (r.size() == 1) { av.invoke_resolver(*r.begin()); } else { if (splash) { splash->hide(); } win->show(); } } Glib::RefPtr<Gtk::ListStore> ls = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(view->get_model()); Gtk::TreeIter s = view->get_selection()->get_selected(); Glib::ustring old; if (s) { old = s->get_value(cols.name); } ls->clear(); for (std::vector<Glib::ustring>::iterator i = r.begin(); i != r.end(); ++i) { Gtk::TreeIter j = ls->append(); j->set_value(cols.name, *i); if (old.empty()) { old = *i; } if (old == *i) { view->get_selection()->select(j); } } }
void GscHelpWindow::set_topic(const Glib::ustring& topic) { this->selection_callback_enabled = false; // temporarily disable it // scroll to it Gtk::TextView* content = this->lookup_widget<Gtk::TextView*>("content_textview"); if (content) { Glib::RefPtr<Gtk::TextBuffer> buffer = content->get_buffer(); Glib::RefPtr<Gtk::TextMark> mark = buffer->get_mark(topic); if (mark) content->scroll_to(mark, 0., 0., 0.); } // select it in tree view Gtk::TreeView* treeview = this->lookup_widget<Gtk::TreeView*>("topics_treeview"); if (treeview && !list_store->children().empty()) { for (Gtk::TreeIter iter = list_store->children().begin(); iter != list_store->children().end(); ++iter) { if (iter->get_value(col_topic) == topic) { selection->select(*iter); treeview->scroll_to_cell(list_store->get_path(iter), *(treeview->get_column(0)), 0.3, 0.); // about 30% from top break; } } } this->selection_callback_enabled = true; // enable it back }
void PluginDisplay::on_caption_toggled(const ustring& path) { Gtk::TreeIter it = port_liststore->get_iter(path); PortDesc *q = it->get_value(port_liststore->col.port); bool s = !cellrenderer_caption->get_active(); it->set_value(port_liststore->col.has_caption, s); q->has_caption = s; }
void PluginDisplay::on_active_toggled(const ustring& path) { Gtk::TreeIter it = plugin_liststore->get_iter(path); bool s = !cellrenderer_active->get_active(); it->set_value(plugin_liststore->col.active, s); change_count += it->get_value(plugin_liststore->col.pdesc)->set_active(s); set_title(); }
bool NotebooksTreeView::on_drag_motion(const Glib::RefPtr<Gdk::DragContext> &, int x, int y, guint ) { Gtk::TreePath treepath; Gtk::TreeViewDropPosition pos; if (get_dest_row_at_pos (x, y, treepath,pos) == false) { gtk_tree_view_set_drag_dest_row (gobj(), NULL, GTK_TREE_VIEW_DROP_INTO_OR_AFTER); return false; } Gtk::TreeIter iter = get_model()->get_iter (treepath); if (!iter) { gtk_tree_view_set_drag_dest_row (gobj(), NULL, GTK_TREE_VIEW_DROP_INTO_OR_AFTER); return false; } Notebook::Ptr destNotebook; iter->get_value(0, destNotebook); if(std::dynamic_pointer_cast<AllNotesNotebook>(destNotebook)) { gtk_tree_view_set_drag_dest_row (gobj(), NULL, GTK_TREE_VIEW_DROP_INTO_OR_AFTER); return true; } set_drag_dest_row (treepath , Gtk::TREE_VIEW_DROP_INTO_OR_AFTER); return true; }
int NotebookManager::compare_notebooks_sort_func(const Gtk::TreeIter &a, const Gtk::TreeIter &b) { Notebook::Ptr notebook_a; a->get_value (0, notebook_a); Notebook::Ptr notebook_b; b->get_value (0, notebook_b); if (!notebook_a || !notebook_b) return 0; SpecialNotebook::Ptr spec_a = dynamic_pointer_cast<SpecialNotebook>(notebook_a); SpecialNotebook::Ptr spec_b = dynamic_pointer_cast<SpecialNotebook>(notebook_b); if(spec_a != 0 && spec_b != 0) { return strcmp(spec_a->get_normalized_name().c_str(), spec_b->get_normalized_name().c_str()); } else if(spec_a != 0) { return -1; } else if(spec_b != 0) { return 1; } Glib::ustring a_name(notebook_a->get_name()); a_name = a_name.lowercase(); Glib::ustring b_name(notebook_b->get_name()); b_name = b_name.lowercase(); return a_name.compare(b_name); }
SelectJackControlPgm::SelectJackControlPgm(BaseObjectType* cobject, Glib::RefPtr<GxBuilder> bld, gx_engine::GxMachineBase& m) : Gtk::Window(cobject), description(), customstarter(), startercombo(), dontask(), machine(m), close() { signal_delete_event().connect(sigc::mem_fun(*this, &SelectJackControlPgm::on_delete_event)); bld->find_widget("description", description); bld->find_widget("customstarter", customstarter); customstarter->set_text(machine.get_parameter_value<string>("ui.jack_starter")); bld->find_widget("startercombo", startercombo); const char *v_id = machine.get_parameter("ui.jack_starter_idx").getValueNames()[machine.get_parameter_value<int>("ui.jack_starter_idx")].value_id; int n = 0; Glib::RefPtr<Gtk::TreeModel> model = startercombo->get_model(); for (Gtk::TreeIter i = model->children().begin(); i; ++i, ++n) { Glib::ustring s; i->get_value(1, s); if (s == v_id) { startercombo->set_active(n); } } startercombo->signal_changed().connect(sigc::mem_fun(*this, &SelectJackControlPgm::on_starter_changed)); bld->find_widget("dontask", dontask); dontask->set_active(!machine.get_parameter_value<bool>("ui.ask_for_jack_starter")); Gtk::Button *button; bld->find_widget("ok_button", button); button->signal_clicked().connect( sigc::mem_fun(*this, &SelectJackControlPgm::on_ok_button)); bld->find_widget("cancel_button", button); button->signal_clicked().connect( sigc::mem_fun(*this, &SelectJackControlPgm::on_cancel_button)); on_starter_changed(); }
bool CanvasTreeStore::find_next_value_node(const synfig::ValueNode::Handle& value_node, Gtk::TreeIter& iter) { if(!iter) return find_first_value_node(value_node,iter); if(iter) do { if(!iter->children().empty()) { Gtk::TreeIter iter2(iter->children().begin()); //! \todo confirm that the && should be done before the || if((iter2 && value_node==(ValueNode::Handle)(*iter2)[model.value_node]) || find_next_value_node(value_node, iter2)) { iter=iter2; return true; } } Gtk::TreeIter iter2(++iter); if(!iter2) { iter==iter->parent(); if(iter)++iter; } else iter=iter2; } while(iter && value_node!=(ValueNode::Handle)(*iter)[model.value_node]); return (bool)iter && value_node==(ValueNode::Handle)(*iter)[model.value_node]; }
bool CanvasTreeStore::find_first_value_node(const synfig::ValueNode::Handle& value_node, Gtk::TreeIter& iter) { // maybe replace the ValueNode_Const or ValueNode_Animated with the contained ValueNode_Bone // todo: do we need to do this in find_next_value_node, and find_*_value_desc too? synfig::ValueNode::Handle node(expandable_bone_parent(value_node)); iter=children().begin(); while(iter && node!=(ValueNode::Handle)(*iter)[model.value_node]) { if(!iter->children().empty()) { Gtk::TreeIter iter2(iter->children().begin()); //! \todo confirm that the && should be done before the || if((iter2 && node==(ValueNode::Handle)(*iter2)[model.value_node]) || find_next_value_node(node, iter2)) { iter=iter2; return true; } } Gtk::TreeIter iter2(++iter); if(!iter2) iter==iter->parent(); else iter=iter2; } return (bool)iter && node==(ValueNode::Handle)(*iter)[model.value_node]; }
NotebookManager::NotebookManager() : m_adding_notebook(false) { m_notebooks = Gtk::ListStore::create(m_column_types); m_sortedNotebooks = Gtk::TreeModelSort::create (m_notebooks); m_sortedNotebooks->set_sort_func ( 0, sigc::ptr_fun(&NotebookManager::compare_notebooks_sort_func)); m_sortedNotebooks->set_sort_column (0, Gtk::SORT_ASCENDING); m_filteredNotebooks = Gtk::TreeModelFilter::create (m_sortedNotebooks); m_filteredNotebooks->set_visible_func( sigc::ptr_fun(&NotebookManager::filter_notebooks)); Notebook::Ptr allNotesNotebook(new AllNotesNotebook ()); Gtk::TreeIter iter = m_notebooks->append (); iter->set_value(0, Notebook::Ptr(allNotesNotebook)); Notebook::Ptr unfiledNotesNotebook(new UnfiledNotesNotebook ()); iter = m_notebooks->append (); iter->set_value(0, Notebook::Ptr(unfiledNotesNotebook)); load_notebooks (); }
int NotebookManager::compare_notebooks_sort_func(const Gtk::TreeIter &a, const Gtk::TreeIter &b) { Notebook::Ptr notebook_a; a->get_value (0, notebook_a); Notebook::Ptr notebook_b; b->get_value (0, notebook_b); if (!notebook_a || !notebook_b) return 0; if (std::tr1::dynamic_pointer_cast<SpecialNotebook>(notebook_a) && std::tr1::dynamic_pointer_cast<SpecialNotebook>(notebook_b)) { if (std::tr1::dynamic_pointer_cast<AllNotesNotebook>(notebook_a)) { return -1; } else { return 1; } } else if (std::tr1::dynamic_pointer_cast<SpecialNotebook>(notebook_a)) { return -1; } else if (std::tr1::dynamic_pointer_cast<SpecialNotebook>(notebook_b)) { return 1; } return strcmp(notebook_a->get_name().c_str(), notebook_b->get_name().c_str()); }
void PluginDisplay::display_label(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) { PortDesc *q = it->get_value(enum_liststore->col.port); if (q->enumkey_changed(int(it->get_value(enum_liststore->col.value)))) { dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red"); } else { dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false); } }
void PluginDisplay::on_search_entry_activate() { Gtk::TreeIter it = treeview1->get_selection()->get_selected(); if (it) { bool v = !it->get_value(plugin_liststore->col.active); it->set_value(plugin_liststore->col.active, v); change_count += it->get_value(plugin_liststore->col.pdesc)->set_active(v); set_title(); } }
void LivePathEffectEditor::selectInList(LivePathEffect::Effect* effect) { Gtk::TreeNodeChildren chi = effectlist_view.get_model()->children(); for (Gtk::TreeIter ci = chi.begin() ; ci != chi.end(); ci++) { if (ci->get_value(columns.lperef)->lpeobject->get_lpe() == effect) effectlist_view.get_selection()->select(ci); } }
void PluginDisplay::on_newrow_toggled(const ustring& path) { Gtk::TreeIter it = port_liststore->get_iter(path); PortDesc *q = it->get_value(port_liststore->col.port); bool s = !cellrenderer_newrow->get_active(); it->set_value(port_liststore->col.newrow, s); if (s == q->factory.get_newrow()) { q->user.unset(ChangeableValues::newrow_set); } else { q->user.set_newrow(s); } }
void SelectInstance::on_response(int response_id) { if (response_id == 1) { Gtk::TreeIter i = view->get_selection()->get_selected(); if (!i) { return; } av.invoke_resolver(i->get_value(cols.name)); return; } Gtk::Main::quit(); }
void PluginDisplay::on_step_edited(const ustring& path, const ustring& newtext) { Gtk::TreeIter it = port_liststore->get_iter(path); step_mode m = stp_normal; for (unsigned int i = 0; i < sizeof(step_type_names)/sizeof(step_type_names[0]); ++i) { if (step_type_names[i] == newtext) { m = static_cast<step_mode>(i); break; } } it->get_value(port_liststore->col.port)->step = m; it->set_value(port_liststore->col.step, newtext); }
void PluginDisplay::on_name_edited(const ustring& path, const ustring& newtext) { Gtk::TreeIter it = port_liststore->get_iter(path); PortDesc *q = it->get_value(port_liststore->col.port); ustring text(newtext); gx_system::strip(text); if (text.empty() || q->factory.get_name() == text) { q->user.unset(ChangeableValues::name_set); } else { q->user.set_name(text); } it->set_value(port_liststore->col.name, q->get_name()); }
void PluginDisplay::on_select_all(bool v) { int d = 0; Gtk::TreeNodeChildren ch = plugin_liststore->children(); for (Gtk::TreeIter it = ch.begin(); it != ch.end(); ++it) { it->set_value(plugin_liststore->col.active, v); d += it->get_value(plugin_liststore->col.pdesc)->set_active(v); } if (d) { change_count += d; set_title(); } }
void PluginDisplay::on_reordered(const Gtk::TreePath& path) { assert(current_plugin); std::map<int,int> d; for (unsigned int i = 0; i < current_plugin->ctrl_ports.size(); ++i) { d[current_plugin->ctrl_ports[i]->pos] = i; } std::vector<PortDesc*> l; Gtk::TreeNodeChildren ch = port_liststore->children(); for (Gtk::TreeIter it = ch.begin(); it != ch.end(); ++it) { l.push_back(current_plugin->ctrl_ports[d[it->get_value(port_liststore->col.pos)]]); } current_plugin->ctrl_ports = l; }
void NotebookNoteAddin::get_notebook_menu_items(std::list<NotebookMenuItem*>& items) { Glib::RefPtr<Gtk::TreeModel> model = NotebookManager::obj().get_notebooks(); Gtk::TreeIter iter; items.clear(); iter = model->children().begin(); for(iter = model->children().begin(); iter != model->children().end(); ++iter) { Notebook::Ptr notebook; iter->get_value(0, notebook); NotebookMenuItem *item = manage(new NotebookMenuItem (m_radio_group, get_note(), notebook)); items.push_back (item); } }
bool PluginDisplay::search_equal(const Glib::RefPtr<Gtk::TreeModel>& model, int column, const ustring& key, const Gtk::TreeIter& iter) { PluginDesc *p = iter->get_value(plugin_liststore->col.pdesc); ustring txt(gx_system::to_string(p->UniqueID)); if (txt.compare(0, ustring::npos, key, 0, key.size()) == 0) { return false; } txt = iter->get_value(plugin_liststore->col.name).lowercase(); std::vector<ustring> keyvec; split(keyvec, key); for (std::vector<ustring>::iterator i = keyvec.begin(); i != keyvec.end(); ++i) { if (txt.find(*i) == ustring::npos) { return true; } } return false; }
void PluginDisplay::on_parameter_selection_changed() { Gtk::TreeIter it = treeview2->get_selection()->get_selected(); enum_liststore->clear(); if (it) { PortDesc *q = it->get_value(port_liststore->col.port); if (q->get_tp() == tp_enum) { int up = int(q->get_up()); for (int idx = int(q->get_low()); idx <= up; ++idx) { it = enum_liststore->append(); it->set_value(enum_liststore->col.value, idx); it->set_value(enum_liststore->col.label, q->get_enum(idx)); it->set_value(enum_liststore->col.port, q); } } } }
std::string AddinsTreeModel::get_module_id(const Gtk::TreeIter & iter) { std::string id; if(iter) { iter->get_value(4, id); } return id; }
void PluginDisplay::display_idx(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) { PortDesc *q = it->get_value(port_liststore->col.port); if (int(port_liststore->get_path(it)[0]) != q->get_pos()) { dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red"); } else { dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false); } }
void PluginDisplay::display_name(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) { PortDesc *q = it->get_value(port_liststore->col.port); if (q->is_set(ChangeableValues::name_set)) { dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground().set_value("red"); } else { dynamic_cast<Gtk::CellRendererText*>(cell)->property_foreground_set().set_value(false); } }
void PluginDisplay::display_newrow(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) { PortDesc *q = it->get_value(port_liststore->col.port); if (q->is_set(ChangeableValues::newrow_set)) { cell->property_cell_background().set_value("red"); } else { cell->property_cell_background_set().set_value(false); } }
void PluginDisplay::display_caption(Gtk::CellRenderer *cell, const Gtk::TreeIter& it) { PortDesc *q = it->get_value(port_liststore->col.port); if (!q->has_caption) { cell->property_cell_background().set_value("red"); } else { cell->property_cell_background_set().set_value(false); } }