def __init__(self): super(PluginListView, self).__init__() self.set_headers_visible(False) render = Gtk.CellRendererToggle() def cell_data(col, render, model, iter_, data): plugin = model.get_value(iter_) pm = PluginManager.instance render.set_active(pm.enabled(plugin)) render.connect('toggled', self.__toggled) column = Gtk.TreeViewColumn("enabled", render) column.set_cell_data_func(render, cell_data) self.append_column(column) render = Gtk.CellRendererPixbuf() def cell_data2(col, render, model, iter_, data): plugin = model.get_value(iter_) icon = plugin.icon or Gtk.STOCK_EXECUTE if Gtk.stock_lookup(icon): render.set_property('stock-id', icon) else: render.set_property('icon-name', icon) column = Gtk.TreeViewColumn("image", render) column.set_cell_data_func(render, cell_data2) self.append_column(column) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) render.set_property('xalign', 0.0) column = Gtk.TreeViewColumn("name", render) def cell_data3(col, render, model, iter_, data): plugin = model.get_value(iter_) render.set_property('text', plugin.name) column.set_cell_data_func(render, cell_data3) column.set_expand(True) self.append_column(column)
def __init__(self, manager, dropdown): self.manager = manager self.dropdown = dropdown self.model = Gtk.ListStore.new([ GObject.TYPE_STRING, # ID GObject.TYPE_STRING, # NAME GObject.TYPE_STRING, # TEXT ]) self.manager.fill_in_values(self.model) self.view = Gtk.TreeView() self.view.set_activate_on_single_click(True) self.view.set_headers_visible(False) self.view.set_enable_search(False) self.view.set_model(self.model) self.view.get_selection().set_mode(Gtk.SelectionMode.NONE) self.view.connect("row-activated", self._row_activated) col = Gtk.TreeViewColumn() self.view.append_column(col) self._rendererHeading = Gtk.CellRendererText(weight=Pango.Weight.BOLD, weight_set=True) col.pack_start(self._rendererHeading, False) col.add_attribute(self._rendererHeading, 'text', BaseModelColumns.HEADING_TEXT) col.set_cell_data_func(self._rendererHeading, self._visibilityForHeading, True) self._rendererRadio = Gtk.CellRendererToggle( radio=True, mode=Gtk.CellRendererMode.INERT) col.pack_start(self._rendererRadio, False) col.set_cell_data_func(self._rendererRadio, self._visibilityForHeading, [False, self._render_radio]) self._rendererText = Gtk.CellRendererText() col.pack_start(self._rendererText, True) col.add_attribute(self._rendererText, 'text', BaseModelColumns.NAME) col.set_cell_data_func(self._rendererText, self._visibilityForHeading, False) self.view.show()
def __init__(self, updates): list_model = UpdateListModel(updates) Gtk.TreeView.__init__(self, list_model) self.set_reorderable(False) self.set_enable_search(False) self.set_headers_visible(False) toggle_renderer = Gtk.CellRendererToggle() toggle_renderer.props.activatable = True toggle_renderer.props.xpad = style.DEFAULT_PADDING toggle_renderer.props.indicator_size = style.zoom(26) toggle_renderer.connect('toggled', self.__toggled_cb) toggle_column = Gtk.TreeViewColumn() toggle_column.pack_start(toggle_renderer, True) toggle_column.add_attribute(toggle_renderer, 'active', UpdateListModel.SELECTED) self.append_column(toggle_column) icon_renderer = CellRendererIcon(self) icon_renderer.props.width = style.STANDARD_ICON_SIZE icon_renderer.props.height = style.STANDARD_ICON_SIZE icon_renderer.props.size = style.STANDARD_ICON_SIZE icon_renderer.props.xpad = style.DEFAULT_PADDING icon_renderer.props.ypad = style.DEFAULT_PADDING icon_renderer.props.stroke_color = style.COLOR_TOOLBAR_GREY.get_svg() icon_renderer.props.fill_color = style.COLOR_TRANSPARENT.get_svg() icon_column = Gtk.TreeViewColumn() icon_column.pack_start(icon_renderer, True) icon_column.add_attribute(icon_renderer, 'file-name', UpdateListModel.ICON_FILE_NAME) self.append_column(icon_column) text_renderer = Gtk.CellRendererText() description_column = Gtk.TreeViewColumn() description_column.pack_start(text_renderer, True) description_column.add_attribute(text_renderer, 'markup', UpdateListModel.DESCRIPTION) self.append_column(description_column)
def init_treeview(self): textrenderer = Gtk.CellRendererText() boolrenderer = Gtk.CellRendererToggle() boolrenderer.connect("toggled", self.on_cell_toggled) self.tree = self.builder.get_object("Signal Selection") self.tree.append_column( Gtk.TreeViewColumn("Plot", boolrenderer, active=0)) columnnames = ["Name", "Unit", "mean", "max", "current"] for i, column in enumerate(columnnames): tcolumn = Gtk.TreeViewColumn(column, textrenderer, text=i + 1) self.tree.append_column(tcolumn) #if i == 0: # tcolumn.set_sort_column_id(i+1) for plotsignal in self.Plotsignals: self.signalstore.append([ plotsignal.plotenable, plotsignal.name, convert_to_si(plotsignal.unit)[0], '0', '0', '0' ]) self.tree.set_model(self.signalstore)
def add_bool_column(self, header, col_type=bool, hidden=False, position=None, status_field=None, sortid=0, column_type="bool", default=True): """Add a bool column to the listview""" render = Gtk.CellRendererToggle() self.add_column(header, render, col_type, hidden, position, status_field, sortid, column_type=column_type, default=default)
def __init__(self, column_name, tooltip_text, model_index_bool, on_toggle, *args, on_toggle_data=None, **kwargs): super(FlagColumn, self).__init__(*args, **kwargs) self.title = Gtk.Label(column_name) self.title.set_tooltip_text(tooltip_text) self.title.show() self.set_widget(self.title) renderer_flag = Gtk.CellRendererToggle() renderer_flag.set_property("activatable", True) self.cell_renderers = (renderer_flag,) renderer_flag.connect("toggled", on_toggle, on_toggle_data) self.pack_start(renderer_flag, expand=False) self.add_attribute(renderer_flag, "active", model_index_bool) self.set_clickable(True) self.set_resizable(False)
def _init_plugin_tree(self): """ Initialize the PluginTree Gtk.TreeView. The format is modelled after the one used in gedit; see http://git.gnome.org/browse/gedit/tree/gedit/gedit-plugin-mapnager.c """ # force creation of the Gtk.ListStore so we can reference it self._refresh_plugin_store() # renderer for the toggle column renderer = Gtk.CellRendererToggle() renderer.set_property('xpad', 6) renderer.connect('toggled', self.on_plugin_toggle) # toggle column column = Gtk.TreeViewColumn(None, renderer, active=PLUGINS_COL_ENABLED, activatable=PLUGINS_COL_ACTIVATABLE, sensitive=PLUGINS_COL_ACTIVATABLE) self.plugin_tree.append_column(column) # plugin name column column = Gtk.TreeViewColumn() column.set_spacing(6) # icon renderer for the plugin name column icon_renderer = Gtk.CellRendererPixbuf() icon_renderer.set_property('stock-size', Gtk.IconSize.SMALL_TOOLBAR) icon_renderer.set_property('xpad', 3) column.pack_start(icon_renderer, False) column.set_cell_data_func(icon_renderer, plugin_icon) # text renderer for the plugin name column name_renderer = Gtk.CellRendererText() name_renderer.set_property('ellipsize', Pango.EllipsizeMode.END) column.pack_start(name_renderer, True) column.set_cell_data_func(name_renderer, plugin_markup, self) self.plugin_tree.append_column(column) # finish setup self.plugin_tree.set_model(self.plugin_store) self.plugin_tree.set_search_column(2)
def __init__(self, filters, browser, parent=None): super(SelectionWindow, self).__init__() self.set_border_width(10) self.set_title(FilterAll.PLUGIN_NAME) self.set_default_size(200, 250) self.set_transient_for(parent) model = Gtk.ListStore(bool, str, str) for key, value in sorted(filters.items()): model.append(row=[False, key, value]) toggle = Gtk.CellRendererToggle() toggle.connect("toggled", self.__toggeled, model, browser) text = Gtk.CellRendererText() toggle_column = Gtk.TreeViewColumn("", toggle, active=0) column = Gtk.TreeViewColumn(_("Tag"), text, text=1) view = Gtk.TreeView(model) view.append_column(toggle_column) view.append_column(column) sw = Gtk.ScrolledWindow() sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.set_shadow_type(Gtk.ShadowType.IN) sw.add(view) buttons = Gtk.HButtonBox() buttons.set_spacing(6) buttons.set_layout(Gtk.ButtonBoxStyle.END) close = Button(_("_Close"), Icons.WINDOW_CLOSE) close.connect('clicked', lambda *x: self.destroy()) buttons.pack_start(close, True, True, 0) box = Gtk.VBox(spacing=12) box.pack_start(sw, True, True, 0) box.pack_start(buttons, False, True, 0) self.add(box) self.show_all()
def build_widget(self): vbox=Gtk.VBox() # FIXME: implement package removal from the list self.store=self.build_liststore() treeview=Gtk.TreeView(model=self.store) treeview.connect('button-press-event', self.tree_view_button_cb) treeview.connect('row-activated', self.row_activated_cb) renderer = Gtk.CellRendererToggle() renderer.set_property('activatable', True) renderer.connect('toggled', self.toggled_cb, self.store, self.COLUMN_IMPORTED) column = Gtk.TreeViewColumn(_('Imported?'), renderer, active=self.COLUMN_IMPORTED) treeview.append_column(column) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Id'), renderer, text=self.COLUMN_ID) column.set_resizable(True) treeview.append_column(column) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Title'), renderer, text=self.COLUMN_LABEL) column.set_resizable(True) treeview.append_column(column) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('URI'), renderer, text=self.COLUMN_URI) column.set_resizable(True) treeview.append_column(column) vbox.add(treeview) vbox.show_all() return vbox
def create_table(self): """ Create list model and filter model and populate with Directories, then create the actual Tree View for showing and editing those values. """ self.store = Gtk.ListStore(str, str, str, bool, bool, float) self.update_table() self.table = Gtk.TreeView.new_with_model(self.store) self.select = self.table.get_selection() for i, att in enumerate( ["Path", "Type", "Last Backup", "Incl.?", "Incr.?"]): if i == 1: renderer = Gtk.CellRendererCombo() type_list = Gtk.ListStore(str) for x in KNOWN_TYPES: type_list.append([x]) def edit_func(_widget, path, text, i=i): self.store[path][i] = text renderer.set_property("model", type_list) renderer.set_property("text-column", 0) renderer.set_property("editable", True) renderer.connect("edited", edit_func) elif i >= 3: renderer = Gtk.CellRendererToggle() def toggle_func(_widget, path, i=i): self.store[path][i] ^= True renderer.set_property("activatable", True) renderer.connect("toggled", toggle_func) else: renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(att, renderer, active=i) if i >= 3 else \ Gtk.TreeViewColumn(att, renderer, text=i) column.set_sort_column_id(i) column.set_expand(i == 0) self.table.append_column(column)
def prepare_storage_list(storage_list): # Checkbox, deleteable?, storage path, target (hda), icon stock, # icon size, tooltip model = Gtk.ListStore(bool, bool, str, str, bool, str, int, str) storage_list.set_model(model) storage_list.set_tooltip_column(STORAGE_ROW_TOOLTIP) confirmCol = Gtk.TreeViewColumn() pathCol = Gtk.TreeViewColumn(_("Storage Path")) targetCol = Gtk.TreeViewColumn(_("Target")) infoCol = Gtk.TreeViewColumn() storage_list.append_column(confirmCol) storage_list.append_column(pathCol) storage_list.append_column(targetCol) storage_list.append_column(infoCol) chkbox = Gtk.CellRendererToggle() chkbox.connect('toggled', storage_item_toggled, storage_list) confirmCol.pack_start(chkbox, False) confirmCol.add_attribute(chkbox, 'active', STORAGE_ROW_CONFIRM) confirmCol.add_attribute(chkbox, 'inconsistent', STORAGE_ROW_CANT_DELETE) confirmCol.set_sort_column_id(STORAGE_ROW_CANT_DELETE) path_txt = Gtk.CellRendererText() pathCol.pack_start(path_txt, True) pathCol.add_attribute(path_txt, 'text', STORAGE_ROW_PATH) pathCol.set_sort_column_id(STORAGE_ROW_PATH) target_txt = Gtk.CellRendererText() targetCol.pack_start(target_txt, False) targetCol.add_attribute(target_txt, 'text', STORAGE_ROW_TARGET) targetCol.set_sort_column_id(STORAGE_ROW_TARGET) info_img = Gtk.CellRendererPixbuf() infoCol.pack_start(info_img, False) infoCol.add_attribute(info_img, 'visible', STORAGE_ROW_ICON_SHOW) infoCol.add_attribute(info_img, 'stock-id', STORAGE_ROW_ICON) infoCol.add_attribute(info_img, 'stock-size', STORAGE_ROW_ICON_SIZE) infoCol.set_sort_column_id(STORAGE_ROW_ICON)
def get_treeview(self, model): """Return TreeeView widget""" treeview = Gtk.TreeView(model=model) treeview.set_headers_visible(False) renderer_toggle = Gtk.CellRendererToggle() renderer_text = Gtk.CellRendererText() installed_column = Gtk.TreeViewColumn(None, renderer_toggle, active=3) renderer_toggle.connect("toggled", self.on_installed_toggled) treeview.append_column(installed_column) version_column = Gtk.TreeViewColumn(None, renderer_text) version_column.add_attribute(renderer_text, "text", self.COL_VER) version_column.set_property("min-width", 80) treeview.append_column(version_column) arch_column = Gtk.TreeViewColumn(None, renderer_text, text=self.COL_ARCH) arch_column.set_property("min-width", 50) treeview.append_column(arch_column) progress_column = Gtk.TreeViewColumn( None, self.renderer_progress, value=self.COL_PROGRESS, visible=self.COL_PROGRESS, ) progress_column.set_property("fixed-width", 60) progress_column.set_property("min-width", 60) progress_column.set_property("resizable", False) treeview.append_column(progress_column) usage_column = Gtk.TreeViewColumn(None, renderer_text, text=self.COL_USAGE) usage_column.set_property("min-width", 200) treeview.append_column(usage_column) return treeview
def init_device_list(self, device_list): """create the gui device list and grid device_list: a list of Device objects - will be displayed in the grid """ self.device_list_model = Gtk.ListStore(int, bool, str, str, str, str, str, str) for device in device_list: print(device.as_list()) self.device_list_model.append(device.as_list()) device_list_view = Gtk.TreeView(model=self.device_list_model) device_list_view.set_grid_lines(Gtk.TreeViewGridLines.HORIZONTAL) for i in range(len(self.DEVICE_LIST_COLUMNS)): if i == 1: cell = Gtk.CellRendererToggle() col = Gtk.TreeViewColumn(self.DEVICE_LIST_COLUMNS[i], cell, active=1) device_list_view.append_column(col) cell.connect("toggled", self.on_toggled) else: cell = Gtk.CellRendererText() # the text in the first column should be in boldface if i == 0: cell.props.weight_set = True cell.props.weight = Pango.Weight.BOLD col = Gtk.TreeViewColumn(self.DEVICE_LIST_COLUMNS[i], cell, text=i) if not self.detailed: if i == 0 or i == 2 or i == 3 or i == 5 or i == 6: # don't show the number, id, serial, port and interface if not in detailed view col.set_visible(False) device_list_view.append_column(col) device_list_view.connect("button-press-event", self.on_row_clicked) grid = Gtk.Grid() grid.attach(device_list_view, 0, 0, 1, 1) self.add(grid)
def inittreeview(self): """initialisation de la liste d'images a importer""" self.liststoreimport = Gtk.ListStore( bool, str, GdkPixbuf.Pixbuf, str) #création de la listestore qui contiendra les noms d'images self.listeimages.set_model( self.liststoreimport ) #on donne la liststore au l'afficheur treeview self.listeimages.set_property('tooltip-column', 3) self.colonneselect = Gtk.TreeViewColumn('') #Premiere colonne : self.listeimages.append_column( self.colonneselect) #on l'ajoute au TreeView self.select = Gtk.CellRendererToggle( ) #On creer le cellrender pour avoir des boutons toggle self.colonneselect.pack_start( self.select, True) #on met le cellrender dans la colonne self.colonneselect.add_attribute( self.select, 'active', 0) #on met les boutons actifs par défaut # self.colonneimages = Gtk.TreeViewColumn(_('Image')) #deuxieme colonne, titre 'Image' # self.listeimages.append_column(self.colonneimages) #on rajoute la colonne dans le treeview # self.cell = Gtk.CellRendererText() #Ce sera des cellules de texte # self.colonneimages.pack_start(self.cell, True) #que l'on met dans la colonne # self.colonneimages.add_attribute(self.cell, 'text', 1) #et on specifie que c'est du texte simple self.colonneimages2 = Gtk.TreeViewColumn( _("Thumbnail")) #deuxieme colonne, titre 'Image' self.listeimages.append_column( self.colonneimages2) #on rajoute la colonne dans le treeview self.cell2 = Gtk.CellRendererPixbuf() #Ce sera des cellules de texte self.colonneimages2.set_sizing(Gtk.TreeViewColumnSizing.FIXED) self.colonneimages2.pack_start(self.cell2, True) #que l'on met dans la colonne self.colonneimages2.add_attribute(self.cell2, 'pixbuf', 2) self.cell2.set_property('visible', 1) self.listeimages.set_rules_hint(True) self.select.connect("toggled", toggled_cb, (self.liststoreimport, 0)) #Pour que les boutons de selection marchent
def make_treeview (self, plugin_list): tv = Gtk.TreeView() toggle_renderer = Gtk.CellRendererToggle() toggle_renderer.set_property('activatable',True) toggle_renderer.set_property('sensitive',True) toggle_renderer.connect('toggled',self.toggled_cb,tv) active_col = Gtk.TreeViewColumn('Active',toggle_renderer,active=0) text_renderer = Gtk.CellRendererText() text_renderer.set_property('wrap-width',350) plugin_col = Gtk.TreeViewColumn('Plugin',text_renderer) plugin_col.set_cell_data_func(text_renderer, self.plugin_description_formatter) plugin_col.set_property('expand',True) plugin_col.set_property('min-width',250) tv.append_column(plugin_col) tv.append_column(active_col) ls = self.make_list_store(plugin_list) tv.set_model(ls) sw = Gtk.ScrolledWindow() sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) sw.add(tv) return sw
def __init__(self, gbuilder, controller): self.mdialog = gbuilder.get_object("dialog_ADEX") self.control = controller self.list_adex_switch = gbuilder.get_object("list_ADEX_switch") treeview_adex_switch = gbuilder.get_object("treeview_ADEX_switch") renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn("Name", renderer, text=0) treeview_adex_switch.append_column(column) render_toggle = Gtk.CellRendererToggle() render_toggle.connect("toggled", self.toggle_switches) column_toggle = Gtk.TreeViewColumn("Choose", render_toggle, active=1) treeview_adex_switch.append_column(column_toggle) self.f30mins_toggle = gbuilder.get_object("adex_30mins_check") self.partial_toggle = gbuilder.get_object("adex_partial_check") self.naptime_toggle = gbuilder.get_object("adex_naptime_check") self.last2r_toggle = gbuilder.get_object("adex_last2_check")
def get_treeview(self, model): treeview = Gtk.TreeView(model=model) treeview.set_headers_visible(False) renderer_toggle = Gtk.CellRendererToggle() renderer_toggle.connect("toggled", self.on_import_toggled) renderer_text = Gtk.CellRendererText() import_column = Gtk.TreeViewColumn("Import", renderer_toggle, active=self.COL_SELECTED) treeview.append_column(import_column) image_cell = Gtk.CellRendererPixbuf() icon_column = Gtk.TreeViewColumn("", image_cell, pixbuf=self.COL_ICON) treeview.append_column(icon_column) name_column = Gtk.TreeViewColumn(None, renderer_text) name_column.add_attribute(renderer_text, "text", self.COL_NAME) name_column.set_property("min-width", 80) treeview.append_column(name_column) return treeview
def __init__(self, category): # important, starred, text, id, history id, background color TreeView.__init__(self, Gtk.ListStore(bool, bool, str, str, str, str), 3) self.category = category self.set_size_request(300, 1) renderer_toggle = Gtk.CellRendererToggle() renderer_toggle.connect("toggled", self.__important_setted) column_toggle = Gtk.TreeViewColumn("Important", renderer_toggle, active=0) self.view.append_column(column_toggle) cell_favorite = CellRendererFavourite() cell_favorite.connect('clicked', self.__favourite_clicked) self._fav_column = Gtk.TreeViewColumn("Starred", cell_favorite) self._fav_column.set_cell_data_func( cell_favorite, self.__favorite_set_data) self.view.append_column(self._fav_column) renderer_text = Gtk.CellRendererText() renderer_text.set_property("ellipsize", Pango.EllipsizeMode.END) column_text = Gtk.TreeViewColumn("Mail", renderer_text, text=2, background=5) self.view.append_column(column_text)
def create_treeview(self): packages_treeview = self.builder.get_object("packages_treeview") renderer_toggle = Gtk.CellRendererToggle() renderer_toggle.connect("toggled", self.on_cell_toggled) column_toggle = Gtk.TreeViewColumn("", renderer_toggle, active=0) packages_treeview.append_column(column_toggle) pixbuf_renderer = Gtk.CellRendererPixbuf() column_status = Gtk.TreeViewColumn("", pixbuf_renderer, icon_name=1) packages_treeview.append_column(column_status) titles = [_('Name'), _('Version'), _('Arch'), _("Repository"), _('Size')] sizes = [2, 1.5, 1, 1, 1] text_renderer = Gtk.CellRendererText() for (i, (title, size)) in enumerate(zip(titles, sizes)): column = Gtk.TreeViewColumn(title, text_renderer, text=i+2) column.set_resizable(True) column.set_fixed_width(175*size) packages_treeview.append_column(column)
def setupItemTree(self): items = self.tree.get_object('item_tree') column = Gtk.TreeViewColumn(_("Show")) cell = Gtk.CellRendererToggle() cell.connect('toggled', self.on_item_tree_show_toggled) column.pack_start(cell, True) column.add_attribute(cell, 'active', 0) #hide toggle for separators column.set_cell_data_func(cell, self._cell_data_toggle_func) items.append_column(column) column = Gtk.TreeViewColumn(_("Item")) column.set_spacing(4) cell = Gtk.CellRendererPixbuf() column.pack_start(cell, False) column.set_cell_data_func(cell, self.icon_data_func, 1) cell = Gtk.CellRendererText() column.pack_start(cell, True) column.add_attribute(cell, 'markup', 2) items.append_column(column) self.item_store = Gtk.ListStore(bool, object, str, object) items.set_model(self.item_store)
def _add_column(self): renderer = Gtk.CellRendererToggle() renderer.connect('toggled', self.on_enable_toggled) column = Gtk.TreeViewColumn(' ', renderer, active=self.COLUMN_ENABLED) column.set_sort_column_id(self.COLUMN_ENABLED) self.append_column(column) self.source_column = Gtk.TreeViewColumn(_('Third-Party Sources')) self.source_column.set_sort_column_id(self.COLUMN_NAME) self.source_column.set_spacing(5) renderer = Gtk.CellRendererPixbuf() self.source_column.pack_start(renderer, False) self.source_column.add_attribute(renderer, 'pixbuf', self.COLUMN_LOGO) renderer = Gtk.CellRendererText() renderer.set_property('ellipsize', Pango.EllipsizeMode.END) self.source_column.pack_start(renderer, True) self.source_column.add_attribute(renderer, 'markup', self.COLUMN_DISPLAY) self.append_column(self.source_column)
def __init__(self, pluginManager, cfgProvider): self.pluginManager = pluginManager self.cfgProvider = cfgProvider self.log = logging.getLogger('radiotray') # load glade and get gui objects gladefile = utils.load_ui_file("configPlugins.glade") self.wTree = gladefile self.window = self.wTree.get_object("dialog1") self.list = self.wTree.get_object("treeview1") # set icon self.window.set_icon_from_file(APP_ICON_ON) # load plugin data liststore = self.load_data() self.list.set_model(liststore) # config plugins view cell1 = Gtk.CellRendererToggle() cell1.set_property('activatable', True) cell1.set_activatable(True) cell1.set_property('mode', Gtk.CellRendererMode.ACTIVATABLE) cell1.connect('toggled', self.on_toggle, liststore) tvcolumn1 = Gtk.TreeViewColumn(_('Active'), cell1) tvcolumn1.add_attribute(cell1, "active", 0) cell2 = Gtk.CellRendererText() tvcolumn2 = Gtk.TreeViewColumn(_('Name'), cell2, text=1) self.list.append_column(tvcolumn1) self.list.append_column(tvcolumn2) if (self.window): dic = {"on_close_clicked": self.on_close_clicked} self.wTree.connect_signals(self) self.window.show()
def show_extras(self, extras): """Show installer screen with the extras picker""" self.clean_widgets() extra_liststore = Gtk.ListStore( bool, # is selected? str, # id str, # label ) for extra in extras: extra_liststore.append( (False, extra["id"], self.get_extra_label(extra))) treeview = Gtk.TreeView(extra_liststore) treeview.set_headers_visible(False) renderer_toggle = Gtk.CellRendererToggle() renderer_toggle.connect("toggled", self.on_extra_toggled, extra_liststore) renderer_text = Gtk.CellRendererText() installed_column = Gtk.TreeViewColumn(None, renderer_toggle, active=0) treeview.append_column(installed_column) label_column = Gtk.TreeViewColumn(None, renderer_text) label_column.add_attribute(renderer_text, "text", 2) label_column.set_property("min-width", 80) treeview.append_column(label_column) scrolledwindow = Gtk.ScrolledWindow(hexpand=True, vexpand=True, child=treeview, visible=True) scrolledwindow.set_shadow_type(Gtk.ShadowType.ETCHED_IN) scrolledwindow.show_all() self.widget_box.pack_end(scrolledwindow, True, True, 10) self.continue_button.show() self.continue_button.set_sensitive(True) if self.continue_handler: self.continue_button.disconnect(self.continue_handler) self.continue_handler = self.continue_button.connect( "clicked", self.on_extras_confirmed, extra_liststore)
def __init__(self): from gi.repository import GObject from pogo.gui import window self.window = window.Window('Preferences.ui', 'vbox1', __name__, _('Preferences'), 390, 350) # List of modules toggleRdr = Gtk.CellRendererToggle() columns = (('', [ (toggleRdr, GObject.TYPE_BOOLEAN) ], ROW_ENABLED, False, True), ('', [ (Gtk.CellRendererText(), GObject.TYPE_STRING) ], ROW_TEXT, True, True), ('', [ (Gtk.CellRendererPixbuf(), GdkPixbuf.Pixbuf) ], ROW_ICON, False, True), (None, [ (None, GObject.TYPE_BOOLEAN) ], ROW_UNLOADABLE, False, False), (None, [ (None, GObject.TYPE_PYOBJECT) ], ROW_INSTANCE, False, False), (None, [(None, GObject.TYPE_PYOBJECT)], ROW_MODINFO, False, False)) self.list = PreferencesListView(columns) self.list.set_headers_visible(False) self.list.addColumnAttribute(0, toggleRdr, 'activatable', ROW_UNLOADABLE) toggleRdr.connect('toggled', self.onModuleToggled) self.window.getWidget('scrolledwindow1').add(self.list) self.fillList() # GTK handlers self.window.getWidget('btn-help').connect('clicked', self.onHelp) self.window.getWidget('btn-about').connect('clicked', self.onAbout) self.list.get_selection().connect('changed', self.onSelectionChanged) self.window.getWidget('btn-close').connect( 'clicked', lambda btn: self.window.hide()) self.list.connect('row_activated', self.onRowActivated) self.prefs_button = self.window.getWidget('btn-prefs') self.prefs_button.connect('clicked', self.onPreferences)
def create_plugin_list(self): """Creates the list-view of the plugins""" self.plugin_view = self.wtree.get_object("plugin_view") self.liststore = Gtk.ListStore(bool, str, bool) self.plugin_view.set_model(self.liststore) for i in self.plugin_manager.plugin_list(): debug.dprint("PLUGIN: create_plugin_list(): plugin_list=" + str(self.plugin_manager.plugin_list())) debug.dprint( "PLUGIN: create_plugin_list(): %s , is_installed = %s" % (i.name, str(i.module.is_installed))) if not i.module.is_installed: i.enabled = False self.liststore.append([i.enabled, i.name, i.module.is_installed]) cb_column = Gtk.TreeViewColumn(_("Enable")) text_column = Gtk.TreeViewColumn(_("Plug-in")) installed_column = Gtk.TreeViewColumn(_("Installed")) cell_tg = Gtk.CellRendererToggle() cell_tx = Gtk.CellRendererText() cell_in = Gtk.CellRendererText() cb_column.pack_start(cell_tg, True) text_column.pack_start(cell_tx, True) installed_column.pack_start(cell_in, True) self.plugin_view.append_column(cb_column) self.plugin_view.append_column(text_column) self.plugin_view.append_column(installed_column) cb_column.add_attribute(cell_tg, "active", 0) text_column.add_attribute(cell_tx, "text", 1) installed_column.add_attribute(cell_in, "text", 2) cell_tg.connect("toggled", self.cb_toggled) selection = self.plugin_view.get_selection() selection.set_mode(Gtk.SelectionMode.SINGLE) selection.connect("changed", self.sel_changed) selection.select_iter(self.liststore.get_iter_first()) selection.emit("changed")
def __init__(self, vismolSession): """ Class initialiser """ Gtk.TreeView.__init__(self) self.vismolSession = vismolSession self.treeview_menu = TreeViewMenu(self) #self.store = Gtk.ListStore(bool,str , str ,str, str) self.store = vismolSession.Vismol_Objects_ListStore self.set_model(self.store) #---------------------------------------------------------------------- # the cellrenderer for the second column - boolean rendered as a toggle renderer_toggle = Gtk.CellRendererToggle() # the second column is created column_in_out = Gtk.TreeViewColumn("", renderer_toggle, active=0) # and it is appended to the treeview self.append_column(column_in_out) # connect the cellrenderertoggle with a callback function renderer_toggle.connect("toggled", self.on_toggled) # the cellrenderer for text columns renderer_text = Gtk.CellRendererText() column = Gtk.TreeViewColumn("id", renderer_text, text=1) self.append_column(column) renderer_text = Gtk.CellRendererText() column = Gtk.TreeViewColumn("Object", renderer_text, text=2) self.append_column(column) renderer_text = Gtk.CellRendererText() column = Gtk.TreeViewColumn("Atoms", renderer_text, text=3) self.append_column(column) renderer_text = Gtk.CellRendererText() column = Gtk.TreeViewColumn("Frames", renderer_text, text=4) self.append_column(column) self.connect('button-release-event', self.on_treeview_Objects_button_release_event)
def __init__(self, main_window): builder = Gtk.Builder() builder.add_from_file(os.path.join(DATA_DIR, "ui.glade")) self.component = Component(builder) self.component.zim_list_store = main_window.component.zim_list_store self.main_window = main_window main_window.component.free_space_label2 = self.component.free_space_label2 self.main_window.update_free_space() self.component.zim_tree_view.set_model(self.component.zim_list_store) renderer_radio = Gtk.CellRendererToggle() column_radio = Gtk.TreeViewColumn("Radio", renderer_radio, active=8) self.component.zim_tree_view.append_column(column_radio) renderer_radio.connect("toggled", self.renderer_radio_toggled) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Id", renderer_text, text=0) self.component.zim_tree_view.append_column(column_text) column_text = Gtk.TreeViewColumn("Name", renderer_text, text=1) self.component.zim_tree_view.append_column(column_text) column_text = Gtk.TreeViewColumn("Language", renderer_text, text=5) self.component.zim_tree_view.append_column(column_text) column_text = Gtk.TreeViewColumn("Size", renderer_text, text=4) self.component.zim_tree_view.append_column(column_text) column_text = Gtk.TreeViewColumn("Type", renderer_text, text=6) self.component.zim_tree_view.append_column(column_text) column_text = Gtk.TreeViewColumn("Description", renderer_text, text=3) self.component.zim_tree_view.append_column(column_text) self.component.zim_window.set_transient_for( main_window.component.window) self.component.zim_window.set_modal(True) self.component.zim_window.set_default_size(1280, 800) self.component.zim_window.show() self.component.zim_window_done_button.connect( "clicked", self.zim_done_button_clicked)
def new(self): self.gPodderConfigEditor.set_transient_for(self.parent_widget) name_column = Gtk.TreeViewColumn(_('Setting')) name_renderer = Gtk.CellRendererText() name_column.pack_start(name_renderer, True) name_column.add_attribute(name_renderer, 'text', 0) name_column.add_attribute(name_renderer, 'style', 5) name_column.set_expand(True) self.configeditor.append_column(name_column) value_column = Gtk.TreeViewColumn(_('Set to')) value_check_renderer = Gtk.CellRendererToggle() # align left otherwise the checkbox is very far away and not visible value_check_renderer.set_alignment(0, 0.5) value_column.pack_start(value_check_renderer, False) value_column.add_attribute(value_check_renderer, 'active', 7) value_column.add_attribute(value_check_renderer, 'visible', 6) value_column.add_attribute(value_check_renderer, 'activatable', 6) value_check_renderer.connect('toggled', self.value_toggled) value_renderer = Gtk.CellRendererText() value_column.pack_start(value_renderer, True) value_column.add_attribute(value_renderer, 'text', 2) value_column.add_attribute(value_renderer, 'visible', 4) value_column.add_attribute(value_renderer, 'editable', 4) value_column.add_attribute(value_renderer, 'style', 5) value_renderer.connect('edited', self.value_edited) value_column.set_expand(False) self.configeditor.append_column(value_column) self.model = ConfigModel(self._config) self.filter = self.model.filter_new() self.filter.set_visible_func(self.visible_func) self.configeditor.set_model(self.filter) self.configeditor.set_rules_hint(True) self._config.connect_gtk_window(self.main_window, 'config_editor', True)
def _init_iq_skills(self): arm9 = self.module.project.get_binary(BinaryName.ARM9) static_data = self.module.project.get_rom_module().get_static_data() iq_skills = HardcodedIq.get_iq_skills(arm9, static_data) if self.module.project.is_patch_applied(PATCH_IQ_SKILL_GROUPS): restrictions = IqGroupsSkills.read_compressed(arm9, static_data) else: restrictions = IqGroupsSkills.read_uncompressed(arm9, static_data) assert len(restrictions) == len(IQGroup) # Ignore invalid restrictions.pop() # noinspection PyTypeChecker store: Gtk.ListStore = Gtk.ListStore(*([str, str, str, str] + [bool] * (len(IQGroup) - 1))) # type: ignore tree: Gtk.TreeView = self.builder.get_object('tree_iq_skills') tree.set_model(store) for i, skill in enumerate(iq_skills): if i == 0: # Add columns and cell renderers for IQ groups for entry_i, entry in enumerate(IQGroup): if entry == IQGroup.INVALID: continue renderer: Gtk.CellRendererToggle = Gtk.CellRendererToggle(activatable=self.module.project.is_patch_applied(PATCH_IQ_SKILL_GROUPS)) renderer.connect('toggled', partial(self.on_cr_skill_to_group, group_id=entry_i)) column = Gtk.TreeViewColumn(title=entry.print_name, cell_renderer=renderer, active=entry_i + 4) tree.append_column(column) continue iq_group_assignments = [] for group in restrictions: iq_group_assignments.append(i in group) # noinspection PyTypeChecker store.append([ str(i), self._string_provider.get_value( StringType.IQ_SKILL_NAMES, i - 1 ), str(skill.iq_required), str(skill.restriction_group) ] + iq_group_assignments) # type: ignore
def add_columns(tree_view, df_py_dtypes, list_store): """ Add columns to a `Gtk.TreeView` for the types listed in `df_py_dtypes`. Args: tree_view (Gtk.TreeView) : Tree view to append columns to. df_py_dtypes (pandas.DataFrame) : Data frame containing type information for one or more columns in `list_store`. list_store (Gtk.ListStore) : Model data. Returns: None """ tree_view.set_model(list_store) for column_i, (i, dtype_i) in df_py_dtypes[['i', 'dtype']].iterrows(): tree_column_i = Gtk.TreeViewColumn(column_i) tree_column_i.set_name(column_i) if dtype_i in (int, int): property_name = 'text' cell_renderer_i = Gtk.CellRendererSpin() elif dtype_i == float: property_name = 'text' cell_renderer_i = Gtk.CellRendererSpin() elif dtype_i in (bool, ): property_name = 'active' cell_renderer_i = Gtk.CellRendererToggle() elif dtype_i in (str, ): property_name = 'text' cell_renderer_i = Gtk.CellRendererText() else: raise ValueError('No cell renderer for dtype: %s' % dtype_i) cell_renderer_i.set_data('column_i', i) cell_renderer_i.set_data('column', tree_column_i) tree_column_i.pack_start(cell_renderer_i, True) tree_column_i.add_attribute(cell_renderer_i, property_name, i) tree_view.append_column(tree_column_i)