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))
