def _build_view_rules(self):
self.lstore_rules = Gtk.ListStore(str, str, str, str, float)
view = Gtk.TreeView(model=self.lstore_rules)
# Create field to set the type of rule tracker/label
liststore_field_type = Gtk.ListStore(str)
for item in ["Tracker", "Label"]:
liststore_field_type.append([item])
crc = Gtk.CellRendererCombo()
crc.set_property("editable", True)
crc.set_property("model", liststore_field_type)
crc.set_property("text-column", 0)
crc.set_property("has-entry", False)
crc.connect("edited", self._on_combo_type_changed)
# crc.set_active(0)
colc = Gtk.TreeViewColumn(_("Type"), crc, text=0)
view.append_column(colc)
# Create text field for label or tracker names
crt = Gtk.CellRendererText()
crt.set_property("editable", True)
crt.connect("edited", self._on_name_changed)
colt = Gtk.TreeViewColumn(_("Name"), crt, text=1)
view.append_column(colt)
# Create field to set the type of selection and/or
liststore_field_logic = self.sel_func_store
crl = Gtk.CellRendererCombo()
crl.set_property("editable", True)
crl.set_property("model", liststore_field_logic)
crl.set_property("text-column", 0)
crl.set_property("has-entry", False)
crl.connect("edited", self._on_combo_logic_changed)
#crl.set_active(0) #TODO
coll = Gtk.TreeViewColumn(_("Operator"), crl, text=2)
view.append_column(coll)
# Create field for remove rule selection
liststore_field_rules = self.rules
crrr = Gtk.CellRendererCombo()
crrr.set_property("editable", True)
crrr.set_property("model", liststore_field_rules)
crrr.set_property("text-column", 1)
crrr.set_property("has-entry", False)
crrr.connect("edited", self._on_combo_rules_changed)
colrr = Gtk.TreeViewColumn(_("Remove Rule"), crrr, text=3)
view.append_column(colrr)
# Spin button for minimum value
crm = Gtk.CellRendererSpin()
crm.set_property("editable", True)
crm.set_property("digits", 3)
crm.set_property("adjustment", Gtk.Adjustment(0, 0, 10000.0, 0.5, 10,
0))
crm.connect("edited", self._on_spin_min_changed)
colm = Gtk.TreeViewColumn(_("Minimum"), crm, text=4)
view.append_column(colm)
return view
def main():
window = gtk.Window()
window.set_default_size(300, 450)
window.set_border_width(18)
# Creating the manufacturers ListStore model
liststore_manufacturers = gtk.ListStore(str)
for item in MANUFACTURERS:
liststore_manufacturers.append([item])
# Creating the hardware ListStore model
liststore_hardware = gtk.ListStore(str, str)
for item in HARDWARE:
liststore_hardware.append(list(item))
# Creating the treeview and add the columns
treeview = gtk.TreeView(model=liststore_hardware)
# Text column
renderer1 = gtk.CellRendererText()
column1_title = "Text"
column1_index = 0
column1 = gtk.TreeViewColumn(column1_title, renderer1, text=column1_index)
treeview.append_column(column1)
# Combo column
renderer2 = gtk.CellRendererCombo()
column2_title = "Combo"
column2_index = 1
column2 = gtk.TreeViewColumn(column2_title, renderer2, text=column2_index)
treeview.append_column(column2)
renderer2.set_property("editable", True)
renderer2.set_property("model", liststore_manufacturers)
renderer2.set_property("text-column", 0)
renderer2.set_property("has-entry", False)
def on_combo_changed_cb(widget, path, text):
liststore_hardware[path][1] = text
renderer2.connect("edited", on_combo_changed_cb)
# Scrolled window
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_border_width(0)
scrolled_window.set_shadow_type(
gtk.ShadowType.IN
) # should be gtk.ShadowType.IN, gtk.ShadowType.OUT, gtk.ShadowType.ETCHED_IN or gtk.ShadowType.ETCHED_OUT
scrolled_window.set_policy(
gtk.PolicyType.AUTOMATIC, gtk.PolicyType.ALWAYS
) # should be gtk.PolicyType.AUTOMATIC, gtk.PolicyType.ALWAYS or gtk.PolicyType.NEVER
scrolled_window.add(treeview)
window.add(scrolled_window)
window.connect(
"delete-event", gtk.main_quit
) # ask to quit the application when the close button is clicked
window.show_all() # display the window
gtk.main() # GTK+ main loop
def __init__(self):
Gtk.Window.__init__(self, title="Hello World")
self.connect("delete-event", Gtk.main_quit)
self.set_default_size(200,200)
liststore_manufacturers = Gtk.ListStore(str)
manufacturers = ["Sony", "LG", "Panasonic", "Toshiba", "Nokia", "Samsung"]
for item in manufacturers:
liststore_manufacturers.append([item])
self.liststore_hardware = Gtk.ListStore(str, str)
self.liststore_hardware.append(["Television", "Samsung"])
self.liststore_hardware.append(["Mobile Phone", "LG"])
self.liststore_hardware.append(["DVD Player", "Sony"])
treeview = Gtk.TreeView(model=self.liststore_hardware)
renderer_text = Gtk.CellRendererText()
column_text = Gtk.TreeViewColumn("Text", renderer_text, text=0)
treeview.append_column(column_text)
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property("editable", True)
renderer_combo.set_property("model", liststore_manufacturers)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
renderer_combo.connect("edited", self.on_combo_changed)
column_combo = Gtk.TreeViewColumn("Combo", renderer_combo, text=1)
treeview.append_column(column_combo)
self.add(treeview)
def __init__(self, model):
GObject.GObject.__init__(self)
self.data = None
self.text_renderer = Gtk.CellRendererText()
self.text_renderer.set_property("editable", True)
self.text_renderer.connect("edited", self.text_edited_cb, model)
self.toggle_renderer = Gtk.CellRendererToggle()
self.toggle_renderer.set_property("activatable", True)
self.toggle_renderer.set_property("xalign", 0)
self.toggle_renderer.connect("toggled", self.toggled_cb, model)
self.ro_toggle_renderer = Gtk.CellRendererToggle()
self.ro_toggle_renderer.set_property("activatable", False)
self.ro_toggle_renderer.set_property("xalign", 0)
self.spin_renderer = Gtk.CellRendererSpin()
self.spin_renderer.set_property("editable", True)
self.spin_renderer.connect("edited", self.spin_edited_cb, model)
self.combo_renderer = Gtk.CellRendererCombo()
self.combo_renderer.set_property("has_entry", False)
self.combo_renderer.set_property("editable", True)
self.combo_renderer.set_property("text_column", 0)
self.combo_renderer.connect("edited", self.text_edited_cb, model)
self.button_renderer = Gtk.CellRendererText()
self.button_renderer.set_property("editable", False)
def setup_tree_view(self, treeview):
# Create a GtkListStore that will be used for the combo box renderer.
model = Gtk.ListStore.new((GObject.TYPE_STRING, GObject.TYPE_STRING))
iter = model.append()
model.set(iter, 0, "None")
iter = model.append()
model.set(iter, 0, "One")
iter = model.append()
model.set(iter, 0, "Half a Dozen")
iter = model.append()
model.set(iter, 0, "Dozen")
iter = model.append()
model.set(iter, 0, "Two Dozen")
# Create the GtkCellRendererCombo and add the tree model. Then, add the
# renderer to a new column and add the column to the GtkTreeView.
renderer = Gtk.CellRendererCombo(text_column=0,
editable=True,
has_entry=True,
model=model)
column = Gtk.TreeViewColumn("Count", renderer, text=QUANTITY)
treeview.append_column(column)
renderer.connect("edited", self.cell_edited, treeview)
renderer = Gtk.CellRendererText.new()
column = Gtk.TreeViewColumn("Product", renderer, text=PRODUCT)
treeview.append_column(column)
def __init__(self, window):
self.databaseWindow = window
store = Gtk.TreeStore(*([int] + [x[1] for x in animModel]))
TreeTab.__init__(self, store)
for i, value in enumerate(animModel):
renderer = None
if value[0] == "Unit Name":
renderer = Gtk.CellRendererText()
renderer.set_property("editable", False)
elif value[0] == "Type":
renderer = Gtk.CellRendererCombo()
renderer.set_property("model", AnimTypeModel.animTypeModel)
renderer.set_property("text-column", 0)
renderer.set_property("editable", False)
else:
renderer = Gtk.CellRendererText()
renderer.set_property("editable", True)
renderer.connect("edited", self.editAnimRenderer, i)
column = Gtk.TreeViewColumn(value[0], renderer, text=i + 1)
column.set_resizable(True)
column.set_expand(True)
self.tree.append_column(column)
def setup_tree(self):
item_renderer = Gtk.CellRendererText()
item_renderer.set_property('editable', True)
item_col = Gtk.TreeViewColumn(_('Item'), item_renderer, text=1)
item_col.set_expand(True)
key_renderer = Gtk.CellRendererCombo()
key_renderer.set_property('editable', True)
key_renderer.connect('editing-started', self.start_keyedit_cb)
key_renderer.connect('edited', self.key_edited_cb)
key_renderer.set_property('mode', Gtk.CellRendererMode.EDITABLE)
key_renderer.set_property('sensitive', True)
key_col = Gtk.TreeViewColumn(_('Key'), key_renderer, text=2)
key_col.set_expand(True)
self.renderers = [key_renderer, item_renderer]
self.tv.append_column(item_col)
self.tv.append_column(key_col)
for r in key_renderer, item_renderer:
r.set_property('wrap-mode', Pango.WrapMode.WORD)
r.set_property('wrap-width', 200)
self.tv.connect('check-resize', self.resize_event_cb)
self.tv.connect('size-allocate', self.tv_size_allocate_cb)
plugin_manager = keyEditorPluggable.get_key_editor_plugin_manager()
for tvc in plugin_manager.get_treeview_columns(self,
key_col=2,
instant_apply=False):
self.tv.append_column(tvc)
def __init__(self):
Gtk.Window.__init__(self, title="CellRendererCombo Example")
self.set_default_size(200, 200)
# 数据源
list_store = Gtk.ListStore(str)
list_store.append(["PHP"])
list_store.append(["Python"])
list_store.append(["Swift"])
list_store.append(["Shell"])
self.list_store_default = Gtk.ListStore(str, str)
self.list_store_default.append(["最好的语言", "PHP"])
self.list_store_default.append(["时间不多了", "Python"])
self.list_store_default.append(["全美推广", "Swift"])
tree_view = Gtk.TreeView(model=self.list_store_default)
renderer_text = Gtk.CellRendererText()
column_text = Gtk.TreeViewColumn("编程留言", renderer_text, text=0)
tree_view.append_column(column_text)
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property("editable", True)
renderer_combo.set_property("model", list_store)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
renderer_combo.connect("edited", self.on_combo_changed)
column_combo = Gtk.TreeViewColumn("Combo", renderer_combo, text=1)
tree_view.append_column(column_combo)
self.add(tree_view)
def __init__(
self,
window: PreferencesWindow,
settings: Dict[Preference, Any],
list_store: Gtk.ListStore,
*args,
**kwargs,
):
super().__init__(*args, **kwargs)
self._settings = settings
self._list_store = list_store
# self._key: str = ""
self._window: PreferencesWindow = window
self._renderer: Gtk.CellRenderer = None
# our renderers
self._toggle_renderer = Gtk.CellRendererToggle(activatable=True,
radio=False)
self._combo_renderer = Gtk.CellRendererCombo(has_entry=False)
self._text_renderer = Gtk.CellRendererText(editable=True)
# our combo models
self._combo_models: Final[Dict[Preference, Gtk.ListStore]] = dict()
# connect signal handlers
self._toggle_renderer.connect("toggled", self._toggle_cb)
self._combo_renderer.connect("changed", self._changed_cb)
self._text_renderer.connect("edited", self._edited_cb)
def __init__(self, window):
self.databaseWindow = window
store = Gtk.TreeStore(*[x[1] for x in unitModel])
TreeTab.__init__(self, store)
for i, value in enumerate(unitModel):
renderer = None
if value[0] == "Type Name":
renderer = Gtk.CellRendererCombo()
renderer.set_property("model", window.classTab.store)
renderer.set_property("text-column", 0)
renderer.set_property("editable", True)
renderer.connect("edited", self.editRenderer, i)
elif value[0] == "Winged":
renderer = Gtk.CellRendererToggle()
renderer.set_property("activatable", True)
renderer.connect("toggled", self.toggleRenderer, i)
else:
renderer = Gtk.CellRendererText()
if value[0] != "ID":
renderer.set_property("editable", True)
renderer.connect("edited", self.editRenderer, i)
column = Gtk.TreeViewColumn(value[0], renderer, text=i)
column.set_resizable(True)
column.set_expand(True)
self.tree.append_column(column)
def __init__(self):
super(EngineTreeView, self).__init__()
self.__engines = []
self.__changed = False
# self.set_headers_visible(True)
self.set_reorderable(True)
self.__model = Gtk.ListStore(GObject.TYPE_PYOBJECT,
GObject.TYPE_STRING)
self.set_model(self.__model)
self.__model.connect("row-changed", self.__emit_changed_delay_cb,
"row-changed")
self.__model.connect("row-deleted", self.__emit_changed_delay_cb,
"row-deleted")
self.__model.connect("row-inserted", self.__emit_changed_delay_cb,
"row-inserted")
self.__model.connect("rows-reordered", self.__emit_changed_delay_cb,
"rows-reordered")
self.__model.set_default_sort_func(self.__sort_engines, None)
self.__model.set_sort_column_id(-1, Gtk.SortType.ASCENDING)
# create im name & icon column
column = Gtk.TreeViewColumn(_("Input Method"))
column.set_min_width(220)
renderer = Gtk.CellRendererPixbuf()
renderer.set_property("xalign", 0)
column.pack_start(renderer, False)
column.set_cell_data_func(renderer, self.__icon_cell_data_cb)
renderer = Gtk.CellRendererText()
renderer.set_property("xalign", 0)
renderer.set_property("ellipsize", Pango.EllipsizeMode.END)
column.pack_start(renderer, True)
column.set_cell_data_func(renderer, self.__name_cell_data_cb)
self.append_column(column)
# create im keyboard layout column
renderer = Gtk.CellRendererCombo()
model = Gtk.ListStore(GObject.TYPE_STRING)
model.append(("us", ))
model.append(("jp", ))
model.append(("xkb", ))
renderer.set_property("xalign", 0)
renderer.set_property("model", model)
renderer.set_property("text-column", 0)
renderer.set_property("has-entry", False)
renderer.set_property("editable", True)
column = Gtk.TreeViewColumn("Kbd")
column.set_expand(False)
column.set_fixed_width(32)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.pack_start(renderer, False)
column.set_cell_data_func(renderer, self.__layout_cell_data_cb)
# self.append_column(column)
self.get_selection().connect("changed", self.__selection_changed_cb)
def _init_widgets(self):
# Comment
ui_label = self._create_label(
_T("List of the figures detected in your document's directory.\nYou can edit the second column to set the translator used for a particular figure."
))
self._insert_row(ui_label, None, False)
# List of figures
self._ui_figure_edit_store = Gtk.ListStore(str)
self._ui_figure_store = Gtk.ListStore(str, str)
ui_figure_widget = Gtk.TreeView()
ui_figure_widget.set_model(self._ui_figure_store)
ui_figure_widget.append_column(
Gtk.TreeViewColumn(_T("Figure"), Gtk.CellRendererText(), text=0))
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property("editable", True)
renderer_combo.set_property("model", self._ui_figure_edit_store)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
renderer_combo.connect("edited", self.on_figure_translator_changed)
ui_figure_widget.append_column(
Gtk.TreeViewColumn(_T("Translator"), renderer_combo, text=1))
ui_figure_widget.set_headers_clickable(False)
ui_figure_widget.set_headers_visible(True)
self._ui_figure_selection = ui_figure_widget.get_selection()
self._ui_figure_selection.set_mode(Gtk.SelectionMode.SINGLE)
# Scroll
ui_figure_scroll = self._create_scroll_for(ui_figure_widget)
self._insert_row(ui_figure_scroll, None, False)
def _build_view_trackers(self):
self.lstore = Gtk.ListStore(str, str)
view = Gtk.TreeView(model=self.lstore)
# Create field to set the type of exemption
liststore_field = Gtk.ListStore(str)
for item in ["Tracker", "Label"]:
liststore_field.append([item])
crc = Gtk.CellRendererCombo()
crc.set_property("editable", True)
crc.set_property("model", liststore_field)
crc.set_property("text-column", 0)
crc.set_property("has-entry", False)
crc.connect("edited", self._on_combo_changed)
# crc.set_active(0)
colc = Gtk.TreeViewColumn(_("Type"), crc, text=0)
view.append_column(colc)
# Create text field for label or tracker names
crt = Gtk.CellRendererText()
crt.set_property("editable", True)
crt.connect("edited", self._text_edited)
colt = Gtk.TreeViewColumn(_("Name"), crt, text=1)
view.append_column(colt)
return view
def setup_treeview_column (self, ike, key_col, instant_apply=False):
'''Set up a treeview column to display your data.
The key_col is the column in the treemodel which will contain
your data in the model. It\'s your responsibility to get
whatever other data you need yourself.
If you make this editable, it\'s up to you to apply the
changes as well to the database. If instant_apply is True,
then apply them instantly; if False, apply them when this
class\'s save method is called.
'''
renderer = Gtk.CellRendererCombo()
renderer.connect('editing-started',self.start_edit_cb)
renderer.connect('edited',self.key_edited_cb,(ike,key_col,instant_apply))
# Build shopcat model...
self.rd = get_recipe_manager()
self.shopcat_model = Gtk.ListStore(str)
for val in self.rd.get_unique_values('shopcategory',table=self.rd.shopcats_table):
if val: self.shopcat_model.append([val])
renderer.set_property('model',self.shopcat_model)
renderer.set_property('text-column',0)
renderer.set_property('editable',True)
renderer.set_property('mode',Gtk.CellRendererMode.EDITABLE)
renderer.set_property('sensitive',True)
tvc = Gtk.TreeViewColumn(self.title,renderer)
tvc.set_cell_data_func(renderer,self.cell_data_func,key_col)
self.tvcs[renderer] = tvc
return tvc
def build_columns(self):
#first the standard text columns with normal method
EmbeddedList.build_columns(self)
# now we add the two special columns
# combobox for type
colno = len(self.columns)
name = self._column_combo[0]
renderer = Gtk.CellRendererCombo()
renderer.set_property('ellipsize', Pango.EllipsizeMode.END)
# set up the comboentry editable
no = NameOriginType()
self.cmborig = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_STRING)
self.cmborigmap = no.get_map().copy()
#sort the keys based on the value
keys = sorted(self.cmborigmap,
key=lambda x: glocale.sort_key(self.cmborigmap[x]))
for key in keys:
if key != no.get_custom():
self.cmborig.append(row=[key, self.cmborigmap[key]])
additional = self.dbstate.db.get_origin_types()
if additional:
for type in additional:
if type:
self.cmborig.append(row=[no.get_custom(), type])
renderer.set_property("model", self.cmborig)
renderer.set_property("text-column", 1)
renderer.set_property('editable', not self.dbstate.db.readonly)
renderer.connect('editing_started', self.on_edit_start_cmb, colno)
renderer.connect('edited', self.on_orig_edited, self._column_combo[3])
# add to treeview
column = Gtk.TreeViewColumn(name, renderer, text=self._column_combo[3])
column.set_resizable(True)
column.set_sort_column_id(self._column_combo[1])
column.set_min_width(self._column_combo[2])
column.set_expand(False)
self.columns.append(column)
self.tree.append_column(column)
# toggle box for primary
colno += 1
name = self._column_toggle[0]
renderer = Gtk.CellRendererToggle()
renderer.set_property('activatable', True)
renderer.set_property('radio', True)
renderer.connect('toggled', self.on_prim_toggled,
self._column_toggle[3])
# add to treeview
column = Gtk.TreeViewColumn(name,
renderer,
active=self._column_toggle[3])
column.set_resizable(False)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_alignment(0.5)
column.set_sort_column_id(self._column_toggle[1])
column.set_max_width(self._column_toggle[2])
self.columns.append(column)
self.tree.append_column(column)
def __init__(self):
gtk.Frame.__init__(self)
scrolledWindow = gtk.ScrolledWindow()
scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC,
gtk.PolicyType.AUTOMATIC)
treeview = self.treeview = gtk.TreeView()
model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
treeview.set_model(model)
treeview.connect("motion-notify-event", self.treeview_mouse_over)
self.key_renderer = key_renderer = gtk.CellRendererText()
key_renderer.set_property("editable", False)
column1 = gtk.TreeViewColumn("Name", key_renderer, text=0)
column1.set_cell_data_func(key_renderer, self.key_data_func)
column1.set_property("min-width", 75)
self.entry_renderer = entry_renderer = gtk.CellRendererText()
entry_renderer.connect("edited", self.entry_edited)
entry_renderer.connect("editing-started", self.entry_edit_start)
self.combo_renderer = combo_renderer = gtk.CellRendererCombo()
combo_renderer.set_property("text-column", 0)
combo_renderer.connect("edited", self.combo_selected)
combo_renderer.connect("editing-started", self.combo_edit_start)
column2 = gtk.TreeViewColumn("Value", entry_renderer, text=1)
column2.pack_start(combo_renderer, True)
column2.set_attributes(combo_renderer, text=1)
column2.set_cell_data_func(entry_renderer, self.entry_data_func)
column2.set_cell_data_func(combo_renderer, self.combo_data_func)
column2.set_property("expand", True)
column2.set_property("min-width", 75)
icon_renderer = gtk.CellRendererPixbuf()
column3 = gtk.TreeViewColumn("", icon_renderer)
column3.set_cell_data_func(icon_renderer, self.icon_data_func)
self.set_fontsize()
treeview.append_column(column1)
treeview.append_column(column2)
treeview.append_column(column3)
scrolledWindow.add(treeview)
label = gtk.Label()
label.set_markup("<b>Attributes</b>")
self.set_label_widget(label)
self.set_shadow_type(gtk.ShadowType.NONE)
self.add(scrolledWindow)
def standard_combo_renderer(list_model, model, path, column):
combo = Gtk.CellRendererCombo()
combo.set_property('model', model)
combo.set_property('editable', True)
combo.set_property('has-entry', False)
combo.set_property('text-column', 1)
combo.set_property('mode', Gtk.CellRendererMode.EDITABLE)
combo.connect('changed', tree_combo_changed, list_model, path, column)
return combo
def ap_list(self):
# To list the APs as going from best signal to weakest, we need to sort it.
# These two lines does that.
sorted_model = Gtk.TreeModelSort(model=self.liststore)
sorted_model.set_sort_column_id(1, Gtk.SortType.DESCENDING)
treeview = Gtk.TreeView(model=sorted_model)
#treeview = Gtk.TreeView(model=liststore)
treeview.set_headers_clickable(True)
treeview.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
#treeview.get_selection().set_select_function()
select = treeview.get_selection()
global ap_selection_signal
ap_selection_signal = select.connect("changed",
self.on_ap_selection_changed)
# SSID, Strength, Encryption, MAC, channel, frequency, (list)bitrate, mode
renderText = Gtk.CellRendererText()
column_name = Gtk.TreeViewColumn("ESSID", renderText, text=0)
treeview.append_column(column_name)
column_strength = Gtk.TreeViewColumn("Strength", renderText, text=1)
treeview.append_column(column_strength)
column_enc = Gtk.TreeViewColumn("Encryption", renderText, text=2)
treeview.append_column(column_enc)
column_mac = Gtk.TreeViewColumn("BSSID", renderText, text=3)
treeview.append_column(column_mac)
column_chan = Gtk.TreeViewColumn("Channel", renderText, text=4)
treeview.append_column(column_chan)
column_freq = Gtk.TreeViewColumn("Frequency", renderText, text=5)
treeview.append_column(column_freq)
renderCombo = Gtk.CellRendererCombo()
renderCombo.set_property("editable", True)
renderCombo.set_property("model", self.liststore_bitrates)
renderCombo.set_property("text-column", 0)
renderCombo.set_property("has-entry", False)
column_bit = Gtk.TreeViewColumn("Bitrates", renderCombo, text=6)
treeview.append_column(column_bit)
column_mode = Gtk.TreeViewColumn("Mode", renderText, text=7)
treeview.append_column(column_mode)
treeview.set_size_request(400, 200)
#list_size = Gtk.Adjustment(lower=10, page_size=100)
scrolledwindow = Gtk.ScrolledWindow()
scrolledwindow.add(treeview)
scrolledwindow.set_min_content_width(1000)
scrolledwindow.set_min_content_height(400)
self.vbox.pack_start(scrolledwindow, True, True, 0)
def make_list(self):
renderer = Gtk.CellRendererText()
renderer.set_fixed_size(20, 25)
column = Gtk.TreeViewColumn("#", renderer, text=0)
self.tree.append_column(column)
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property("editable", True)
renderer_combo.set_property("model", self.store)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
renderer_combo.connect("edited", self.edit_data)
renderer_combo.set_fixed_size(400, 25)
column = Gtk.TreeViewColumn("Product", renderer_combo, text=1)
self.tree.append_column(column)
renderer = Gtk.CellRendererText()
renderer.set_property("editable", True)
renderer.set_fixed_size(120, 25)
renderer.connect("edited", self.edit_data)
column = Gtk.TreeViewColumn("OpeningMeter", renderer, text=2)
self.tree.append_column(column)
renderer = Gtk.CellRendererText()
renderer.set_property("editable", True)
renderer.set_fixed_size(120, 25)
column = Gtk.TreeViewColumn("ClosingMeter", renderer, text=3)
renderer.connect("edited", self.edit_data)
self.tree.append_column(column)
renderer = Gtk.CellRendererText()
renderer.set_property("editable", True)
renderer.set_fixed_size(120, 25)
column = Gtk.TreeViewColumn("Rtt", renderer, text=4)
renderer.connect("edited", self.edit_data)
self.tree.append_column(column)
renderer = Gtk.CellRendererText()
renderer.set_property("editable", False)
renderer.set_fixed_size(100, 25)
column = Gtk.TreeViewColumn("Litres", renderer, text=5)
renderer.connect("edited", self.edit_data)
self.tree.append_column(column)
renderer = Gtk.CellRendererText()
renderer.set_property("editable", True)
renderer.set_fixed_size(100, 25)
column = Gtk.TreeViewColumn("Price", renderer, text=6)
renderer.connect("edited", self.edit_data)
self.tree.append_column(column)
renderer = Gtk.CellRendererText()
renderer.set_property("editable", False)
renderer.set_fixed_size(100, 25)
column = Gtk.TreeViewColumn("Amount", renderer, text=7)
self.tree.append_column(column)
def create_cell_renderer_combo(self, tree_view, title="title", assign=0, editable=False, model=None, function=None):
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property('editable', editable)
if model:
renderer_combo.set_property('model', model)
if function:
renderer_combo.connect("edited", function)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry",False)
column = Gtk.TreeViewColumn(title, renderer_combo, text=assign)
tree_view.append_column(column)
def __init__(self, theBook):
Gtk.TreeView.__init__(self)
logger.verbose("GUI: Building plots tree")
# Connect to GUI
self.mainConf = nw.CONFIG
self.theBook = theBook
self.iterMap = {}
self.set_name("treePlots")
self.set_headers_visible(True)
# Core Objects
self.treeSelect = self.get_selection()
self.listStore = Gtk.ListStore(str, str, str, str)
self.set_model(self.listStore)
# Title Column
self.colName = Gtk.TreeViewColumn(title="Plot")
self.rendName = Gtk.CellRendererText()
self.rendName.set_property("editable", True)
self.colName.pack_start(self.rendName, True)
self.colName.add_attribute(self.rendName, "text", 0)
self.colName.set_attributes(self.rendName, markup=0)
self.colImport = Gtk.TreeViewColumn(title="Importance")
self.listImport = Gtk.ListStore(str)
self.listImport.append(["Main"])
self.listImport.append(["Major"])
self.listImport.append(["Minor"])
self.rendImport = Gtk.CellRendererCombo()
self.rendImport.set_property("model", self.listImport)
self.rendImport.set_property("editable", True)
self.rendImport.set_property("has-entry", False)
self.rendImport.set_property("text-column", 0)
self.colImport.pack_start(self.rendImport, False)
self.colImport.add_attribute(self.rendImport, "text", 1)
# Comment
self.colComment = Gtk.TreeViewColumn(title="Comment")
self.rendComment = Gtk.CellRendererText()
self.rendComment.set_property("editable", True)
self.colComment.pack_start(self.rendComment, False)
self.colComment.add_attribute(self.rendComment, "text", 2)
# Add to TreeView
self.append_column(self.colName)
self.append_column(self.colImport)
self.append_column(self.colComment)
return
def GetColumn(self, num):
self.Num = num
cell = Gtk.CellRendererCombo()
column = Gtk.TreeViewColumn(self.Setting.ShortDesc, cell, text=num)
model = Gtk.ListStore(str)
for property, value in [("model", model), ("text_column", 0),
("editable", False), ("has_entry", False)]:
cell.set_property(property, value)
cell.connect("edited", self._CellEdited)
for item, i in self.SortedItems:
model.append([item])
return (str, column)
def create(signals):
signal_editor = {
'view': gtk.TreeView(signals),
'renderers': {
'source': gtk.CellRendererCombo(),
'dest': gtk.CellRendererCombo(),
'invert': gtk.CellRendererToggle(),
},
}
R = signal_editor['renderers']
R['source'].set_property('editable', True)
R['dest'].set_property('editable', True)
R['invert'].set_property('activatable', True)
R['source'].set_property('text-column', 0)
R['dest'].set_property('text-column', 0)
R['source'].connect('edited', set_item, signals, signals.SOURCE)
R['source'].connect('editing-started', load_signals_combobox, signals)
R['dest'].connect('edited', set_item, signals, signals.DEST)
R['dest'].connect('editing-started', load_dest_combobox, signals)
R['invert'].connect('toggled', toggle_item, signals, signals.INVERT)
signal_editor.update({
'columns': {
'source': GTVC('Source', R['source'], text=signals.SOURCE),
'dest': GTVC('Destination', R['dest'], text=signals.DEST),
'invert': GTVC('Invert Polarity', R['invert']),
},
})
C = signal_editor['columns']
V = signal_editor['view']
C['invert'].add_attribute(R['invert'], 'active', signals.INVERT)
#V.set_property( 'hover_selection', True )
V.append_column(C['source'])
V.append_column(C['dest'])
V.append_column(C['invert'])
return signal_editor
def __init__(self):
GObject.GObject.__init__(self)
Signalizable.__init__(self)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
units = Gtk.ListStore(str)
units.append([_("millimeters")])
units.append([_("inches")])
units.append([_("pixels")])
self.liststore = Gtk.ListStore(str, int, str)
treeview = Gtk.TreeView(self.liststore)
treeview.set_size_request(-1, 100)
treeview.set_rules_hint(True)
treeview.set_grid_lines(True)
self.add(treeview)
cell = Gtk.CellRendererText()
cell.connect("edited", self.title_edited)
cell.set_property("editable", True)
column = Gtk.TreeViewColumn(_("Title"))
column.pack_start(cell, True)
column.set_attributes(cell, text=COLUMN_TITLE)
treeview.append_column(column)
treeview.set_search_column(COLUMN_TITLE)
adjustment = Gtk.Adjustment(0, 0, 100, 1)
cell = Gtk.CellRendererSpin()
cell.connect("edited", self.width_edited)
cell.set_property("editable", True)
cell.set_property("adjustment", adjustment)
cell.set_property("xalign", 1.0)
column = Gtk.TreeViewColumn(_("Width"))
column.pack_start(cell, True)
column.set_attributes(cell, text=COLUMN_WIDTH)
treeview.append_column(column)
cell = Gtk.CellRendererCombo()
cell.set_property("editable", True)
cell.set_property("has-entry", False)
cell.set_property("model", units)
cell.set_property("text-column", 0)
column = Gtk.TreeViewColumn(_("Unit"))
column.pack_start(cell, True)
column.set_attributes(cell, text=COLUMN_UNIT)
treeview.append_column(column)
self.install_signals()
def _prepare_treeview_with_headcolumn_list(self, liststore):
'''
Preparation of the treeview element, that displays the columns of the table
:param liststore: model for current treeview
:return: the treeview
'''
treeview = Gtk.TreeView(liststore)
# 1. Column - Title
cell = Gtk.CellRendererText()
cell.set_property('editable', True)
column = Gtk.TreeViewColumn(_('Title'), cell, text=self.Col.title)
column.set_min_width(120)
treeview.append_column(column)
cell.connect('edited', self.on_cell_changed, liststore, self.Col.title)
cell.connect('editing-started', self.on_cell_editing_started,
liststore, self.Col.title)
# 2. Column - Wrap Line
cell = Gtk.CellRendererToggle()
cell.connect('toggled', self.on_wrap_toggled, liststore,
self.Col.wrapped)
column = Gtk.TreeViewColumn(_('Auto\nWrap'), cell) # T: table header
treeview.append_column(column)
column.add_attribute(cell, 'active', self.Col.wrapped)
# 3. Column - Alignment
store = Gtk.ListStore(str, str, str)
store.append(COLUMNS_ALIGNMENTS['left'])
store.append(COLUMNS_ALIGNMENTS['center'])
store.append(COLUMNS_ALIGNMENTS['right'])
column = Gtk.TreeViewColumn(_('Align')) # T: table header
cellicon = Gtk.CellRendererPixbuf()
column.pack_start(cellicon, True)
column.add_attribute(cellicon, 'stock-id', self.Col.alignicon)
cell = Gtk.CellRendererCombo()
cell.set_property('model', store)
cell.set_property('has-entry', False)
cell.set_property('text-column', 2)
cell.set_property('width', 50)
cell.set_property('editable', True)
column.pack_start(cell, True)
column.add_attribute(cell, 'text', self.Col.aligntext)
cell.connect('changed', self.on_alignment_changed, liststore)
treeview.append_column(column)
return treeview
def build_combo_column(self, column_name, column_id, value_list):
"""Function to build the columns with selection from a list"""
# COMBOBOX CELL
combo_list = Gtk.ListStore(str)
for value in value_list:
combo_list.append([value])
rendererCombo = Gtk.CellRendererCombo()
rendererCombo.set_properties(model=combo_list, editable=True)
rendererCombo.set_property("has-entry", False)
rendererCombo.set_property("text-column", 0)
rendererCombo.connect("edited", self.on_combo_edit, column_id)
# COMBOBOX COLUMN
column = Gtk.TreeViewColumn(column_name)
column.pack_start(rendererCombo, False)
column.add_attribute(rendererCombo, "text", column_id)
column.add_attribute(rendererCombo, "visible", 4)
self.config_app_view.append_column(column)
def on_view_added(self, view):
self.view.window.set_title(Smelted_Settings.program_title)
self.playlist_list_store = self.view.builder.get_object(
"playlist_list_store")
self.unit_list_store = self.view.builder.get_object("unit_list_store")
self.unit_tree_view = self.view.builder.get_object("unit_tree_view")
self.playlist_tree_view = self.view.builder.get_object(
"playlist_tree_view")
self.progress_label = self.view.builder.get_object("progress_label")
self.in_slider_view = self.view.builder.get_object("in_slider")
self.out_slider_view = self.view.builder.get_object("out_slider")
self.in_slider_label_view = self.view.builder.get_object(
"in_slider_label")
self.out_slider_label_view = self.view.builder.get_object(
"out_slider_label")
# create combo box column on playlist tree view, should be moved to view if time allows
end_event_list_store = Gtk.ListStore(str)
self.end_event_list_items = ["Stop", "Loop", "Continue", "Pause"]
for item in self.end_event_list_items:
end_event_list_store.append([item])
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property("editable", True)
renderer_combo.set_property("model", end_event_list_store)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
renderer_combo.connect("edited", self.on_combo_changed)
column_combo = Gtk.TreeViewColumn("Unit Ended Event",
renderer_combo,
text=1)
self.unit_tree_view.append_column(column_combo)
ModelManager.register_on_model_added_callback(self.refresh_clips,
ModelManager.MODEL_CLIP)
ModelManager.register_on_model_added_callback(self.add_unit,
ModelManager.MODEL_UNIT)
ModelManager.register_on_model_list_emptied_callback(
self.remove_units, ModelManager.MODEL_UNIT)
ModelManager.register_on_attribute_changed_callback(
self.update_seek_progress, Models.Clip.CLIP_PROGRESS)
def drawTreeView(self):
vmNameRenderer = Gtk.CellRendererText()
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property("editable", True)
renderer_combo.set_property("model", self.adaptersListStore)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
renderer_combo.connect("edited", self.on_combo_changed)
statusRenderer = Gtk.CellRendererText()
vmColumn = Gtk.TreeViewColumn("Virtual Machine",
vmNameRenderer,
text=0)
adaptorColumn = Gtk.TreeViewColumn("Adaptor", renderer_combo, text=1)
statusColumn = Gtk.TreeViewColumn("Status", statusRenderer, text=2)
self.treeView.append_column(vmColumn)
self.treeView.append_column(adaptorColumn)
self.treeView.append_column(statusColumn)
def __init__(self, parent, gladefile, schema_file, schematron_file):
self.parent = parent
self.gladefile = gladefile
self.schema_file = schema_file
self.schematron_file = schematron_file
self.errlist_type = 0
self.listview = None
self.listwindow = self.parent.gui.get_object("errListWindow")
self.listview = self.parent.gui.get_object("sch_err_list")
if self.listwindow is None or self.listview is None:
raise Exception("Could not find the error list widgets")
self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.cellcombo = gtk.CellRendererCombo()
self.cellcombo.set_property("model", self.model)
self.cellcombo.set_property("editable", False)
column_renderer = gtk.CellRendererText()
column_renderer.set_property("editable", False)
column_xpath = gtk.TreeViewColumn("Element", column_renderer, text=0)
column_error = gtk.TreeViewColumn("Error", column_renderer, text=1)
self.listview.append_column(column_xpath)
self.listview.append_column(column_error)
column_xpath.set_property("expand", True)
column_xpath.set_resizable(True)
column_xpath.set_property("min-width", 75)
column_error.set_property("expand", True)
column_error.set_resizable(True)
column_error.set_property("min-width", 75)
# Set adjustment parameters for the list view
self.listview.set_model(self.model)
self.listview.connect("row_activated", self.on_xml_row_activate)
# User can only select one error at a time to go to.
self.listview.get_selection().set_mode(gtk.SelectionMode.SINGLE)
self.listview.hide()
self.listwindow.hide()
def _draw_ports(self, port_type: str):
hlbl = Gtk.Label()
hlbl.set_text(port_type)
self.pack_start(hlbl, False, False, 0)
scrw = Gtk.ScrolledWindow()
self.pack_start(scrw, True, True, 0)
self.lstore[port_type] = Gtk.ListStore(str, str)
for nm in self.portdef.port_names[port_type]:
self.lstore[port_type].append(
[nm, self.portdef.port_profiles[port_type][nm]["name"]])
tview = Gtk.TreeView(model=self.lstore[port_type])
scrw.add(tview)
rendtxt = Gtk.CellRendererText()
col = Gtk.TreeViewColumn("portname")
col.set_property("resizable", True)
col.pack_start(rendtxt, True)
col.add_attribute(rendtxt, "text", 0)
tview.append_column(col)
lstorecombo = Gtk.ListStore(str)
if port_type == "jack/midi/input":
tgtlst = self.portdef.synth_profiles.ls_writable()
else:
tgtlst = self.portdef.synth_profiles.ls_readable()
for pr in tgtlst:
lstorecombo.append([pr["name"]])
rendcombo = Gtk.CellRendererCombo()
rendcombo.set_property("editable", True)
rendcombo.set_property("model", lstorecombo)
rendcombo.set_property("text-column", 0)
colcombo = Gtk.TreeViewColumn("port profile")
colcombo.set_property("resizable", True)
colcombo.pack_start(rendcombo, False)
colcombo.add_attribute(rendcombo, "text", 1)
tview.append_column(colcombo)
if port_type == "jack/midi/input":
rendcombo.connect("edited", self.on_combo_changed_input)
else:
rendcombo.connect("edited", self.on_combo_changed_output)
