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)
