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类ListStore()的实例源码
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 __init_cmb_visualiser(self):
store = Gtk.ListStore(str)
for x in self.player.streamer.Visualizers:
store.append([x])
self.cmb_visualiser.set_model(store)
def create_store():
model = Gtk.ListStore(str, str, str, str, str, str, str, str, str, str)
model.set_default_sort_func(lambda *unused: 0)
model.set_sort_column_id(Gtk.TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, Gtk.SortType.ASCENDING)
return model
def create_store():
model = Gtk.ListStore(str, str, str, str)
model.set_default_sort_func(lambda *unused: 0)
model.set_sort_column_id(
Gtk.TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, Gtk.SortType.ASCENDING)
return model
def __init__(self, core):
self.store = Gtk.ListStore(str, str, str, str, str, str, str, str)
super(InfoTree,self).__init__(self.store)
self.uicore = core
self.set_rules_hint(True)
self.show_all()
def set_completion(self):
# Seek entry EntryCompletion
self.completion = Gtk.EntryCompletion()
self.liststore = Gtk.ListStore(str)
# Add function names to the list
for function in self.uicore.allfuncs:
self.liststore.append([function])
self.completion.set_model(self.liststore)
self.seek.set_completion(self.completion)
self.completion.set_text_column(0)
def populate_treeview(self, rows):
""" Accepts an array of n rows made of 2 elements each, and returns a ListView."""
store = Gtk.ListStore(str, str)
for row in rows:
store.append([row[0], row[1]])
tv = Gtk.TreeView(store)
tv.set_rules_hint(True)
return tv
def __init__(self, core, textviews):
self.store = Gtk.ListStore(GdkPixbuf.Pixbuf, str, str, str, str)
super(SectionsTreeView ,self).__init__(self.store)
self.uicore = core
self.textviews = textviews
self.set_rules_hint(True)
self.set_has_tooltip(True)
self.create_sections_columns()
# Connect right click popup search menu
self.popup_handler = self.connect('row-activated', self.popup_menu)
def __init__(self, core, textviews):
self.uicore = core
self.textviews = textviews
self.store = Gtk.ListStore(str, str, str)
self.create_classes_columns()
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 _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 load_combo(self):
# Gateway combo
model = Gtk.ListStore(str, str) #id, name
selected_iter = None
# load list of gateways
gateway_info = []
try:
with open('/usr/share/pia-manager/gateways.list.dynamic') as fp:
gateway_info = fp.readlines()
except IOError:
with open('/usr/share/pia-manager/gateways.list') as fp:
gateway_info = fp.readlines()
for line in gateway_info:
line = line.strip()
if not line.startswith("#"):
bits = line.split()
if len(bits) >= 2:
gateway_id = bits[0]
gateway_name = " ".join(bits[1:])
iter = model.append([gateway_id, gateway_name])
if gateway_id == self.gateway_value:
selected_iter = iter
self.gateway.set_model(model)
if selected_iter is not None:
self.gateway.set_active_iter(selected_iter)
def set_up_completion(self):
completion = self.gtk_completion = Gtk.EntryCompletion()
self.completion_choices = Gtk.ListStore(str)
self.completion_choices_as_set = set()
completion.set_model(self.completion_choices)
completion.set_text_column(0)
if self.gtk_completion_enabled:
self.set_completion(completion)
def __init__(self, config):
self.config = config
self.bhandlers = dict()
# Create objects for alternative and prewiew
self.alternatives = Prospector(config.get("Directories", "alternatives"))
# Read icon size settins from config
self.VIEW_ICON_SIZE = int(config.get("PreviewSize", "group"))
# Load GUI
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(acyls.dirs['gui'], "alternatives.glade"))
gui_elements = (
'alternatives_grid', 'alt_theme_combo', 'alt_group_combo', 'alt_icon_view',
)
self.gui = {element: self.builder.get_object(element) for element in gui_elements}
# Mainpage buttnons hanlers
self.mhandlers = dict()
self.mhandlers['apply_button'] = self.on_apply_click
# Build store
self.store = Gtk.ListStore(Pixbuf)
self.gui['alt_icon_view'].set_model(self.store)
self.gui['alt_icon_view'].set_pixbuf_column(0)
self.iconview_lock = TreeViewHolder(self.gui['alt_icon_view'])
# Fill up GUI
for name in self.alternatives.structure[0]['directories']:
self.gui['alt_group_combo'].append_text(name.capitalize())
# connect signals
self.gui['alt_group_combo'].connect("changed", self.on_alt_group_combo_changed)
self.gui['alt_theme_combo'].connect("changed", self.on_alt_theme_combo_changed)
# setup
self.gui['alt_group_combo'].set_active(0)
# GUI handlers
def __init__(self, config):
self.bhandlers = dict()
self.mhandlers = dict()
# Create object for iconview
self.iconview = Prospector(config.get("Directories", "real"))
# Read icon size settins from config
self.VIEW_ICON_SIZE = int(config.get("PreviewSize", "group"))
# Load GUI
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(acyls.dirs['gui'], "viewer.glade"))
gui_elements = (
'iconview_grid', 'iconview_combo', 'icons_view',
)
self.gui = {element: self.builder.get_object(element) for element in gui_elements}
# Build store
self.store = Gtk.ListStore(Pixbuf)
self.gui['icons_view'].set_model(self.store)
self.gui['icons_view'].set_pixbuf_column(0)
self.iconview_lock = TreeViewHolder(self.gui['icons_view'])
# Fill up GUI
for name in self.iconview.structure[0]['directories']:
self.gui['iconview_combo'].append_text(name.capitalize())
# connect signals
self.gui['iconview_combo'].connect("changed", self.on_iconview_combo_changed)
# setup
self.gui['iconview_combo'].set_active(0)
# GUI handlers
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 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)
