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'])
python类TreeViewColumn()的实例源码
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 __row_activated(self, target: Gtk.TreeView, path: Gtk.TreePath, column: Gtk.TreeViewColumn):
i = path.get_indices()[0]
connection = self._manager.get_connection(i)
self.__command_ssh.run(connection, connection.args)
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, 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 _build_tree_view(self, model):
for i, name in enumerate(self._COLUMN_NAMES):
renderer = Gtk.CellRendererText()
renderer.set_property("wrap-width", 200)
column = Gtk.TreeViewColumn(name, renderer, markup=i)
self.append_column(column)
self.set_model(model)
return
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 _build_tree_view(self, model):
for i, name in enumerate(self._COLUMN_NAMES):
renderer = Gtk.CellRendererText()
renderer.set_property("wrap-width", 200)
column = Gtk.TreeViewColumn(name, renderer, markup=i)
self.append_column(column)
self.set_model(model)
return
def init_bank_list_widget(self):
self.bank_list_widget = self.gtk_builder.get_object('bank-list-trv')
if self.bank_list_widget:
self.bank_list_model = Gtk.ListStore(int, str, str, str)
self.bank_list_widget.set_model(self.bank_list_model)
# Note: column 0 contains program number but is not rendered
column_loc = Gtk.TreeViewColumn('Loc.',
Gtk.CellRendererText(),
text=1)
self.bank_list_widget.append_column(column_loc)
column_changed = Gtk.TreeViewColumn('*',
Gtk.CellRendererText(),
text=2)
self.bank_list_widget.append_column(column_changed)
cell_name = Gtk.CellRendererText()
cell_name.set_property('editable', True)
column_name = Gtk.TreeViewColumn('Bank Name', cell_name, text=3)
self.bank_list_widget.append_column(column_name)
cell_name.connect('edited', self.on_prog_name_edited)
self.bank_list_widget.connect('cursor_changed',
self.select_program_from_ui)
self.bank_list_widget.connect('button_press_event',
self.popup_context_menu)
else:
self.bank_list_model = None
print('Could not find widget for bank list')
def __init__(self):
Gtk.Window.__init__(self, title='My Window Title')
self.connect('delete-event', Gtk.main_quit)
# Gtk.ListStore will hold data for the TreeView
# Only the first two columns will be displayed
# The third one is for sorting file sizes as numbers
store = Gtk.ListStore(str, str, long)
# Get the data - see below
self.populate_store(store)
treeview = Gtk.TreeView(model=store)
# The first TreeView column displays the data from
# the first ListStore column (text=0), which contains
# file names
renderer_1 = Gtk.CellRendererText()
column_1 = Gtk.TreeViewColumn('File Name', renderer_1, text=0)
# Calling set_sort_column_id makes the treeViewColumn sortable
# by clicking on its header. The column is sorted by
# the ListStore column index passed to it
# (in this case 0 - the first ListStore column)
column_1.set_sort_column_id(0)
treeview.append_column(column_1)
# xalign=1 right-aligns the file sizes in the second column
renderer_2 = Gtk.CellRendererText(xalign=1)
# text=1 pulls the data from the second ListStore column
# which contains filesizes in bytes formatted as strings
# with thousand separators
column_2 = Gtk.TreeViewColumn('Size in bytes', renderer_2, text=1)
# Mak the Treeview column sortable by the third ListStore column
# which contains the actual file sizes
column_2.set_sort_column_id(2)
treeview.append_column(column_2)
# Use ScrolledWindow to make the TreeView scrollable
# Otherwise the TreeView would expand to show all items
# Only allow vertical scrollbar
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(
Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scrolled_window.add(treeview)
scrolled_window.set_min_content_height(200)
self.add(scrolled_window)
self.show_all()
def __init__(self):
glade_dir = gv.jcchess.get_glade_dir()
self.glade_file = os.path.join(glade_dir, "move_list.glade")
Move_List.move_list_ref = self
self.comments = comments.get_ref()
self.saved_move_list = []
# create move list window
self.builder = Gtk.Builder()
self.builder.set_translation_domain(gv.domain)
self.builder.add_from_file(self.glade_file)
self.builder.connect_signals(self)
self.window = self.builder.get_object("move_list_window")
self.vbox = self.builder.get_object("vbox1") #man
self.treeview = Gtk.TreeView() #man
self.liststore = self.builder.get_object("liststore1")
self.scrolled_window = Gtk.ScrolledWindow()
#self.scrolled_window.set_size_request(150,300)
self.treeview.set_model(self.liststore)
self.scrolled_window.add(self.treeview)
self.vbox.add(self.scrolled_window)
self.comments_button = self.builder.get_object("comments_button")
#self.builder.connect("button_press_event",self.comments_button_clicked_cb)
cell0 = Gtk.CellRendererText()
# cell0.set_property("cell-background", Gdk.color_parse("#F8F8FF"))
tvcolumn0 = Gtk.TreeViewColumn("#")
self.treeview.append_column(tvcolumn0)
tvcolumn0.pack_start(cell0, True)
tvcolumn0.set_min_width(50)
tvcolumn0.set_attributes(cell0, text=0)
cell1 = Gtk.CellRendererText()
# cell1.set_property("cell-background", Gdk.color_parse("#F8F8FF"))
tvcolumn1 = Gtk.TreeViewColumn(_("Move"))
self.treeview.append_column(tvcolumn1)
tvcolumn1.pack_start(cell1, True)
tvcolumn1.set_min_width(100)
tvcolumn1.set_attributes(cell1, text=1)
cell2 = Gtk.CellRendererText()
# cell1.set_property("cell-background", Gdk.color_parse("#F8F8FF"))
tvcolumn2 = Gtk.TreeViewColumn(_("Cmt"))
self.treeview.append_column(tvcolumn2)
tvcolumn2.pack_start(cell2, True)
tvcolumn2.set_min_width(20)
tvcolumn2.set_attributes(cell2, text=2)
self.tree_selection = self.treeview.get_selection()
self.treeview.connect("button_press_event", self.treeview_button_press)
self.treeview.connect("key_press_event", self.treeview_key_press)
self.update()
# user has closed the window
# just hide it
def __init__(self, parent):
Gtk.Dialog.__init__(self, "Alarms", parent, 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self._store = Gtk.ListStore(str, str, str, object)
for i, alarm in enumerate(config['alarms']):
row = self._build_row(alarm)
self._store.append(row)
self._tree = Gtk.TreeView(self._store)
self._selection = self._tree.get_selection()
self._selection.connect("changed", self._on_tree_selection_changed)
self._tree.set_size_request(300, 150)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Exchange", renderer, text=self._EXCHANGE_COL)
self._tree.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Market", renderer, text=self._MARKET_COL)
self._tree.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Alarm Trigger", renderer, text=self._TRIGGER_COL)
self._tree.append_column(column)
vbox = Gtk.Box(spacing=6, orientation=Gtk.Orientation.VERTICAL)
new_button = Gtk.Button.new_with_label("New Alarm")
new_button.connect("clicked", self._on_new_button_clicked)
vbox.pack_start(new_button, False, False, 0)
self._remove_button = Gtk.Button.new_with_label("Remove Alarm")
self._remove_button.connect("clicked", self._on_remove_button_clicked)
vbox.pack_start(self._remove_button, False, False, 0)
self._market_combo, self._market_store = self._create_market_combo()
self._market_combo.connect("changed", self._on_market_changed)
vbox.pack_start(self._market_combo, False, False, 0)
self._above_radio = Gtk.RadioButton.new_with_label_from_widget(None, "Above")
self._above_radio.connect("clicked", self._on_type_radio_clicked)
self._below_radio = Gtk.RadioButton.new_with_label_from_widget(self._above_radio, "Below")
self._below_radio.connect("clicked", self._on_type_radio_clicked)
type_hbox = Gtk.Box(spacing=6, orientation=Gtk.Orientation.HORIZONTAL)
type_hbox.pack_start(self._above_radio, True, True, 0)
type_hbox.pack_start(self._below_radio, True, True, 0)
vbox.pack_start(type_hbox, False, False, 0)
self._price_entry = Gtk.Entry()
self._price_entry.connect("changed", self._on_price_changed)
_add_label_and_widget(vbox, "Price:", self._price_entry)
hbox = Gtk.Box(spacing=6)
hbox.pack_start(self._tree, True, True, 0)
hbox.pack_start(vbox, False, False, 0)
self.get_content_area().add(hbox)
self._set_inputs_sensitive(False)
self.show_all()
def __init__(self):
Gtk.Window.__init__(self)
self.set_title("Dependency Explorer")
self.set_default_size(500, 500)
self.connect("delete-event", Gtk.main_quit)
# Create the data models
self.pkg_model = Gtk.ListStore(GObject.TYPE_STRING)
self.pkg_model.set_sort_column_id(COL_PKG_NAME, Gtk.SortType.ASCENDING)
self.depends_model = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_STRING, GObject.TYPE_STRING)
self.depends_model.set_sort_column_id(COL_DEP_PACKAGE, Gtk.SortType.ASCENDING)
pane = Gtk.HPaned()
pane.set_position(250)
self.add(pane)
# The master list of packages
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.pkg_treeview = Gtk.TreeView(self.pkg_model)
self.pkg_treeview.get_selection().connect("changed", self.on_cursor_changed)
column = Gtk.TreeViewColumn("Package", Gtk.CellRendererText(), text=COL_PKG_NAME)
self.pkg_treeview.append_column(column)
pane.add1(scrolled)
scrolled.add(self.pkg_treeview)
box = Gtk.VBox(homogeneous=True, spacing=4)
# Runtime Depends
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.rdep_treeview = PackageDepView(self.depends_model, TYPE_RDEP, "Runtime Depends")
self.rdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
scrolled.add(self.rdep_treeview)
box.add(scrolled)
# Build Depends
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.dep_treeview = PackageDepView(self.depends_model, TYPE_DEP, "Build Depends")
self.dep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
scrolled.add(self.dep_treeview)
box.add(scrolled)
pane.add2(box)
# Reverse Depends
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.revdep_treeview = PackageReverseDepView(self.depends_model, "Reverse Depends")
self.revdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PARENT)
scrolled.add(self.revdep_treeview)
box.add(scrolled)
pane.add2(box)
self.show_all()
def __init__(self):
Gtk.Window.__init__(self, title="EFI boot manager")
self.set_border_width(10)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
self.add(vbox)
self.store = EFIStore(self)
self.tree = Gtk.TreeView(self.store, vexpand=True)
vbox.add(self.tree)
renderer_text = Gtk.CellRendererText()
renderer_check = Gtk.CellRendererToggle(radio=False)
renderer_radio = Gtk.CellRendererToggle(radio=True)
renderer_check.connect("toggled", self.store.change_active)
renderer_radio.connect("toggled", self.store.change_boot_next)
self.tree.append_column(Gtk.TreeViewColumn("BootNum", renderer_text, text=0))
self.tree.append_column(Gtk.TreeViewColumn("Name", renderer_text, text=1))
self.tree.append_column(Gtk.TreeViewColumn("Loader", renderer_text, text=2))
self.tree.append_column(Gtk.TreeViewColumn("Active", renderer_check, active=3))
self.tree.append_column(Gtk.TreeViewColumn("NextBoot", renderer_radio, active=4))
for column in self.tree.get_columns():
column.set_resizable(True)
column.set_min_width(75)
hb = Gtk.HeaderBar()
hb.set_show_close_button(True)
hb.props.title = "EFI boot manager"
self.set_titlebar(hb)
clear_btn = btn_with_icon("edit-clear-all-symbolic")
clear_btn.connect("button-press-event", self.discard_changes)
hb.pack_end(clear_btn)
write_btn = btn_with_icon("document-save-symbolic")
write_btn.connect("button-press-event", self.apply_changes)
hb.pack_end(write_btn)
hbox = Gtk.HButtonBox()
hbox.set_layout(Gtk.ButtonBoxStyle.EXPAND)
vbox.add(hbox)
up = btn_with_icon("go-up-symbolic")
down = btn_with_icon("go-down-symbolic")
new = btn_with_icon("list-add-symbolic")
delete = btn_with_icon("list-remove-symbolic")
hbox.add(up)
hbox.add(down)
hbox.add(new)
hbox.add(delete)
up.connect("button-press-event", self.up)
down.connect("button-press-event", self.down)
new.connect("button-press-event", self.new)
delete.connect("button-press-event", self.delete)
self.connect("delete-event", self.quit)
self.set_default_size(300, 260)
def __init__(self):
Gtk.Dialog.__init__(self, _("GNU Solfege Preferences"),
solfege.win, 0,
(Gtk.STOCK_HELP, Gtk.ResponseType.HELP, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE))
cfg.ConfigUtils.__init__(self, 'configwindow')
self.connect('response', self.apply_and_close)
# We do this so that the window is only hidden when the
# user click on the close button provided by the window manager.
self.connect('delete-event', self.on_destroy)#lambda w, e: True)
hbox = Gtk.HBox()
hbox.set_spacing(gu.hig.SPACE_LARGE)
hbox.set_border_width(gu.hig.SPACE_SMALL)
self.vbox.pack_start(hbox, True, True, 0)
frame = Gtk.Frame()
self.g_pages = Gtk.TreeStore(str)
self.g_pview = Gtk.TreeView(self.g_pages)
self.g_pview.set_headers_visible(False)
hbox.pack_start(frame, False, False, 0)
frame.add(self.g_pview)
self.g_page_box = Gtk.HBox()
hbox.pack_start(self.g_page_box, True, True, 0)
self.m_page_mapping = {}
def cursor_changed(treeview):
path, col = treeview.get_cursor()
if not path:
return
path = tuple(path)
for key, page in self.m_page_mapping.items():
if key == path:
page.show()
else:
page.hide()
self.m_page_mapping[path].show_all()
tvcol = Gtk.TreeViewColumn("Col 0")
self.g_pview.append_column(tvcol)
cell = Gtk.CellRendererText()
tvcol.pack_start(cell, True)
tvcol.add_attribute(cell, 'text', 0)
hbox.show_all()
self.create_midi_config()
self.create_user_config()
self.create_external_programs_config()
self.create_gui_config()
self.create_practise_config()
self.create_sound_config()
self.create_statistics_config()
self.g_pview.connect('cursor-changed', cursor_changed)
def create_idtone_accels_config(self, parent):
it, page_vbox = self.new_page_box(parent, _("Identify tone keyboard accelerators"))
self.g_idtone_accels = Gtk.ListStore(GObject.TYPE_STRING,
GObject.TYPE_STRING)
notenames = ('c', 'cis', 'd', 'dis', 'e', 'f', 'fis',
'g', 'gis', 'a', 'ais', 'b')
for notename in notenames:
self.g_idtone_accels.append((
solfege.mpd.MusicalPitch.new_from_notename(notename).get_user_notename(),
cfg.get_string('idtone/tone_%s_ak' % notename)))
self.g_treeview = Gtk.TreeView(self.g_idtone_accels)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Note name"), renderer, text=0)
self.g_treeview.append_column(column)
renderer = Gtk.CellRendererAccel()
renderer.set_property('editable', True)
def acc_ff(renderer, path, accel_key, accel_mods, hw_key):
is_unique = True
for notename in notenames:
if (notename != notenames[int(path)]
and cfg.get_string('idtone/tone_%s_ak' % notename) == unichr(accel_key)):
is_unique = False
break
if not is_unique:
gu.dialog_ok(_(u"The accelerator in use for the tone “%s”. You have to choose another key.") % solfege.mpd.MusicalPitch.new_from_notename(notename).get_user_notename(), parent=self, msgtype=Gtk.MessageType.ERROR)
return
it = self.g_idtone_accels.get_iter(path)
cfg.set_string('idtone/tone_%s_ak' % notenames[int(path)], unichr(accel_key))
self.g_idtone_accels.set(it, 1, unichr(accel_key))
return True
renderer.connect('accel-edited', acc_ff)
column = Gtk.TreeViewColumn(_i("keyboard|Key"), renderer, text=1)
self.g_treeview.append_column(column)
page_vbox.pack_start(self.g_treeview, True, True, 0)
layouts = {'ascii': (_('ASCII'), u'awsedfujikol'),
'dvorak': (_('Dvorak'), u'a,o.eughctrn'),
}
hbox = Gtk.HBox()
page_vbox.pack_start(hbox, False, False, 0)
def set_buttons(widget, layout):
v = layouts[layout][1]
idx = 0
it = self.g_idtone_accels.get_iter_first()
while True:
self.g_idtone_accels.set_value(it, 1, v[idx])
cfg.set_string('idtone/tone_%s_ak' % notenames[idx], v[idx])
it = self.g_idtone_accels.iter_next(it)
idx += 1
if not it:
break
for key in layouts:
btn = Gtk.Button(layouts[key][0])
btn.connect('clicked', set_buttons, key)
hbox.pack_start(btn, True, True, 0)
def create_interval_accels_config(self, parent):
it, page_vbox = self.new_page_box(parent, _("Interval keyboard accelerators"))
self.g_interval_accels = Gtk.ListStore(GObject.TYPE_STRING,
GObject.TYPE_STRING)
intervals = ['minor2', 'major2', 'minor3', 'major3',
'perfect4', 'diminished5', 'perfect5', 'minor6',
'major6', 'minor7', 'major7', 'perfect8',
'minor9', 'major9', 'minor10', 'major10']
for interval in intervals:
self.g_interval_accels.append((
mpd.Interval.new_from_int(intervals.index(interval)).get_name(),
cfg.get_string('interval_input/%s' % interval)))
self.g_intervals_treeview = Gtk.TreeView(self.g_interval_accels)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Interval"), renderer, text=0)
self.g_intervals_treeview.append_column(column)
renderer = Gtk.CellRendererAccel()
renderer.set_property('editable', True)
def acc_ff(renderer, path, accel_key, accel_mods, hw_key):
is_unique = True
for interval in intervals:
if (interval != intervals[int(path)]
and cfg.get_string('interval_input/%s' % interval) == unichr(accel_key)):
is_unique = False
break
if not is_unique:
gu.dialog_ok(_(u"The accelerator in use for “%s”. You have to choose another key.") % mpd.Interval.new_from_int(intervals.index(interval)).get_name(), parent=self, msgtype=Gtk.MessageType.ERROR)
return
it = self.g_interval_accels.get_iter(path)
cfg.set_string('interval_input/%s' % intervals[int(path)], unichr(accel_key))
self.g_interval_accels.set(it, 1, unichr(accel_key))
return True
renderer.connect('accel-edited', acc_ff)
column = Gtk.TreeViewColumn(_i("keyboard|Key"), renderer, text=1)
self.g_intervals_treeview.append_column(column)
page_vbox.pack_start(self.g_intervals_treeview, True, True, 0)
hbox = Gtk.HBox()
page_vbox.pack_start(hbox, False, False, 0)
layouts = {'ascii': (_('ASCII'), u'1qaz2wsx3edc4rfv'),
'dvorak': (_('Dvorak'), u"1'a;2,oq3.ej4puk"),
}
def set_buttons(widget, layout):
v = layouts[layout][1]
idx = 0
it = self.g_interval_accels.get_iter_first()
while True:
self.g_interval_accels.set_value(it, 1, v[idx])
cfg.set_string('interval_input/%s' % intervals[idx], v[idx])
it = self.g_interval_accels.iter_next(it)
idx += 1
if not it:
break
for key in layouts:
btn = Gtk.Button(layouts[key][0])
btn.connect('clicked', set_buttons, key)
hbox.pack_start(btn, True, True, 0)
def __init__(self, default_profile):
Gtk.Dialog.__init__(self, _("GNU Solfege - Choose User Profile"))
# We save the initially selected profile, because we need to keep
# track of it if the user renames it and then presses cancel.
self.m_default_profile = default_profile
vbox = gu.hig_dlg_vbox()
self.vbox.pack_start(vbox, False, False, 0)
l = Gtk.Label(_("Solfege will save your statistics and test results in the user profile. By adding additional user profiles to Solfege, multiple users can share a user account on the operating system."))
l.set_alignment(0.0, 0.5)
l.set_line_wrap(True)
vbox.pack_start(l, True, True, 0)
hbox = Gtk.HBox()
hbox.set_spacing(gu.hig.SPACE_MEDIUM)
vbox.pack_start(hbox, True, True, 0)
button_box = Gtk.VBox()
self.g_create_profile = Gtk.Button.new_with_mnemonic(_(u"_Create profile\u2026"))
self.g_create_profile.connect('clicked', self.on_create_profile)
button_box.pack_start(self.g_create_profile, False, False, 0)
self.g_rename_profile = Gtk.Button.new_with_mnemonic(_(u"_Rename profile\u2026"))
self.g_rename_profile.connect('clicked', self.on_rename_profile)
button_box.pack_start(self.g_rename_profile, False, False, 0)
self.g_delete_profile = Gtk.Button.new_with_mnemonic(_(u"_Delete profile\u2026"))
self.g_delete_profile.connect('clicked', self.on_delete_profile)
button_box.pack_start(self.g_delete_profile, False, False, 0)
hbox.pack_start(button_box, False, False, 0)
self.g_liststore = liststore = Gtk.ListStore(GObject.TYPE_STRING)
liststore.append((_("Standard profile"),))
if os.path.exists(os.path.join(filesystem.app_data(), 'profiles')):
for subdir in os.listdir(os.path.join(filesystem.app_data(),
'profiles')):
liststore.append((subdir,))
#
self.g_tw = tw = Gtk.TreeView(liststore)
tw.connect('row-activated', lambda a, b, c: self.response(Gtk.ResponseType.ACCEPT))
tw.set_headers_visible(False)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(None, renderer, text=0)
tw.append_column(column)
hbox.pack_start(tw, False, False, 0)
tw.show()
tw.connect('cursor-changed', self.on_cursor_changed)
tw.set_cursor((0,))
for idx, s in enumerate(self.g_liststore):
if s[0].decode("utf-8") == default_profile:
tw.set_cursor((idx, ))
#
chk = gu.nCheckButton("app", "noprofilemanager", _("D_on't ask at startup"))
vbox.pack_start(chk, False, False, 0)
self.show_all()
def __init__(self, parent, app, title, source_url, save_path):
'''???BT???????.
source_url - ???BT????, ?????????.
???????, ???magent:???????.
'''
super().__init__(title, app.window, Gtk.DialogFlags.MODAL,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self.app = app
self.source_url = source_url
self.save_path = save_path
self.set_default_response(Gtk.ResponseType.OK)
self.set_default_size(520, 480)
self.set_border_width(10)
box = self.get_content_area()
select_all_button = Gtk.ToggleButton.new_with_label(_('Select All'))
select_all_button.props.halign = Gtk.Align.START
select_all_button.props.margin_bottom = 5
select_all_button.connect('toggled', self.on_select_all_toggled)
box.pack_start(select_all_button, False, False, 0)
scrolled_win = Gtk.ScrolledWindow()
box.pack_start(scrolled_win, True, True, 0)
# check, name, size, humansize
self.liststore = Gtk.ListStore(bool, str, GObject.TYPE_INT64, str)
self.treeview = Gtk.TreeView(model=self.liststore)
self.treeview.set_tooltip_column(NAME_COL)
scrolled_win.add(self.treeview)
check_cell = Gtk.CellRendererToggle()
check_cell.connect('toggled', self.on_check_cell_toggled)
check_col = Gtk.TreeViewColumn('', check_cell, active=CHECK_COL)
self.treeview.append_column(check_col)
name_cell = Gtk.CellRendererText(ellipsize=Pango.EllipsizeMode.END,
ellipsize_set=True)
name_col = Gtk.TreeViewColumn(_('Name'), name_cell, text=NAME_COL)
name_col.set_expand(True)
self.treeview.append_column(name_col)
size_cell = Gtk.CellRendererText()
size_col = Gtk.TreeViewColumn(_('Size'), size_cell, text=HUMANSIZE_COL)
self.treeview.append_column(size_col)
box.show_all()
self.request_data()
