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)