def __init__(self, app):
super().__init__(app, 'key_management', "Key Management")
builder = self.get_builder()
# XXX: Keeping state is bad but we can fix this later
self._selected_keys = []
self._key_list_box = builder.get_object('lst_keys')
self._refresh_key_list()
self._keyserver_combo = builder.get_object('cmb_keyserver')
# Populate keyserver list
keyserver_list = Gtk.ListStore(str, str)
for keyserver in Config.get_keyservers():
keyserver_list.append([keyserver, keyserver])
cell = Gtk.CellRendererText()
self._keyserver_combo.pack_start(cell, True)
self._keyserver_combo.add_attribute(cell, 'text', 1)
self._keyserver_combo.set_model(keyserver_list)
self._keyserver_combo.set_id_column(0)
self._keyserver_combo.set_entry_text_column(1)
# Set default keyserver
self._keyserver_combo.set_active(0)
self._edit_key_button = builder.get_object('btn_edit')
self._upload_key_button = builder.get_object('btn_upload')
self._export_key_button = builder.get_object('btn_export')
self._delete_key_button = builder.get_object('btn_delete')
self.add(builder.get_object('main_vbox'))
self._update_button_state()
python类CellRendererText()的实例源码
def add_gpg_keys_to_combo_box(combo_box, secret=False):
gpg_keys_list = Gtk.ListStore(str, str)
for key in GpgUtils.get_gpg_keys(secret):
key_id = key[0]
key_name = key[1]
gpg_keys_list.append([key_id, key_name])
cell = Gtk.CellRendererText()
combo_box.pack_start(cell, True)
combo_box.add_attribute(cell, 'text', 1)
combo_box.set_model(gpg_keys_list)
combo_box.set_entry_text_column(1)
def create_functions_columns(self):
rendererText = Gtk.CellRendererText()
rendererText.tooltip_handle = self.connect('motion-notify-event', self.fcn_tooltip)
rendererPix = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("Function")
column.set_spacing(5)
column.pack_start(rendererPix, False)
column.pack_start(rendererText, True)
column.set_attributes(rendererText, text=1)
column.set_attributes(rendererPix, pixbuf=0)
column.set_sort_column_id(1)
self.store.set_sort_column_id(1,Gtk.SortType.ASCENDING)
self.append_column(column)
self.set_model(self.store)
def create_sections_columns(self):
rendererPix = Gtk.CellRendererPixbuf()
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Name")
column.set_spacing(5)
column.pack_start(rendererPix, False)
column.pack_start(rendererText, True)
column.set_attributes(rendererText, text=1)
column.set_attributes(rendererPix, pixbuf=0)
column.set_sort_column_id(0)
self.append_column(column)
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Virtual Address", rendererText, text=2)
self.store.set_sort_column_id(2,Gtk.SortType.ASCENDING)
column.set_sort_column_id(2)
self.append_column(column)
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Virtual Size", rendererText, text=3)
column.set_sort_column_id(3)
self.append_column(column)
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Raw Size", rendererText, text=4)
column.set_sort_column_id(4)
self.append_column(column)
self.set_model(self.store)
def create_classes_columns(self):
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Name", rendererText, text=0)
column.set_sort_column_id(0)
self.append_column(column)
def create_tree(self):
# Scrolled Window
self.sw = Gtk.ScrolledWindow()
self.sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
self.sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.store = Gtk.ListStore(str, str)
self.tree = Gtk.TreeView(self.store)
self.sw.add(self.tree)
self.tree.set_rules_hint(True)
# Connect right click popup search menu
self.popup_handler = self.tree.connect('button-press-event', self.popup_menu)
# Create the column
bblocks = Gtk.TreeViewColumn()
bblocks.set_title("Basic Blocks")
cell = Gtk.CellRendererText()
bblocks.pack_start(cell, True)
bblocks.add_attribute(cell, "text", 0)
self.treestore = Gtk.TreeStore(str)
# Add column to tree
self.tree.append_column(bblocks)
self.tree.set_model(self.treestore)
self.tree.expand_all()
def __init__(self, choices, start=None, change_handler=None):
self.model = gtk.ListStore(GObject.TYPE_STRING)
self._values = []
for label, value in choices:
self.model.append((label, ))
self._values.append(value)
renderer = gtk.CellRendererText()
self.control = gtk.ComboBox.new_with_model(self.model)
self.control.pack_start(renderer, expand=False)
self.control.add_attribute(renderer, 'text', 0)
if start is None:
self.control.set_active(0)
else:
self.set_value(start)
self.connect("changed", change_handler)
def setColumns(Treeview, Title, MWIDTH,align):
for i, column_title in enumerate(Title):
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(column_title, renderer, text=i)
column.set_sort_column_id(i)
column.set_alignment(align)
column.add_attribute(renderer, "background", len(Title))
column.set_property("min-width", MWIDTH)
Treeview.set_property("can-focus",False)
Treeview.append_column(column)
# adding Scrollbar to the Treeview
def setColumnFrameBuffer(TreeFB,Title):
for i, column_title in enumerate(Title):
FBrenderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(column_title, FBrenderer, text=i)
column.add_attribute(FBrenderer, "background", 25)
if i < len(Title) - 1:
FBrenderer.set_alignment(0.5, 0.5)
column.set_alignment(0.5)
column.set_property("min-width", 40)
TreeFB.set_property("can-focus", False)
TreeFB.append_column(column)
def setOclColumns(Treeview,Title):
for i, column_title in enumerate(Title):
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(column_title, renderer, text=i)
column.add_attribute(renderer, "background", len(Title))
if i == 1:
column.add_attribute(renderer, "foreground", len(Title) + 1)
column.set_property("min-width", Const.MWIDTH)
Treeview.set_property("can-focus", False)
Treeview.append_column(column)
def _build_widgets(self):
"""Generate the headerbar."""
header_bar = self._builder.get_object("headerbar")
title = _("Comparing commits of {0}").format(
self._git.get_project_name())
header_bar.set_title(title)
self._stats = self._builder.get_object("stats")
# Build list of modified files
self._source = self._builder.get_object("source")
files = self._git.get_modified()
files.sort()
liststore = Gtk.ListStore(str)
for filename in files:
liststore.append([filename])
combobox = self._builder.get_object("files")
combobox.set_model(liststore)
renderer_text = Gtk.CellRendererText()
combobox.pack_start(renderer_text, True)
combobox.add_attribute(renderer_text, "text", 0)
combobox.set_active(0)
# Load the buffer of the first file on the list
self._set_buffer(files[0])
def __init__(self):
builder = Gtk.Builder()
builder.add_from_file("layout.glade")
builder.connect_signals(self)
window = builder.get_object("BrowserWindow")
window.set_default_size(900, 675)
self.url_bar = builder.get_object("UrlBar")
self.refresh_button = builder.get_object("Refresh")
self.history_forward = builder.get_object("HistoryForward")
self.history_backward = builder.get_object("HistoryBackward")
# create popup menu for browser tabs
self.tab_menu = TabContextMenu(self)
self.uni_menu = UniverseContextMenu(self)
# tabs tracks the open BrowserTab objects
self.tabs = {}
self.focused = None
self.tab_store = builder.get_object("TabTreeStore")
self.tab_tree_view = builder.get_object("TabTreeView")
self.tab_tree_view.set_activate_on_single_click(True)
# stores a list of tab ID's, in order of call
self.focus_history = []
# setup the treeview's renderer
renderer = Gtk.CellRendererText()
renderer.set_property("ellipsize", 3)
self.title_column = Gtk.TreeViewColumn("Tab Title", renderer, text=0)
self.tab_tree_view.append_column(self.title_column)
self.tab_tree_view.connect("row_activated", self.tree_activates_tab)
# self.views tracks all of the sockets
self.views = builder.get_object("ViewPorts")
window.show_all()
# create a new tab
self.new_tab("http://duckduckgo.com")
def __init__(self):
Gtk.TreeView.__init__(self)
self.task_store = Gtk.TreeStore(str, str)
self.set_model(self.task_store)
column = Gtk.TreeViewColumn(_('Tasks'), Gtk.CellRendererText(), text=0)
self.append_column(column)
self.connect('notify::tasks', self.tasks_changed)
def build_data_stores(self):
"""Build stores for GUI dataviews"""
self.store = dict()
# custom icons
self.ied = {'Name': 0, 'State': 1}
self.store['custom_icons'] = Gtk.ListStore(str, bool)
self.store['custom_icons'].append(["Simple Icon Group", False])
renderer_toggle = Gtk.CellRendererToggle()
renderer_toggle.connect("toggled", self.on_custom_icon_toggled)
self.gui['custom_icons_treeview'].append_column(Gtk.TreeViewColumn("Name", Gtk.CellRendererText(), text=0))
self.gui['custom_icons_treeview'].append_column(Gtk.TreeViewColumn("State", renderer_toggle, active=1))
self.gui['custom_icons_treeview'].set_model(self.store['custom_icons'])
# color list
self.ced = {'Color': 0, 'Alpha': 1, 'Offset': 2, 'RGBA': 3}
colorstore_visible_keys = [k for k in self.ced.keys() if k != 'RGBA']
self.store['colorlist'] = Gtk.ListStore(str, float, int, str)
for key in sorted(colorstore_visible_keys, key=lambda k: self.ced[k]):
self.gui['colorlist_treeview'].append_column(
Gtk.TreeViewColumn(key, Gtk.CellRendererText(), text=self.ced[key])
)
self.gui['colorlist_treeview'].set_model(self.store['colorlist'])
# gradient direction
self.ded = {'Coord': 0, 'Value': 1}
self.store['direction'] = Gtk.ListStore(str, int)
self.gui['renderer_spin'] = Gtk.CellRendererSpin(editable=True, adjustment=Gtk.Adjustment(0, 0, 100, 5, 0, 0))
self.signals['direction_edited'] = self.gui['renderer_spin'].connect("edited", self.on_direction_edited)
self.gui['direction_treeview'].append_column(Gtk.TreeViewColumn("Coord", Gtk.CellRendererText(), text=0))
self.gui['direction_treeview'].append_column(Gtk.TreeViewColumn("Value", self.gui['renderer_spin'], text=1))
self.gui['direction_treeview'].set_model(self.store['direction'])
def __fill_listbox(self):
self._list_store.clear()
connections = self._manager.get_connections()
for connection in connections:
self._list_store.append([connection.label])
renderer = Gtk.CellRendererText()
column = self._listbox.get_column(0)
if not column:
column = Gtk.TreeViewColumn(None, renderer, text=0)
self._listbox.append_column(column)
self._listbox.show_all()
# noinspection PyUnusedLocal
def run_query(self, query):
try:
for column in self.query_tree.get_columns():
self.query_tree.remove_column(column)
cursor = self.conn.cursor()
cursor.execute(query)
self.conn.commit()
self.query_info.set_text(cursor.statusmessage)
if not cursor.description:
return
columns = []
# TODO get rid of manual incrementing
i = 0
for description in cursor.description:
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(description.name.replace('_', '__'), renderer, text=i)
column.set_resizable(True)
i += 1
self.query_tree.append_column(column)
columns.append(str)
store = Gtk.ListStore(*columns)
for row in cursor.fetchall():
store.append([str(i) for i in row])
self.query_tree.set_model(store)
except DatabaseError as e:
Alert(e.message, self.query_tree.get_toplevel())
self.conn.rollback()
self.query_tree.show_all()
def refresh_schema(self):
cursor = self.conn.cursor()
cursor.execute('SELECT * FROM %s LIMIT 1' % self.table)
for column in self.data_tree.get_columns():
self.data_tree.remove_column(column)
self.columns = []
# TODO get rid of manual incrementing
i = 0
for description in cursor.description:
s = None
if description.type_code == 16:
renderer = Gtk.CellRendererToggle()
self.columns.append(bool)
column = Gtk.TreeViewColumn(description.name.replace('_', '__'), renderer, active=i)
else:
renderer = Gtk.CellRendererText()
renderer.set_property('editable', True)
renderer.connect('edited', self.on_text_edit, i)
renderer.set_property('placeholder-text', 'Null')
renderer.set_property('ellipsize', Pango.EllipsizeMode.END)
self.columns.append(str)
column = Gtk.TreeViewColumn(description.name.replace('_', '__'), renderer, text=i)
column.set_clickable(True)
column.set_resizable(True)
column.set_fixed_width(100)
if i == 0:
# TODO Should this be here?
self.order = description.name
column.set_sort_indicator(True)
column.set_sort_order(1)
self.last_selected_column = column
column.connect('clicked', self.on_column_click, description.name)
self.data_tree.append_column(column)
i += 1
self.store = Gtk.ListStore(*self.columns)
self.data_tree.set_model(self.store)
def __init__(self, keyfile, settings, key, options, valtype="string"):
self.key = key
self.keyfile = keyfile
try:
self.value = keyfile.get_string(GROUP_NAME, key)
except:
self.value = settings.get_string(key)
Gtk.ComboBox.__init__(self)
renderer_text = Gtk.CellRendererText()
self.pack_start(renderer_text, True)
self.add_attribute(renderer_text, "text", 1)
self.set_valign(Gtk.Align.CENTER)
# assume all keys are the same type (mixing types is going to cause an error somewhere)
var_type = type(options[0][0])
self.model = Gtk.ListStore(var_type, str)
self.valtype = valtype
self.option_map = {}
for option in options:
self.option_map[option[0]] = self.model.append([option[0], option[1]])
self.set_model(self.model)
self.set_id_column(0)
if self.value in self.option_map.keys():
self.set_active_iter(self.option_map[self.value])
self.connect("changed", self.on_changed)
def __init__(self, header, cache, pkgnames, icons, icon_size, db):
super(PackageNamesView, self).__init__()
model = Gtk.ListStore(GdkPixbuf.Pixbuf, str)
self.set_model(model)
tp = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("Icon", tp, pixbuf=self.COL_ICON)
self.append_column(column)
tr = Gtk.CellRendererText()
tr.set_property("ellipsize", Pango.EllipsizeMode.END)
column = Gtk.TreeViewColumn(header, tr, markup=self.COL_TEXT)
self.append_column(column)
for pkgname in sorted(pkgnames):
if (not pkgname in cache or
not cache[pkgname].installed):
continue
s = "%s \n<small>%s</small>" % (
cache[pkgname].installed.summary.capitalize(), pkgname)
app_details = Application("", pkgname).get_details(db)
proposed_icon = app_details.icon
if not proposed_icon or not icons.has_icon(proposed_icon):
proposed_icon = Icons.MISSING_APP
if icons.has_icon(proposed_icon):
icon = icons.load_icon(proposed_icon, icon_size, 0)
pb = icon.scale_simple(
icon_size, icon_size, GdkPixbuf.InterpType.BILINEAR)
else:
LOG.warn("cant set icon for '%s' " % pkgname)
pb = icons.load_icon(Icons.MISSING_APP,
icon_size,
Gtk.IconLookupFlags.GENERIC_FALLBACK)
pb = pb.scale_simple(icon_size,
icon_size, GdkPixbuf.InterpType.BILINEAR)
model.append([pb, s])
# finally, we don't allow selection, it's just a simple display list
tree_selection = self.get_selection()
tree_selection.set_mode(Gtk.SelectionMode.NONE)
def __init__(self, icons, layout, show_ratings, overlay_icon_name):
Gtk.CellRendererText.__init__(self)
# the icon pixbuf to be displayed in the row
self.icon = None
# geometry-state values
self.pixbuf_width = 0
self.apptitle_width = 0
self.apptitle_height = 0
self.normal_height = 0
self.selected_height = 0
self.show_ratings = show_ratings
# button packing
self.button_spacing = 0
self._buttons = {
Gtk.PackType.START: [],
Gtk.PackType.END: []
}
self._all_buttons = {}
# cache a layout
self._layout = layout
# star painter, paints stars
self._stars = StarRenderer()
self._stars.size = StarSize.SMALL
# icon/overlay jazz
try:
self._installed = icons.load_icon(overlay_icon_name,
self.OVERLAY_SIZE, 0)
except GObject.GError:
# icon not present in theme, probably because running uninstalled
self._installed = icons.load_icon('emblem-system',
self.OVERLAY_SIZE, 0)