def _update_tree_view(self): """Updates the tree view""" self.tree_store = Gtk.ListStore(int, bool, float, float, str, float, int) for cpu, conf in self.settings.items(): fmin, fmax = conf.freqs self.tree_store.append([ cpu, conf.online, fmin, fmax, conf.governor.capitalize(), 0.0, 0 ]) for i, column_title in enumerate([ _("CPU"), _("Online"), _("Min"), _("Max"), _("Governor"), _("Current freq."), ]): if column_title == _("Online"): renderer = Gtk.CellRendererToggle() renderer.connect("toggled", self.on_tree_toggled) column = Gtk.TreeViewColumn(column_title, renderer, active=i) elif column_title == _("Current freq."): renderer = Gtk.CellRendererSpin(digits=2) column = Gtk.TreeViewColumn(column_title, renderer, text=i, style=6) column.set_cell_data_func(renderer, self.conv_float, 5) elif column_title in [_("Min"), _("Max")]: index = 2 if column_title == _("Min") else 3 adj = Gtk.Adjustment( value=0, lower=fmin, upper=fmax, step_increment=10, page_increment=50, page_size=0, ) renderer = Gtk.CellRendererSpin(editable=True, adjustment=adj, digits=2) renderer.connect("edited", self.on_freq_edited, index) column = Gtk.TreeViewColumn(column_title, renderer, text=i, style=6) column.set_cell_data_func(renderer, self.conv_float, index) else: renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(column_title, renderer, text=i, style=6) self.tree_view.append_column(column) self.tree_view.set_model(self.tree_store)
def __init__(self, GUI, g): Gtk.Box.__init__(self) self.GUI = GUI self.g = g self.liststore = Gtk.ListStore(str, int, int) self.filters = ["Out-degree", "In-degree", "# of neighbors", \ "Page Rank", "Betweenness", "Closeness", "Eigenvector", \ "Authority centrality", "Hub centrality"] # can also have in-neighbors or out-neighbors for filter_name in self.filters: self.liststore.append([filter_name, 0, 100]) self.GUI.vertex_filters[filter_name + "_low"] = \ self.g.new_vertex_property("bool") self.GUI.vertex_filters[filter_name + "_low"].a = \ np.array([True] * g.num_vertices()) self.GUI.vertex_filters[filter_name + "_high"] = \ self.g.new_vertex_property("bool") self.GUI.vertex_filters[filter_name + "_high"].a = \ np.array([True] * g.num_vertices()) treeview = Gtk.TreeView(model=self.liststore) filter_name = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Vertex Filters", filter_name, text=0) treeview.append_column(column_text) self.filter_low = Gtk.CellRendererSpin() self.filter_low.connect("edited", self.low_on_amount_edited) self.filter_low.set_property("editable", True) self.filter_high = Gtk.CellRendererSpin() self.filter_high.connect("edited", self.high_on_amount_edited) self.filter_high.set_property("editable", True) low_adjustment = Gtk.Adjustment(0, 0, 99, 1, 10, 0) self.filter_low.set_property("adjustment", low_adjustment) high_adjustment = Gtk.Adjustment(100, 1, 100, 1, 10, 0) self.filter_high.set_property("adjustment", high_adjustment) low_spin = Gtk.TreeViewColumn("Lower bound (%)", self.filter_low, text=1) high_spin = Gtk.TreeViewColumn("Upper bound (%)", self.filter_high, text=2) treeview.append_column(low_spin) treeview.append_column(high_spin) self.add(treeview)
def __init__(self, GUI, g): Gtk.Box.__init__(self) self.GUI = GUI self.g = g self.liststore = Gtk.ListStore(str, int, int) self.filters = ["# of bytes", "Betweenness"] for filter_name in self.filters: self.liststore.append([filter_name, 0, 100]) self.GUI.edge_filters[filter_name + "_low"] = \ self.g.new_edge_property("bool") self.GUI.edge_filters[filter_name + "_low"].a = \ np.array([True] * g.num_edges()) self.GUI.edge_filters[filter_name + "_high"] = \ self.g.new_edge_property("bool") self.GUI.edge_filters[filter_name + "_high"].a = \ np.array([True] * g.num_edges()) treeview = Gtk.TreeView(model=self.liststore) filter_name = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Edge Filters", filter_name, text=0) treeview.append_column(column_text) self.filter_low = Gtk.CellRendererSpin() self.filter_low.connect("edited", self.low_on_amount_edited) self.filter_low.set_property("editable", True) self.filter_high = Gtk.CellRendererSpin() self.filter_high.connect("edited", self.high_on_amount_edited) self.filter_high.set_property("editable", True) low_adjustment = Gtk.Adjustment(0, 0, 99, 1, 10, 0) self.filter_low.set_property("adjustment", low_adjustment) high_adjustment = Gtk.Adjustment(100, 1, 100, 1, 10, 0) self.filter_high.set_property("adjustment", high_adjustment) low_spin = Gtk.TreeViewColumn("Lower bound (%)", self.filter_low, text=1) high_spin = Gtk.TreeViewColumn("Upper bound (%)", self.filter_high, text=2) treeview.append_column(low_spin) treeview.append_column(high_spin) self.add(treeview)
def __init__(this): Gtk.Window.__init__(this, title="Cell Renderer Spin") this.set_position(Gtk.WindowPosition.CENTER) this.model = Gtk.ListStore(str, int) this.model.append(["Apples", 10]) this.model.append(["Mangoes", 2]) this.model.append(["Strawberry", 5]) view = Gtk.TreeView(this.model) rnd_text = Gtk.CellRendererText() col0 = Gtk.TreeViewColumn("Fruit", rnd_text, text=0) view.append_column(col0) rnd_spin = Gtk.CellRendererSpin() rnd_spin.set_property("editable", True) # Otherwise what use would be the spin rnd_spin.connect("edited", this.on_quantity_edited) adj = Gtk.Adjustment(0, 0, 100, 1, 10, 0) rnd_spin.set_property("adjustment", adj) col1 = Gtk.TreeViewColumn("Quantity", rnd_spin, text=1) view.append_column(col1) this.add(view)
def __init__(self): Gtk.Window.__init__(self, title="CellRendererSpin Example") self.set_default_size(200, 200) self.liststore = Gtk.ListStore(str, int) self.liststore.append(["Oranges", 5]) self.liststore.append(["Apples", 4]) self.liststore.append(["Bananas", 2]) treeview = Gtk.TreeView(model = self.liststore) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Fruit", renderer_text, text=0) treeview.append_column(column_text) renderer_spin = Gtk.CellRendererSpin() renderer_spin.connect("edited", self.on_amount_edited) renderer_spin.set_property("editable", True) adjustment = Gtk.Adjustment(0, 0, 100, 1, 10, 0) renderer_spin.set_property("adjustment", adjustment) column_spin = Gtk.TreeViewColumn("Amount", renderer_spin, text=1) treeview.append_column(column_spin) self.add(treeview)
def __init__(self): Gtk.Window.__init__(self) self.set_title("CellRendererSpin") self.set_default_size(150, -1) self.connect("destroy", Gtk.main_quit) self.liststore = Gtk.ListStore(str, int) self.liststore.append(["Oranges", 5]) self.liststore.append(["Bananas", 2]) self.liststore.append(["Apples", 3]) treeview = Gtk.TreeView() treeview.set_model(self.liststore) self.add(treeview) cellrenderertext = Gtk.CellRendererText() adjustment = Gtk.Adjustment(0, 0, 10, 1, 1, 0) cellrendererspin = Gtk.CellRendererSpin() cellrendererspin.set_property("editable", True) cellrendererspin.set_property("adjustment", adjustment) cellrendererspin.connect("edited", self.on_cell_edited) treeviewcolumn = Gtk.TreeViewColumn("Fruit") treeview.append_column(treeviewcolumn) treeviewcolumn.pack_start(cellrenderertext, False) treeviewcolumn.add_attribute(cellrenderertext, "text", 0) treeviewcolumn = Gtk.TreeViewColumn("Quantity") treeview.append_column(treeviewcolumn) treeviewcolumn.pack_start(cellrendererspin, False) treeviewcolumn.add_attribute(cellrendererspin, "text", 1)
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 __init__(self, GUI): Gtk.Box.__init__(self) self.GUI = GUI self.liststore = Gtk.ListStore(str, int, int) self.liststore.append(["Apple", 0, 100]) self.liststore.append(["Pear", 0, 100]) self.liststore.append(["Orange", 0, 100]) treeview = Gtk.TreeView(model=self.liststore) filter_name = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Fruit is good", filter_name, text=0) treeview.append_column(column_text) self.filter_low = Gtk.CellRendererSpin() self.filter_low.connect("edited", self.low_on_amount_edited) self.filter_low.set_property("editable", True) low_adjustment = Gtk.Adjustment(0, 0, 99, 1, 10, 0) self.filter_low.set_property("adjustment", low_adjustment) low_spin = Gtk.TreeViewColumn("Random Number", self.filter_low, text=1) treeview.append_column(low_spin) self.add(treeview)
def __init__(self): Gtk.TreeView.__init__(self) self.set_headers_visible(True) adj = Gtk.Adjustment(step_increment=1, upper=1000) number_renderer = Gtk.CellRendererSpin(editable=True, adjustment=adj) number_renderer.connect("edited", self.on_number_edited) number_column = Gtk.TreeViewColumn(title=_("Button Number"), cell_renderer=number_renderer, text=0) self.append_column(number_column) text_renderer = Gtk.CellRendererText(editable=True) text_renderer.connect("edited", self.on_label_edited) text_column = Gtk.TreeViewColumn(title=_("Button Label"), cell_renderer=text_renderer, text=1) text_column.set_expand(True) text_column.set_cell_data_func(text_renderer, self.label_data_func) self.append_column(text_column) text_renderer = Gtk.CellRendererText(editable=True) text_renderer.connect("edited", self.on_text_edited) text_column = Gtk.TreeViewColumn(title=_("Snippet Text"), cell_renderer=text_renderer, text=2) text_column.set_expand(True) text_column.set_cell_data_func(text_renderer, self.text_data_func) self.append_column(text_column) self.update() config.snippets_notify_add(self.on_snippets_changed)
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 __init__(self, GUI, g): Gtk.Box.__init__(self) self.GUI = GUI self.g = g self.liststore = Gtk.ListStore(str, int, int) self.liststore.append(["Out-degree", 0, 100]) self.liststore.append(["In-degree", 0, 100]) self.liststore.append(["# of neighbors", 0, 100]) self.liststore.append(["Page Rank", 0, 100]) self.liststore.append(["Betweenness", 0, 100]) self.liststore.append(["Closeness", 0, 100]) self.liststore.append(["Eigenvector", 0, 100]) self.liststore.append(["Authority centrality", 0, 100]) self.liststore.append(["Hub centrality", 0, 100]) treeview = Gtk.TreeView(model=self.liststore) filter_name = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Vertex Filters", filter_name, text=0) treeview.append_column(column_text) self.filter_low = Gtk.CellRendererSpin() self.filter_low.connect("edited", self.low_on_amount_edited) self.filter_low.set_property("editable", True) self.filter_high = Gtk.CellRendererSpin() self.filter_high.connect("edited", self.high_on_amount_edited) self.filter_high.set_property("editable", True) low_adjustment = Gtk.Adjustment(0, 0, 99, 1, 10, 0) self.filter_low.set_property("adjustment", low_adjustment) high_adjustment = Gtk.Adjustment(100, 1, 100, 1, 10, 0) self.filter_high.set_property("adjustment", high_adjustment) low_spin = Gtk.TreeViewColumn("Lower bound (%)", self.filter_low, text=1) high_spin = Gtk.TreeViewColumn("Upper bound (%)", self.filter_high, text=2) treeview.append_column(low_spin) treeview.append_column(high_spin) self.add(treeview)
def setup_tree_view(self, treeview): adj = Gtk.Adjustment.new(0.0, 0.0, 100.0, 1.0, 2.0, 2.0) renderer = Gtk.CellRendererSpin(editable=True, adjustment=adj, digits=0) 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 add_columns(tree_view, df_py_dtypes, list_store): """ Add columns to a `Gtk.TreeView` for the types listed in `df_py_dtypes`. Args: tree_view (Gtk.TreeView) : Tree view to append columns to. df_py_dtypes (pandas.DataFrame) : Data frame containing type information for one or more columns in `list_store`. list_store (Gtk.ListStore) : Model data. Returns: None """ tree_view.set_model(list_store) for column_i, (i, dtype_i) in df_py_dtypes[['i', 'dtype']].iterrows(): tree_column_i = Gtk.TreeViewColumn(column_i) tree_column_i.set_name(column_i) if dtype_i in (int, int): property_name = 'text' cell_renderer_i = Gtk.CellRendererSpin() elif dtype_i == float: property_name = 'text' cell_renderer_i = Gtk.CellRendererSpin() elif dtype_i in (bool, ): property_name = 'active' cell_renderer_i = Gtk.CellRendererToggle() elif dtype_i in (str, ): property_name = 'text' cell_renderer_i = Gtk.CellRendererText() else: raise ValueError('No cell renderer for dtype: %s' % dtype_i) cell_renderer_i.set_data('column_i', i) cell_renderer_i.set_data('column', tree_column_i) tree_column_i.pack_start(cell_renderer_i, True) tree_column_i.add_attribute(cell_renderer_i, property_name, i) tree_view.append_column(tree_column_i)
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 _build_treeview(self): list_store = self._build_list_store() treeview = gtk.TreeView(list_store) #create hidden id column col = gtk.TreeViewColumn('ID', gtk.CellRendererText(), text=0) col.set_visible(False) col.set_resizable(True) treeview.append_column(col) col_names = ['Time', 'Phrase', 'Speakers', 'Target Listeners'] for i in range(len(col_names)): col = gtk.TreeViewColumn(col_names[i], gtk.CellRendererText(), text=(i + 1)) col.set_resizable(True) treeview.append_column(col) spin_renderer = gtk.CellRendererSpin() adj = gtk.Adjustment(value=1, lower=0, upper=100, page_incr=5, step_incr=1, page_size=0) spin_renderer.set_property('adjustment', adj) spin_renderer.set_property('editable', True) spin_renderer.connect('edited', self._update_row, treeview) col = gtk.TreeViewColumn('WHQ Count', spin_renderer, text=(len(col_names) + 1)) col.set_resizable(True) treeview.append_column(col) for i in range(len(self.count_cols)): col = gtk.TreeViewColumn(self.count_cols[i][0], gtk.CellRendererText(), text=(len(col_names) + 2 + i)) col.set_resizable(True) treeview.append_column(col) treeview.connect('key-press-event', self._keypress_callback, treeview) return treeview
def _build_model(self, direction): label1 = {'vertical' : _("#Col"), 'horizontal' : _("#Row")} label2 = {'vertical' : _("Width in %"), 'horizontal' : _("Height in %")} split_count = self.split_count[direction] for s in range(1, split_count + 1): self.model[direction].append([s, 100 // split_count]) treeview = Gtk.TreeView(model=self.model[direction]) cr = Gtk.CellRendererText() heading = Gtk.TreeViewColumn(label1[direction], cr, text=0) treeview.append_column(heading) cr = Gtk.CellRendererSpin() cr.connect("edited", self._edited, direction) cr.set_property("editable", True) adjustment = Gtk.Adjustment(value=100, lower=0, upper=100, step_increment=1) cr.set_property("adjustment", adjustment) heading = Gtk.TreeViewColumn(label2[direction], cr, text=1) treeview.append_column(heading) return treeview
def build_data_stores(self): """Build stores for GUI dataviews""" self.store = dict() # custom icons self.ied = {'Name': 0, 'State': 1} self.store['custom_icons'] = Gtk.ListStore(str, bool) self.store['custom_icons'].append(["Simple Icon Group", False]) renderer_toggle = Gtk.CellRendererToggle() renderer_toggle.connect("toggled", self.on_custom_icon_toggled) self.gui['custom_icons_treeview'].append_column( Gtk.TreeViewColumn("Name", Gtk.CellRendererText(), text=0)) self.gui['custom_icons_treeview'].append_column( Gtk.TreeViewColumn("State", renderer_toggle, active=1)) self.gui['custom_icons_treeview'].set_model(self.store['custom_icons']) # color list self.ced = {'Color': 0, 'Alpha': 1, 'Offset': 2, 'RGBA': 3} colorstore_visible_keys = [k for k in self.ced.keys() if k != 'RGBA'] self.store['colorlist'] = Gtk.ListStore(str, float, int, str) for key in sorted(colorstore_visible_keys, key=lambda k: self.ced[k]): self.gui['colorlist_treeview'].append_column( Gtk.TreeViewColumn(key, Gtk.CellRendererText(), text=self.ced[key])) self.gui['colorlist_treeview'].set_model(self.store['colorlist']) # gradient direction self.ded = {'Coord': 0, 'Value': 1} self.store['direction'] = Gtk.ListStore(str, int) self.gui['renderer_spin'] = Gtk.CellRendererSpin( editable=True, adjustment=Gtk.Adjustment(0, 0, 100, 5, 0, 0)) self.signals['direction_edited'] = self.gui['renderer_spin'].connect( "edited", self.on_direction_edited) self.gui['direction_treeview'].append_column( Gtk.TreeViewColumn("Coord", Gtk.CellRendererText(), text=0)) self.gui['direction_treeview'].append_column( Gtk.TreeViewColumn("Value", self.gui['renderer_spin'], text=1)) self.gui['direction_treeview'].set_model(self.store['direction'])
def __init__(self, parent, application): SettingsPage.__init__(self, parent, application, 'item_list', _('Item List')) notebook = Gtk.Notebook() # create frames label_look_and_feel = Gtk.Label(label=_('Look & feel')) label_hidden_files = Gtk.Label(label=_('Hidden files')) label_operation = Gtk.Label(label=_('Operation')) label_directories = Gtk.Label(label=_('Directories')) label_columns = Gtk.Label(label=_('Columns')) # vertical boxes vbox_look_and_feel = Gtk.VBox(False, 0) vbox_hidden_files = Gtk.VBox(False, 0) vbox_operation = Gtk.VBox(False, 0) vbox_directory = Gtk.VBox(False, 0) vbox_columns = Gtk.VBox(False, 0) vbox_look_and_feel.set_border_width(5) vbox_hidden_files.set_border_width(5) vbox_operation.set_border_width(5) vbox_directory.set_border_width(5) vbox_directory.set_spacing(5) vbox_columns.set_border_width(5) # file list options self._checkbox_row_hinting = Gtk.CheckButton(_('Row hinting')) self._checkbox_case_sensitive = Gtk.CheckButton( _('Case sensitive item sorting')) self._checkbox_number_sensitive = Gtk.CheckButton( _('Number sensitive item sorting')) self._checkbox_single_click = Gtk.CheckButton( _('Single click navigation')) self._checkbox_right_click = Gtk.CheckButton( _('Right click selects items')) self._checkbox_show_headers = Gtk.CheckButton(_('Show list headers')) self._checkbox_media_preview = Gtk.CheckButton(_('Fast media preview')) self._checkbox_show_expanders = Gtk.CheckButton( _('Show tree expanders')) self._checkbox_second_extension = Gtk.CheckButton( _('Support second level extension')) self._checkbox_row_hinting.connect('toggled', self._parent.enable_save) self._checkbox_case_sensitive.connect('toggled', self._parent.enable_save) self._checkbox_number_sensitive.connect('toggled', self._parent.enable_save) self._checkbox_single_click.connect('toggled', self._parent.enable_save) self._checkbox_right_click.connect('toggled', self._parent.enable_save) self._checkbox_show_headers.connect('toggled', self._parent.enable_save) self._checkbox_media_preview.connect('toggled', self._parent.enable_save) self._checkbox_show_expanders.connect('toggled', self._parent.enable_save) self._checkbox_second_extension.connect('toggled', self._parent.enable_save) # file access mode format hbox_mode_format = Gtk.HBox(False, 5) label_mode_format = Gtk.Label(label=_('Access mode format:')) label_mode_format.set_alignment(0, 0.5) self._combobox_mode_format = Gtk.ComboBoxText.new() self._combobox_mode_format.connect('changed', self._parent.enable_save) self._combobox_mode_format.append(str(AccessModeFormat.OCTAL), _('Octal')) self._combobox_mode_format.append(str(AccessModeFormat.TEXTUAL), _('Textual')) # grid lines hbox_grid_lines = Gtk.HBox(False, 5) label_grid_lines = Gtk.Label(label=_('Show grid lines:')) label_grid_lines.set_alignment(0, 0.5) self._combobox_grid_lines = Gtk.ComboBoxText.new() self._combobox_grid_lines.connect('changed', self._parent.enable_save) self._combobox_grid_lines.append(str(Gtk.TreeViewGridLines.NONE), _('None')) self._combobox_grid_lines.append(str(Gtk.TreeViewGridLines.HORIZONTAL), _('Horizontal')) self._combobox_grid_lines.append(str(Gtk.TreeViewGridLines.VERTICAL), _('Vertical')) self._combobox_grid_lines.append(str(Gtk.TreeViewGridLines.BOTH), _('Both')) # selection color hbox_selection_color = Gtk.HBox(False, 5) label_selection_color = Gtk.Label(label=_('Selection color:')) label_selection_color.set_alignment(0, 0.5) self._button_selection_color = Gtk.ColorButton() self._button_selection_color.set_use_alpha(False) self._button_selection_color.connect('color-set', self._parent.enable_save) # selection indicator hbox_indicator = Gtk.HBox(False, 5) label_indicator = Gtk.Label(label=_('Selection indicator:')) label_indicator.set_alignment(0, 0.5) self._combobox_indicator = Gtk.ComboBoxText.new_with_entry() self._combobox_indicator.connect('changed', self._parent.enable_save) self._combobox_indicator.set_size_request(100, -1) self._combobox_indicator.append_text(u'\u25b6', ) self._combobox_indicator.append_text(u'\u25e2', ) self._combobox_indicator.append_text(u'\u25c8', ) self._combobox_indicator.append_text(u'\u263b', ) self._combobox_indicator.append_text(u'\u2771', ) self._combobox_indicator.append_text(u'\u2738', ) self._combobox_indicator.append_text(u'\u2731', ) # quick search label_quick_search = Gtk.Label(label=_('Quick search combination:')) label_quick_search.set_alignment(0, 0.5) label_quick_search.set_use_markup(True) self._checkbox_control = Gtk.CheckButton(_('Control')) self._checkbox_alt = Gtk.CheckButton(_('Alt')) self._checkbox_shift = Gtk.CheckButton(_('Shift')) self._checkbox_control.connect('toggled', self._parent.enable_save) self._checkbox_alt.connect('toggled', self._parent.enable_save) self._checkbox_shift.connect('toggled', self._parent.enable_save) hbox_quick_search = Gtk.HBox(False, 5) vbox_time_format = Gtk.VBox(False, 0) label_time_format = Gtk.Label(label=_('Date format:')) label_time_format.set_alignment(0, 0.5) self._entry_time_format = Gtk.Entry() self._entry_time_format.set_tooltip_markup( '<b>' + _('Time is formed using the format located at:') + '</b>\n' 'http://docs.python.org/library/time.html#time.strftime') self._entry_time_format.connect('changed', self._parent.enable_save) # hidden files table_always_visible = Gtk.Table(rows=3, columns=1, homogeneous=False) table_always_visible.set_row_spacing(1, 5) self._checkbox_show_hidden = Gtk.CheckButton(_('Show hidden files')) self._checkbox_show_hidden.connect('toggled', self._parent.enable_save) container_always_visible = Gtk.ScrolledWindow() container_always_visible.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS) container_always_visible.set_shadow_type(Gtk.ShadowType.IN) label_always_visible = Gtk.Label( label=_('Always visible files and directories:')) label_always_visible.set_alignment(0, 0.5) self._always_visible_store = Gtk.ListStore(str) self._always_visible_list = Gtk.TreeView( model=self._always_visible_store) self._always_visible_list.set_headers_visible(False) cell_name = Gtk.CellRendererText() col_name = Gtk.TreeViewColumn(None, cell_name, text=0) self._always_visible_list.append_column(col_name) hbox_always_visible = Gtk.HBox(False, 5) button_add_always_visible = Gtk.Button(stock=Gtk.STOCK_ADD) button_add_always_visible.connect('clicked', self._add_always_visible) button_delete_always_visible = Gtk.Button(stock=Gtk.STOCK_DELETE) button_delete_always_visible.connect('clicked', self._delete_always_visible) # create list of directories container_directory = Gtk.ScrolledWindow() container_directory.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS) container_directory.set_shadow_type(Gtk.ShadowType.IN) self._checkbox_load_directories = Gtk.CheckButton( _('Load specified tabs instead of saved')) self._checkbox_load_directories.connect('toggled', self._parent.enable_save) self._directory_store = Gtk.ListStore(str, bool, bool) self._directory_list = Gtk.TreeView(model=self._directory_store) cell_directory = Gtk.CellRendererText() cell_left_list = Gtk.CellRendererToggle() cell_right_list = Gtk.CellRendererToggle() cell_left_list.connect('toggled', self._toggle_path, Source.LEFT) cell_right_list.connect('toggled', self._toggle_path, Source.RIGHT) col_directory = Gtk.TreeViewColumn(_('Directory'), cell_directory, text=DirectoryColumn.PATH) col_directory.set_min_width(200) col_directory.set_resizable(True) col_directory.set_expand(True) col_left_list = Gtk.TreeViewColumn(_('Left list'), cell_left_list, active=DirectoryColumn.LEFT_LIST) col_right_list = Gtk.TreeViewColumn(_('Right list'), cell_right_list, active=DirectoryColumn.RIGHT_LIST) self._directory_list.append_column(col_directory) self._directory_list.append_column(col_left_list) self._directory_list.append_column(col_right_list) hbox_directory = Gtk.HBox(False, 5) button_add_directory = Gtk.Button(stock=Gtk.STOCK_ADD) button_add_directory.connect('clicked', self.__button_add_clicked) button_delete_directory = Gtk.Button(stock=Gtk.STOCK_DELETE) button_delete_directory.connect('clicked', self._delete_path) image_up = Gtk.Image() image_up.set_from_stock(Gtk.STOCK_GO_UP, Gtk.IconSize.BUTTON) button_directory_move_up = Gtk.Button(label=None) button_directory_move_up.add(image_up) button_directory_move_up.set_tooltip_text(_('Move Up')) button_directory_move_up.connect('clicked', self._move_path, -1) image_down = Gtk.Image() image_down.set_from_stock(Gtk.STOCK_GO_DOWN, Gtk.IconSize.BUTTON) button_directory_move_down = Gtk.Button(label=None) button_directory_move_down.add(image_down) button_directory_move_down.set_tooltip_text(_('Move Down')) button_directory_move_down.connect('clicked', self._move_path, 1) self._menu_add_directory = Gtk.Menu() menu_item_custom = Gtk.MenuItem(_('Custom directory')) menu_item_separator = Gtk.SeparatorMenuItem() menu_item_left_directory = Gtk.MenuItem(_('Left directory')) menu_item_right_directory = Gtk.MenuItem(_('Right directory')) menu_item_custom.connect('activate', self._add_path, Source.CUSTOM) menu_item_left_directory.connect('activate', self._add_path, Source.LEFT) menu_item_right_directory.connect('activate', self._add_path, Source.RIGHT) self._menu_add_directory.append(menu_item_custom) self._menu_add_directory.append(menu_item_separator) self._menu_add_directory.append(menu_item_left_directory) self._menu_add_directory.append(menu_item_right_directory) self._menu_add_directory.show_all() # create columns editor hbox_columns = Gtk.HBox(False, 5) container_columns = Gtk.ScrolledWindow() container_columns.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS) container_columns.set_shadow_type(Gtk.ShadowType.IN) container_plugin = Gtk.ScrolledWindow() container_plugin.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) container_plugin.set_shadow_type(Gtk.ShadowType.IN) container_plugin.set_size_request(170, -1) # create variable to store active extension to self._extensions = {} self._active_extension = None # create column list self._columns_store = Gtk.ListStore(str, int, bool, str) self._columns_list = Gtk.TreeView() self._columns_list.set_model(self._columns_store) self._columns_list.set_rules_hint(True) self._columns_list.set_enable_search(True) self._columns_list.set_search_column(Column.NAME) cell_name = Gtk.CellRendererText() cell_size = Gtk.CellRendererText() cell_visible = Gtk.CellRendererToggle() cell_font_size = Gtk.CellRendererSpin() cell_size.set_property('editable', True) cell_size.set_property('mode', Gtk.CellRendererMode.EDITABLE) cell_size.connect('edited', self._edited_column_size) cell_font_size.set_property('editable', True) cell_font_size.set_property('mode', Gtk.CellRendererMode.EDITABLE) adjustment = Gtk.Adjustment(0, 0, 100, 1, 10, 0) cell_font_size.set_property('adjustment', adjustment) cell_font_size.connect('edited', self._edited_column_font_size) cell_visible.connect('toggled', self._toggle_column_visible) col_name = Gtk.TreeViewColumn(_('Column'), cell_name, text=Column.NAME) col_name.set_min_width(150) col_name.set_resizable(True) col_name.set_expand(True) col_size = Gtk.TreeViewColumn(_('Size'), cell_size, text=Column.SIZE) col_size.set_min_width(50) col_visible = Gtk.TreeViewColumn(_('Visible'), cell_visible, active=Column.VISIBLE) col_visible.set_min_width(50) col_font_size = Gtk.TreeViewColumn(_('Font'), cell_font_size, text=Column.FONT_SIZE) col_font_size.set_min_width(50) self._columns_list.append_column(col_name) self._columns_list.append_column(col_size) self._columns_list.append_column(col_font_size) self._columns_list.append_column(col_visible) # create plugin list self._extension_store = Gtk.ListStore(str, str) self._extension_list = Gtk.TreeView() self._extension_list.set_model(self._extension_store) self._extension_list.set_headers_visible(False) self._extension_list.connect('cursor-changed', self._handle_cursor_change) cell_name = Gtk.CellRendererText() col_name = Gtk.TreeViewColumn(None, cell_name, text=ExtensionColumn.NAME) self._extension_list.append_column(col_name) # pack interface container_directory.add(self._directory_list) container_columns.add(self._columns_list) container_plugin.add(self._extension_list) container_always_visible.add(self._always_visible_list) hbox_always_visible.pack_start(button_add_always_visible, False, False, 0) hbox_always_visible.pack_start(button_delete_always_visible, False, False, 0) table_always_visible.attach(label_always_visible, 0, 1, 0, 1, xoptions=Gtk.AttachOptions.SHRINK | Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.SHRINK) table_always_visible.attach( container_always_visible, 0, 1, 1, 2, xoptions=Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL) table_always_visible.attach(hbox_always_visible, 0, 1, 2, 3, xoptions=Gtk.AttachOptions.SHRINK | Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.SHRINK) hbox_directory.pack_start(button_add_directory, False, False, 0) hbox_directory.pack_start(button_delete_directory, False, False, 0) hbox_directory.pack_end(button_directory_move_down, False, False, 0) hbox_directory.pack_end(button_directory_move_up, False, False, 0) hbox_columns.pack_start(container_plugin, False, False, 0) hbox_columns.pack_start(container_columns, True, True, 0) hbox_indicator.pack_start(label_indicator, False, False, 0) hbox_indicator.pack_start(self._combobox_indicator, False, False, 0) hbox_selection_color.pack_start(label_selection_color, False, False, 0) hbox_selection_color.pack_start(self._button_selection_color, False, False, 0) hbox_quick_search.pack_start(label_quick_search, False, False, 0) hbox_quick_search.pack_start(self._checkbox_control, False, False, 0) hbox_quick_search.pack_start(self._checkbox_alt, False, False, 0) hbox_quick_search.pack_start(self._checkbox_shift, False, False, 0) hbox_mode_format.pack_start(label_mode_format, False, False, 0) hbox_mode_format.pack_start(self._combobox_mode_format, False, False, 0) hbox_grid_lines.pack_start(label_grid_lines, False, False, 0) hbox_grid_lines.pack_start(self._combobox_grid_lines, False, False, 0) vbox_time_format.pack_start(label_time_format, False, False, 0) vbox_time_format.pack_start(self._entry_time_format, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_row_hinting, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_show_headers, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_media_preview, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_show_expanders, False, False, 0) vbox_look_and_feel.pack_start(hbox_mode_format, False, False, 5) vbox_look_and_feel.pack_start(hbox_grid_lines, False, False, 5) vbox_look_and_feel.pack_start(hbox_selection_color, False, False, 5) vbox_look_and_feel.pack_start(hbox_indicator, False, False, 5) vbox_hidden_files.pack_start(self._checkbox_show_hidden, False, False, 0) vbox_hidden_files.pack_start(table_always_visible, True, True, 0) vbox_operation.pack_start(self._checkbox_case_sensitive, False, False, 0) vbox_operation.pack_start(self._checkbox_number_sensitive, False, False, 0) vbox_operation.pack_start(self._checkbox_single_click, False, False, 0) vbox_operation.pack_start(self._checkbox_right_click, False, False, 0) vbox_operation.pack_start(self._checkbox_second_extension, False, False, 0) vbox_operation.pack_start(hbox_quick_search, False, False, 5) vbox_operation.pack_start(vbox_time_format, False, False, 5) vbox_directory.pack_start(self._checkbox_load_directories, False, False, 0) vbox_directory.pack_start(container_directory, True, True, 0) vbox_directory.pack_start(hbox_directory, False, False, 0) vbox_columns.pack_start(hbox_columns, True, True, 0) notebook.append_page(vbox_look_and_feel, label_look_and_feel) notebook.append_page(vbox_hidden_files, label_hidden_files) notebook.append_page(vbox_operation, label_operation) notebook.append_page(vbox_directory, label_directories) notebook.append_page(vbox_columns, label_columns) self.pack_start(notebook, True, True, 0)
def __init__(self, parent, setup_table, model, module, cmd_manager=None): """Create an new instance of a SetupDialog.""" Gtk.Dialog.__init__(self, _("Edit Setup Matrix"), parent, Gtk.DialogFlags.DESTROY_WITH_PARENT, (Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)) self.setup_table = setup_table self.cmd = cmd_manager self.setup_model = Gtk.ListStore(str, str, str) program_model = Gtk.ListStore(str) for p in module.properties['program_table'].keys(): program_model.append([p]) self.setup_default_spin = Gtk.SpinButton( digits=1, adjustment=Gtk.Adjustment(value=float( self.setup_table.default_time), lower=0., upper=10000., step_incr=1.)) self.setup_default_spin.connect('changed', self.apply_change) for row in self.setup_table.items(): self.setup_model.append(row) self.treeview = Gtk.TreeView(self.setup_model) self.treeview.connect('key-press-event', self.on_key_pressed_event, self.treeview.get_selection()) self.treeview.connect('button-press-event', self.on_button_press_event) default_time_box = Gtk.HBox() default_time_box.pack_start(Gtk.Label(_("Default setup time:")), False, False, 0) default_time_box.pack_start(self.setup_default_spin, False, False, 0) self.vbox.pack_start(default_time_box, False, False, 0) self.vbox.pack_start(self.treeview, False, False, 0) #rendering as combo for col 1 col_init_render = Gtk.CellRendererCombo() col_init_render.set_property('editable', True) col_init_render.set_property('text-column', 0) col_init_render.set_property('model', program_model) column = Gtk.TreeViewColumn('Initial', col_init_render, text=0) column.set_expand(True) self.treeview.append_column(column) col_init_render.connect('edited', self.apply_change_init) #rendering as combo for col 2 col_final_render = Gtk.CellRendererCombo() col_final_render.set_property('editable', True) col_final_render.set_property('text-column', 0) col_final_render.set_property('model', program_model) column = Gtk.TreeViewColumn('Final', col_final_render, text=1) column.set_expand(True) self.treeview.append_column(column) col_final_render.connect("edited", self.apply_change_final) #rendering with spin for col 3 spin_cell_render = Gtk.CellRendererSpin() spin_cell_render.set_property('editable', True) spin_cell_render.set_property('digits', 1) adjust = Gtk.Adjustment(lower=0, step_incr=0.1, page_incr=1, upper=10000) spin_cell_render.set_property('adjustment', adjust) column = Gtk.TreeViewColumn('Delay', spin_cell_render, text=2) column.set_expand(True) self.treeview.append_column(column) spin_cell_render.connect('edited', self.apply_change_delay) self.connect('response', self.close) self.connect('delete-event', self.delete_event) self.show_all()
def __init__(self, nCliente): """ Constructor que genera la interfaz del apartado de compras :param nCliente: Número de cliente que ha iniciado sesión recibido de la clase Login """ Gtk.Window.__init__(self, title="Ventana de Compras") self.cajaProductos = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6) """ Iniciamos la conexión a la base de datos. Seleccionamos todos los datos de la tabla productos :param bbdd: Parámetro que conecta a la base de datos :param cursor: Cursor con el que recibimos datos de la base de datos. """ self.bbdd = dbapi2.connect("TiendaInformatica.db") self.cursor = self.bbdd.cursor() self.cursor.execute("select * from productos") """ Creamos un modelo al que le pasamos los tipos de valores de cada dato de la tabla modelo: Lista que recibe los datos de la tabla para añadirlo al TreeView """ self.modelo = Gtk.ListStore(int, str, int, int) """ Rellenamos el modelo recorriendo el cursor con un for """ for rellenarModelo in self.cursor: codigo = rellenarModelo[0] nombre = rellenarModelo[1] precio = rellenarModelo[3] self.modelo.append([codigo, nombre, precio, 1]) """ vista: TreeView que contendrá los productos celdaText: CellRendererText que recibirá los valores columnaCodigo: columna del TreeView que contiene el codigo columnaNombre: columna del TreeView que contiene el nombre columnaPrecio: columna del TreeView que contiene el precio columnaCantidad: columna del TreeView que contiene la cantidad. """ self.vista = Gtk.TreeView() celdaText = Gtk.CellRendererText() columnaCodigo = Gtk.TreeViewColumn('Codigo', celdaText, text=0) self.vista.append_column(columnaCodigo) celdaText2 = Gtk.CellRendererText(xalign=1) columnaNombre = Gtk.TreeViewColumn('Nombre', celdaText2, text=1) self.vista.append_column(columnaNombre) celdaText3 = Gtk.CellRendererText(xalign=1) columnaPrecio = Gtk.TreeViewColumn('Precio', celdaText3, text=2) self.vista.append_column(columnaPrecio) """ renderer_spin: Es un SpinButton que lo que hace es poder sumar +1 o restar -1 la cantidad. Se le establece la propiedrad adjustement. """ renderer_spin = Gtk.CellRendererSpin() renderer_spin.connect("edited", self.on_amount_edited) renderer_spin.set_property("editable", True) adjustment = Gtk.Adjustment(0, 0, 100, 1, 10, 0) renderer_spin.set_property("adjustment", adjustment) columnaCantidad = Gtk.TreeViewColumn('Cantidad', renderer_spin, text=3) self.vista.append_column(columnaCantidad) self.vista.set_model(self.modelo) """ Hacemos que la variable nCliente pase a ser variable self de la clase """ self.codcli = nCliente boComprar = Gtk.Button("Comprar") boComprar.connect('clicked', self.on_boComprar_clicked) boFinalizar = Gtk.Button("Finalizar Pedido") boFinalizar.connect('clicked', self.on_boFinalizar_clicked) self.cajaProductos.pack_start(self.vista, True, True, 0) self.cajaProductos.pack_start(boComprar, True, True, 0) self.cajaProductos.pack_start(boFinalizar, True, True, 0) self.add(self.cajaProductos) self.show_all()
def load(self, gmwidg): self.gmwidg = gmwidg self.boardview = gmwidg.board.view self.sw = Gtk.ScrolledWindow() self.tv = Gtk.TreeView() self.tv.set_property("headers_visible", False) self.sw.add(self.tv) self.sw.show_all() self.store = Gtk.TreeStore(GObject.TYPE_PYOBJECT, GObject.TYPE_PYOBJECT, int, bool, str, bool, bool) self.tv.set_model(self.store) # ## move suggested moveRenderer = Gtk.CellRendererText() moveRenderer.set_property("xalign", 1.0) moveRenderer.set_property("yalign", 0) c0 = Gtk.TreeViewColumn("Move", moveRenderer) def getMoveText(column, cell, store, iter, data): board, move, pv = store[iter][0] if not move: cell.set_property("text", "") else: if conf.get("figuresInNotation", False): cell.set_property("text", toFAN(board, move)) else: cell.set_property("text", toSAN(board, move, True)) c0.set_cell_data_func(moveRenderer, getMoveText) # ## strength of the move c1 = Gtk.TreeViewColumn("Strength", StrengthCellRenderer(), data=1) # ## multipv (number of analysis lines) self.multipvRenderer = Gtk.CellRendererSpin() adjustment = Gtk.Adjustment(value=conf.get("multipv", 1), lower=1, upper=9, step_incr=1) self.multipvRenderer.set_property("adjustment", adjustment) self.multipvRenderer.set_property("editable", True) self.multipvRenderer.set_property("width_chars", 1) c2 = Gtk.TreeViewColumn("PV", self.multipvRenderer, editable=3) c2.set_property("min_width", 80) def spin_visible(column, cell, store, iter, data): if store[iter][2] == 0: cell.set_property('visible', False) else: cell.set_property("text", str(store[iter][2])) cell.set_property('visible', True) c2.set_cell_data_func(self.multipvRenderer, spin_visible) def multipv_edited(renderer, path, text): iter = self.store.get_iter(path) self.store.set_value(iter, 2, int(text)) self.advisors[int(path[0])].multipv_edited(int(text)) self.multipv_cid = self.multipvRenderer.connect( 'edited', multipv_edited) # ## start/stop button for analysis engines self.toggleRenderer = CellRendererPixbufXt() self.toggleRenderer.set_property("stock-id", "gtk-add") c4 = Gtk.TreeViewColumn("StartStop", self.toggleRenderer) def cb_visible(column, cell, store, iter, data): if not store[iter][6]: cell.set_property('visible', False) else: cell.set_property('visible', True) if store[iter][5]: cell.set_property("stock-id", "gtk-add") else: cell.set_property("stock-id", "gtk-remove") c4.set_cell_data_func(self.toggleRenderer, cb_visible) def toggled_cb(cell, path): self.store[path][5] = not self.store[path][5] self.advisors[int(path[0])].start_stop(self.store[path][5]) self.toggle_cid = self.toggleRenderer.connect('clicked', toggled_cb) self.tv.append_column(c4) self.tv.append_column(c0) self.tv.append_column(c1) self.tv.append_column(c2) # ## header text, or analysis line uistuff.appendAutowrapColumn(self.tv, "Details", text=4) self.cid = self.boardview.connect("shownChanged", self.shownChanged) self.tv_cids = [ self.tv.connect("cursor_changed", self.selection_changed), self.tv.connect("select_cursor_row", self.selection_changed), self.tv.connect("row-activated", self.row_activated), self.tv.connect("query-tooltip", self.query_tooltip), ] self.tv.props.has_tooltip = True self.tv.set_property("show-expanders", False) self.advisors = [] self.conf_conids = [] if conf.get("opening_check", 0): self.advisors.append(OpeningAdvisor(self.store, self.tv)) if conf.get("endgame_check", 0): advisor = EndgameAdvisor(self.store, self.tv, self.boardview) self.advisors.append(advisor) self.model_cids = [ gmwidg.gamemodel.connect("analyzer_added", self.on_analyzer_added), gmwidg.gamemodel.connect("analyzer_removed", self.on_analyzer_removed), gmwidg.gamemodel.connect("analyzer_paused", self.on_analyzer_paused), gmwidg.gamemodel.connect("analyzer_resumed", self.on_analyzer_resumed), gmwidg.gamemodel.connect_after("game_terminated", self.on_game_terminated), ] def on_opening_check(none): if conf.get("opening_check", 0) and self.boardview is not None: advisor = OpeningAdvisor(self.store, self.tv) self.advisors.append(advisor) advisor.shownChanged(self.boardview, self.boardview.shown) else: for advisor in self.advisors: if advisor.mode == OPENING: parent = advisor.empty_parent() self.store.remove(parent) self.advisors.remove(advisor) self.conf_conids.append( conf.notify_add("opening_check", on_opening_check)) def on_opening_file_entry_changed(none): default_path = os.path.join(addDataPrefix("pychess_book.bin")) path = conf.get("opening_file_entry", default_path) if os.path.isfile(path): for advisor in self.advisors: if advisor.mode == OPENING and self.boardview is not None: advisor.shownChanged(self.boardview, self.boardview.shown) self.conf_conids.append( conf.notify_add("opening_file_entry", on_opening_file_entry_changed)) def on_endgame_check(none): if conf.get("endgame_check", 0): advisor = EndgameAdvisor(self.store, self.tv, self.boardview) self.advisors.append(advisor) advisor.shownChanged(self.boardview, self.boardview.shown) else: for advisor in self.advisors: if advisor.mode == ENDGAME: advisor._del() parent = advisor.empty_parent() self.store.remove(parent) self.advisors.remove(advisor) self.conf_conids.append( conf.notify_add("endgame_check", on_endgame_check)) return self.sw
def __init__(self, model, add_undo=None, range_factory=RangeFactory(), template=None, reorderable=False, editable_label_prefixes=['External/']): self.add_undo = add_undo self.range_factory = range_factory self.editable_label_prefixes = editable_label_prefixes assert callable(range_factory), 'Generic.range_factory must be callable' if template is not None: self.range_factory.set_template( template ) V = self.view = gtk.TreeView(model) V.set_property( 'rules-hint', True ) sheet_cb = spreadsheet.Callbacks(V) enable = 'ENABLE' in dir(model) if reorderable: V.set_reorderable(True) V.connect('drag-motion', drag_motion) R = { 'label' : GCRT(), 'val:bool' : gtk.CellRendererToggle(), 'val:text' : GCRT(), 'val:int' : gtk.CellRendererSpin(), 'val:float' : gtk.CellRendererSpin(), 'cmb:text' : gtk.CellRendererCombo(), 'cmb:int' : gtk.CellRendererCombo(), 'cmb:float' : gtk.CellRendererCombo(), } R['val:bool' ].set_property( 'activatable', True ) R['val:text' ].set_property( 'editable', True ) R['val:int' ].set_property( 'editable', True ) R['val:float'].set_property( 'editable', True ) R['cmb:text' ].set_property( 'editable', True ) R['cmb:int' ].set_property( 'editable', True ) R['cmb:float'].set_property( 'editable', True ) R['cmb:text' ].set_property( 'text-column', 0 ) R['cmb:int' ].set_property( 'text-column', 0 ) R['cmb:float'].set_property( 'text-column', 0 ) R['cmb:text' ].set_property( 'has-entry', False ) R['cmb:int' ].set_property( 'has-entry', False ) R['cmb:float'].set_property( 'has-entry', False ) R['val:int' ].set_property( 'adjustment', gtk.Adjustment(0,0,100,1,10,0) ) R['val:float'].set_property( 'adjustment', gtk.Adjustment(0,0,100,1,10,0) ) R['val:int' ].connect('editing-started', set_range, model) R['val:float'].connect('editing-started', set_range, model) R['cmb:text'].connect( 'editing-started', load_combobox, model ) R['cmb:int'].connect( 'editing-started', load_combobox, model ) R['cmb:float'].connect( 'editing-started', load_combobox, model ) sheet_cb.connect_column( R['label'], setitem=(helpers.set_item, model, model.LABEL, add_undo, False, str, self.editable_label_prefixes) ) sheet_cb.connect_column( R['val:bool'], toggleitem=(helpers.toggle_item, model, model.VAL_BOOL, add_undo) ) sheet_cb.connect_column( R['val:text'], setitem=(helpers.set_item, model, model.VAL_STR, add_undo) ) sheet_cb.connect_column( R['val:int'], setitem=(helpers.set_item, model, model.VAL_INT, add_undo, False, int) ) sheet_cb.connect_column( R['val:float'], setitem=(helpers.set_item, model, model.VAL_FLOAT, add_undo, False, float) ) sheet_cb.connect_column( R['cmb:text'], setitem=(helpers.set_item, model, model.VAL_STR, add_undo) ) sheet_cb.connect_column( R['cmb:int'], setitem=(helpers.set_item, model, model.VAL_INT, add_undo, False, int) ) sheet_cb.connect_column( R['cmb:float'], setitem=(helpers.set_item, model, model.VAL_FLOAT, add_undo, False, float) ) C = { 'L' : GTVC('Parameter', R['label'], text=0), 'V' : GTVC('Value'), } C['L'].set_clickable(True) C['V'].set_clickable(True) C['V'].pack_start(R['val:bool'],True) C['V'].pack_start(R['val:text'],True) C['V'].pack_start(R['val:int'],True) C['V'].pack_start(R['val:float'],True) C['V'].pack_start(R['cmb:text'],True) C['V'].pack_start(R['cmb:int'],True) C['V'].pack_start(R['cmb:float'],True) C['V'].set_attributes( R['val:bool'], active=model.VAL_BOOL ) C['V'].set_attributes( R['val:text'], text=model.VAL_STR ) C['V'].set_attributes( R['val:int'], text=model.VAL_INT ) C['V'].set_attributes( R['val:float'], text=model.VAL_FLOAT ) C['V'].set_attributes( R['cmb:text'], text=model.VAL_STR ) C['V'].set_attributes( R['cmb:int'], text=model.VAL_INT ) C['V'].set_attributes( R['cmb:float'], text=model.VAL_FLOAT ) def can_edit(treecol, cell, model, i, data ): Ltxt = model[i][model.LABEL] if True in [ Ltxt.startswith(i) for i in self.editable_label_prefixes ]: cell.set_property('editable', True) else: cell.set_property('editable', False) C['L'].set_cell_data_func( R['label'], can_edit ) def is_sensitive( treecol, cell, model, i, TYPE ): combo = False if type(TYPE) in [list,tuple]: TYPE, combo = TYPE show = model[i][model.TYPE] is TYPE if show: if model[i][model.RANGE] is None and self.range_factory is not None: # Create Range class model[i][model.RANGE] = \ self.range_factory( get_config_path(model.get_path(i), model), i, model ) if combo != model[i][model.RANGE].is_combo(): show = False if show and TYPE == float: cell.set_property('text', '%g' % model[i][model.VAL_FLOAT]) cell.set_property('sensitive', show) cell.set_property('visible', show) C['V'].set_cell_data_func( R['val:bool'], is_sensitive, bool ) C['V'].set_cell_data_func( R['val:text'], is_sensitive, str ) C['V'].set_cell_data_func( R['val:int'], is_sensitive, int ) C['V'].set_cell_data_func( R['val:float'], is_sensitive, float ) C['V'].set_cell_data_func( R['cmb:text'], is_sensitive,(str, True)) C['V'].set_cell_data_func( R['cmb:int'], is_sensitive,(int, True)) C['V'].set_cell_data_func( R['cmb:float'], is_sensitive,(float, True)) V.append_column(C['L']) V.append_column(C['V']) if enable: R['enable'] = gtk.CellRendererToggle() R['enable'].set_property('activatable', True) R['enable'].connect('toggled', helpers.toggle_item, model, model.ENABLE, add_undo) C['enable'] = GTVC('Enabled', R['enable']) C['enable'].add_attribute(R['enable'], 'active', model.ENABLE) V.append_column( C['enable'] ) V.show()
window.connect("destroy", lambda q: Gtk.main_quit()) liststore = Gtk.ListStore(str, int) liststore.append(["Orange", 3]) liststore.append(["Apple", 6]) liststore.append(["Banana", 4]) adjustment = Gtk.Adjustment(0, 0, 10, 1, 2, 0) treeview = Gtk.TreeView(model=liststore) window.add(treeview) treeviewcolumn = Gtk.TreeViewColumn("Fruit") treeview.append_column(treeviewcolumn) cellrenderertext = Gtk.CellRendererText() treeviewcolumn.pack_start(cellrenderertext, False) treeviewcolumn.add_attribute(cellrenderertext, "text", 0) treeviewcolumn = Gtk.TreeViewColumn("Quantity") treeview.append_column(treeviewcolumn) cellrendererspin = Gtk.CellRendererSpin() cellrendererspin.set_property("adjustment", adjustment) cellrendererspin.set_property("editable", True) cellrendererspin.connect("edited", value_changed) treeviewcolumn.pack_start(cellrendererspin, False) treeviewcolumn.add_attribute(cellrendererspin, "text", 1) window.show_all() Gtk.main()
def __init_widgets(self): """ Initialize interface widgets """ self.set_size(640, 420) # ------------------------------------ # Grid # ------------------------------------ grid = Gtk.Grid() # Properties grid.set_row_spacing(6) grid.set_column_spacing(12) # ------------------------------------ # Description # ------------------------------------ label = Gtk.Label() label_game = Gtk.Label() # Properties label.set_text( _("This dialog allows you to specify specific backup " "memory type for the following game:")) label.set_line_wrap(True) label.set_max_width_chars(8) label.set_single_line_mode(False) label.set_justify(Gtk.Justification.FILL) label.set_line_wrap_mode(Pango.WrapMode.WORD) label_game.set_text(self.name) label_game.set_margin_bottom(12) label_game.set_single_line_mode(True) label_game.set_ellipsize(Pango.EllipsizeMode.END) label_game.get_style_context().add_class("dim-label") # ------------------------------------ # Buttons # ------------------------------------ buttons = Gtk.Box() self.image_add = Gtk.Image() self.button_add = Gtk.Button() self.image_remove = Gtk.Image() self.button_remove = Gtk.Button() # Properties Gtk.StyleContext.add_class(buttons.get_style_context(), "linked") buttons.set_spacing(-1) buttons.set_orientation(Gtk.Orientation.VERTICAL) self.image_add.set_from_icon_name(Icons.Symbolic.ADD, Gtk.IconSize.MENU) self.button_add.set_image(self.image_add) self.image_remove.set_from_icon_name(Icons.Symbolic.REMOVE, Gtk.IconSize.MENU) self.button_remove.set_image(self.image_remove) # ------------------------------------ # Link # ------------------------------------ link = Gtk.LinkButton() # Properties link.set_label(_("Mednafen GBA documentation")) link.set_uri("https://mednafen.github.io/documentation/gba.html" "#Section_backupmem_type") # ------------------------------------ # Content list # ------------------------------------ frame = Gtk.Frame() scroll = Gtk.ScrolledWindow() view = Gtk.Viewport() self.adjustment_value = Gtk.Adjustment() self.model_memory_keys = Gtk.ListStore(str) self.model = Gtk.ListStore(str, int) self.treeview = Gtk.TreeView() column = Gtk.TreeViewColumn() self.cell_key = Gtk.CellRendererCombo() self.cell_value = Gtk.CellRendererSpin() # Properties self.adjustment_value.set_lower(0) self.adjustment_value.set_upper(2147483647) # INT_MAX self.adjustment_value.set_step_increment(16) self.adjustment_value.set_page_increment(1024) self.treeview.set_hexpand(True) self.treeview.set_vexpand(True) self.treeview.set_model(self.model) self.treeview.set_headers_clickable(False) self.treeview.set_headers_visible(False) self.treeview.set_show_expanders(False) self.treeview.set_has_tooltip(False) column.set_expand(True) column.pack_start(self.cell_key, True) column.pack_start(self.cell_value, True) column.add_attribute(self.cell_key, "text", 0) column.add_attribute(self.cell_value, "text", 1) self.cell_key.set_padding(12, 6) self.cell_key.set_alignment(0, .5) self.cell_key.set_property("text-column", 0) self.cell_key.set_property("editable", True) self.cell_key.set_property("has-entry", False) self.cell_key.set_property("model", self.model_memory_keys) self.cell_value.set_padding(12, 6) self.cell_value.set_alignment(1, .5) self.cell_value.set_property("editable", True) self.cell_value.set_property("adjustment", self.adjustment_value) # ------------------------------------ # Integrate widgets # ------------------------------------ frame.add(self.treeview) scroll.add(view) view.add(grid) self.treeview.append_column(column) buttons.add(self.button_add) buttons.add(self.button_remove) grid.attach(label, 0, 0, 2, 1) grid.attach(label_game, 0, 1, 2, 1) grid.attach(buttons, 0, 2, 1, 1) grid.attach(frame, 1, 2, 1, 1) grid.attach(link, 0, 3, 2, 1) self.pack_start(scroll, True, True)
def __init__(self, lc, ylim_correct=[-42,20], ylim_wrong=[-42,2], cmds=[]): self.lc = lc self.commands = cmds; self.create_queues() self.window = Gtk.Window(title="SenSys'17 - Packetized-LTE PHY") self.window.set_default_size(1200, 900) self.superbox = Gtk.Box() self.window.add(self.superbox) self.boxplot = Gtk.Box() self.superbox.pack_start(self.boxplot, True, True, 0) self.grid = Gtk.Grid() self.superbox.pack_start(self.grid, False, False, 0) self.boxbuttons = Gtk.Box() self.grid.add(self.boxbuttons) self.boxstats = Gtk.Box() self.grid.attach_next_to(self.boxstats, self.boxbuttons, Gtk.PositionType.BOTTOM, 1, 2) button = Gtk.Button.new_with_label("Single Link") button.connect("clicked", self.on_single_radio) self.boxbuttons.pack_start(button, True, True, 0) button = Gtk.Button.new_with_label("LBT Disabled") button.connect("clicked", self.on_lbt_disabled) self.boxbuttons.pack_start(button, True, True, 0) button = Gtk.Button.new_with_label("LBT Enabled") button.connect("clicked", self.on_lbt_enabled) self.boxbuttons.pack_start(button, True, True, 0) self.box = Gtk.Box() self.boxplot.pack_start(self.box, True, True, 0) scale = 10 self.fig = Figure(figsize=(4*scale,3*scale)) self.ax1 = self.fig.add_subplot(2, 1, 1) plt.grid(True) self.ax2 = self.fig.add_subplot(2, 1, 2) plt.grid(True) # draw and show it self.ax1.set_title("Successful Statistics") self.line1_correct, = self.ax1.plot(np.zeros(measure_lbt_performance.CORRECT_ARRAY_SIZE),'b',visible=True,label='RSSI [dBm]') self.line2_correct, = self.ax1.plot(np.zeros(measure_lbt_performance.CORRECT_ARRAY_SIZE),'k',visible=True,label='CQI') self.line3_correct, = self.ax1.plot(np.zeros(measure_lbt_performance.CORRECT_ARRAY_SIZE),'g',visible=True,label='Noise [dBm]') self.ax1.legend() self.ax1.grid(True) self.ax1.set_ylim(ylim_correct) self.ax2.set_title("Unsuccessful Statistics") self.line1_wrong, = self.ax2.plot(np.zeros(measure_lbt_performance.ERROR_ARRAY_SIZE),'b',visible=True,label='RSSI [dBm]') self.line2_wrong, = self.ax2.plot(np.zeros(measure_lbt_performance.ERROR_ARRAY_SIZE),'g',visible=True,label='Noise [dBm]') self.ax2.legend() self.ax2.grid(True) self.ax2.set_ylim(ylim_wrong) self.canvas = FigureCanvas(self.fig) self.canvas.show() self.box.pack_start(self.canvas, True, True, 0) plt.ion() self.liststore_correct_rx = Gtk.ListStore(str, float) self.liststore_correct_rx.append(["In sequence %", 0.0]) self.liststore_correct_rx.append(["Out of sequence %", 0.0]) self.liststore_correct_rx.append(["Correct %", 0.0]) self.liststore_correct_rx.append(["Error %", 0.0]) self.liststore_correct_rx.append(["Channel free %", 0.0]) self.liststore_correct_rx.append(["Channel busy %", 0.0]) self.liststore_correct_rx.append(["Channel free pwr", 0.0]) self.liststore_correct_rx.append(["Channel busy pwr", 0.0]) self.liststore_correct_rx.append(["Avg. coding time", 0.0]) self.liststore_correct_rx.append(["Avg. # TX slots", 0.0]) treeview = Gtk.TreeView(model=self.liststore_correct_rx) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Statistics", renderer_text, text=0) treeview.append_column(column_text) renderer_spin = Gtk.CellRendererSpin() renderer_spin.set_property("editable", False) column_spin = Gtk.TreeViewColumn("Value", renderer_spin, text=1) treeview.append_column(column_spin) self.boxstats.pack_start(treeview, True, True, 0) gobject.idle_add(self.update_graph)
def get_renderer(self): return Gtk.CellRendererSpin(editable=True, adjustment=Gtk.Adjustment(lower=self.min_value, upper=self.max_value, step_increment=1))