def create_columns(self):
renderer_toggle = Gtk.CellRendererToggle()
renderer_toggle.connect("toggled", self.on_cell_toggled)
column_toggle = Gtk.TreeViewColumn("", renderer_toggle, active=0)
self.treeview.append_column(column_toggle)
renderer_pixbuf = Gtk.CellRendererPixbuf()
column_pixbuf = Gtk.TreeViewColumn("", renderer_pixbuf, pixbuf=1)
self.treeview.append_column(column_pixbuf)
renderer_text = Gtk.CellRendererText()
column_computer = Gtk.TreeViewColumn("Conputer", renderer_text, text=2)
self.treeview.append_column(column_computer)
renderer_progress = Gtk.CellRendererProgress()
column_progress = Gtk.TreeViewColumn("Progress",
renderer_progress,
value=3)
self.treeview.append_column(column_progress)
renderer_toggle1 = Gtk.CellRendererToggle()
renderer_toggle1.connect("toggled", self.on_cell_toggled)
column_toggle1 = Gtk.TreeViewColumn("Connected",
renderer_toggle1,
active=4)
column_toggle1.set_visible(False)
column_toggle1.set_cell_data_func(renderer_toggle1, self.set_toggle)
self.treeview.append_column(column_toggle1)
def add_progress_column(self,
header,
col_types=[float, str],
sortid=0,
hidden=False,
position=None,
status_field=None,
function=None,
column_type="progress",
default=True):
"""Add a progress column to the listview."""
render = Gtk.CellRendererProgress()
self.add_column(header,
render,
col_types,
hidden,
position,
status_field,
sortid,
function=function,
column_type=column_type,
value=0,
text=1,
default=default)
return True
def get_treeview(self, model):
treeview = Gtk.TreeView(model=model)
treeview.set_headers_visible(False)
renderer_toggle = Gtk.CellRendererToggle()
renderer_text = Gtk.CellRendererText()
self.renderer_progress = Gtk.CellRendererProgress()
installed_column = Gtk.TreeViewColumn(None, renderer_toggle, active=3)
renderer_toggle.connect("toggled", self.on_installed_toggled)
treeview.append_column(installed_column)
version_column = Gtk.TreeViewColumn(None, renderer_text)
version_column.add_attribute(renderer_text, 'text', self.COL_VER)
version_column.set_property('min-width', 80)
treeview.append_column(version_column)
arch_column = Gtk.TreeViewColumn(None,
renderer_text,
text=self.COL_ARCH)
arch_column.set_property('min-width', 50)
treeview.append_column(arch_column)
progress_column = Gtk.TreeViewColumn(None,
self.renderer_progress,
value=self.COL_PROGRESS,
visible=self.COL_PROGRESS)
progress_column.set_property('fixed-width', 60)
progress_column.set_property('min-width', 60)
progress_column.set_property('resizable', False)
treeview.append_column(progress_column)
return treeview
def __init__(self):
Gtk.Window.__init__(self, title="CellRendererProgress Example")
self.set_default_size(200, 200)
self.liststore = Gtk.ListStore(str, int, bool)
self.current_iter = self.liststore.append(["Sabayon", 0, False])
self.liststore.append(["Zenwalk", 0, False])
self.liststore.append(["SimplyMepis", 0, False])
treeview = Gtk.TreeView(model=self.liststore)
renderer_text = Gtk.CellRendererText()
column_text = Gtk.TreeViewColumn("Text", renderer_text, text=0)
treeview.append_column(column_text)
renderer_progress = Gtk.CellRendererProgress()
column_progress = Gtk.TreeViewColumn("Progress",
renderer_progress,
value=1,
inverted=2)
treeview.append_column(column_progress)
renderer_toggle = Gtk.CellRendererToggle()
renderer_toggle.connect("toggled", self.on_inverted_toggled)
column_toggle = Gtk.TreeViewColumn("Inverted",
renderer_toggle,
active=2)
treeview.append_column(column_toggle)
self.add(treeview)
self.timeout_id = GLib.timeout_add(100, self.on_timeout, None)
def __init__(self, transaction=None):
Gtk.TreeView.__init__(self)
model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_INT,
GObject.TYPE_STRING)
self.set_model(model)
self.props.headers_visible = False
self.set_rules_hint(True)
self._download_map = {}
self._signals = []
if transaction is not None:
self.set_transaction(transaction)
cell_uri = Gtk.CellRendererText()
cell_uri.props.ellipsize = Pango.EllipsizeMode.END
column_download = Gtk.TreeViewColumn(_("File"))
column_download.pack_start(cell_uri, True)
column_download.add_attribute(cell_uri, "markup", self.COL_TEXT)
cell_progress = Gtk.CellRendererProgress()
# TRANSLATORS: header of the progress download column
column_progress = Gtk.TreeViewColumn(_("%"))
column_progress.pack_start(cell_progress, True)
column_progress.set_cell_data_func(cell_progress, self._data_progress,
None)
self.append_column(column_progress)
self.append_column(column_download)
self.set_tooltip_column(self.COL_URI)
def create_view(oStore, sHeading, iWidth):
"""Setup the TreeView for the results"""
oView = Gtk.TreeView(oStore)
oTextCol = Gtk.TreeViewColumn(sHeading)
oTextCell = Gtk.CellRendererText()
oTextCol.pack_start(oTextCell, True)
oTextCol.add_attribute(oTextCell, 'text', 0)
oValCol = Gtk.TreeViewColumn("Expected Number")
oValProgCell = Gtk.CellRendererProgress()
oValCol.pack_start(oValProgCell, True)
oValCol.add_attribute(oValProgCell, 'value', 2)
oValCol.add_attribute(oValProgCell, 'text', 1)
# Take up space not reserved for progress bar column
oTextCol.set_min_width(iWidth - 60)
oTextCol.set_sort_column_id(0)
oTextCol.set_expand(True)
oValCol.set_sort_column_id(1)
# limit space taken by progress bars
oValCol.set_max_width(60)
oValCol.set_expand(False)
oView.append_column(oTextCol)
oView.append_column(oValCol)
# set suitable default sort
oStore.set_sort_column_id(0, Gtk.SortType.ASCENDING)
return oView
def __init__(self):
Gtk.CellRenderer.__init__(self)
# self.__gobject_init__()
self.set_property('mode', Gtk.CellRendererMode.ACTIVATABLE)
self.statuses = {
DownloadStatus.RUNNING:
GdkPixbuf.Pixbuf.new_from_file(
path.getdatapath('media', 'download_start.png')),
DownloadStatus.STOPPED:
GdkPixbuf.Pixbuf.new_from_file(
path.getdatapath('media', 'download_stop.png')),
DownloadStatus.ERROR:
GdkPixbuf.Pixbuf.new_from_file(
path.getdatapath('media', 'error.png')),
DownloadStatus.FINISHED:
GdkPixbuf.Pixbuf.new_from_file(
path.getdatapath('media', 'finished.png')),
DownloadStatus.SEEDING:
GdkPixbuf.Pixbuf.new_from_file(
path.getdatapath('media', 'finished.png'))
}
self.types = {
DownloadTypes.TORRENT: 'Torrent-Download',
DownloadTypes.BASIC: 'Normaler Download',
DownloadTypes.OTR_DECODE: 'OTR-Download mit Dekodieren',
DownloadTypes.OTR_CUT: 'OTR-Download mit Schneiden'
}
self.cellrenderer_pixbuf = Gtk.CellRendererPixbuf()
self.cellrenderer_filename = Gtk.CellRendererText()
self.cellrenderer_info = Gtk.CellRendererText()
self.cellrenderer_progress = Gtk.CellRendererProgress()
def __init__(self):
Gtk.Window.__init__(self)
self.set_title("CellRendererProgress")
self.set_default_size(200, 200)
self.connect("destroy", Gtk.main_quit)
self.liststore = Gtk.ListStore(str, int)
self.liststore.append(["Downloading files", 0])
self.liststore.append(["Parsing access logs", 0])
self.liststore.append(["Compiling modules", 0])
treeview = Gtk.TreeView()
treeview.set_model(self.liststore)
self.add(treeview)
cellrenderertext = Gtk.CellRendererText()
treeviewcolumn = Gtk.TreeViewColumn("Action")
treeview.append_column(treeviewcolumn)
treeviewcolumn.pack_start(cellrenderertext, False)
treeviewcolumn.add_attribute(cellrenderertext, "text", 0)
cellrendererprogress = Gtk.CellRendererProgress()
treeviewcolumn = Gtk.TreeViewColumn("Status")
treeview.append_column(treeviewcolumn)
treeviewcolumn.pack_start(cellrendererprogress, True)
treeviewcolumn.add_attribute(cellrendererprogress, "value", 1)
GObject.timeout_add(250, self.on_pulse_progressbar)
def __init__(self, queue):
self.queue = queue
self.scroll = sftp_utilities.get_object(
'SFTPClient.notebook.page_stfp.scrolledwindow_transfer_statuses')
self.treeview_transfer = sftp_utilities.get_object(
'SFTPClient.notebook.page_stfp.treeview_transfer_statuses')
self._tv_lock = threading.RLock()
col_img = Gtk.CellRendererPixbuf()
col = Gtk.TreeViewColumn('')
col.pack_start(col_img, False)
col.add_attribute(col_img, 'pixbuf', 0)
self.treeview_transfer.append_column(col)
gui_utilities.gtk_treeview_set_column_titles(
self.treeview_transfer, ('Local File', 'Remote File', 'Status'),
column_offset=1)
col_bar = Gtk.TreeViewColumn('Progress')
progress = Gtk.CellRendererProgress()
col_bar.pack_start(progress, True)
col_bar.add_attribute(progress, 'value', 4)
col_bar.set_property('resizable', True)
col_bar.set_min_width(125)
self.treeview_transfer.append_column(col_bar)
# todo: make this a CellRendererBytes
gui_utilities.gtk_treeview_set_column_titles(
self.treeview_transfer, ('Size', ),
column_offset=5,
renderers=(extras.CellRendererBytes(), ))
self._tv_model = Gtk.TreeStore(GdkPixbuf.Pixbuf, str, str, str, int,
int, object)
self.treeview_transfer.connect('size-allocate',
self.signal_tv_size_allocate)
self.treeview_transfer.connect('button_press_event',
self.signal_tv_button_pressed)
self.treeview_transfer.set_model(self._tv_model)
self.treeview_transfer.show_all()
self.popup_menu = Gtk.Menu.new()
self.menu_item_paused = Gtk.CheckMenuItem.new_with_label('Paused')
menu_item = self.menu_item_paused
menu_item.connect('toggled', self.signal_menu_toggled_paused)
self.popup_menu.append(menu_item)
self.menu_item_cancel = Gtk.MenuItem.new_with_label('Cancel')
menu_item = self.menu_item_cancel
menu_item.connect('activate', self.signal_menu_activate_cancel)
self.popup_menu.append(menu_item)
menu_item = Gtk.SeparatorMenuItem()
self.popup_menu.append(menu_item)
menu_item = Gtk.MenuItem.new_with_label('Clear')
menu_item.connect('activate', self.signal_menu_activate_clear)
self.popup_menu.append(menu_item)
self.popup_menu.show_all()
def load(self, persp):
self.persp = persp
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.tv = Gtk.TreeView()
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Title"), renderer, text=1)
self.tv.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Source"), renderer, text=2)
self.tv.append_column(column)
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4)
column.set_expand(True)
self.tv.append_column(column)
renderer = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn(_("Reset"), renderer, icon_name=5)
column.set_name(COLUMN_ROW_RESET)
self.tv.append_column(column)
self.tv.connect("row-activated", self.row_activated)
def on_progress_updated(solving_progress, key, progress):
for i, row in enumerate(self.store):
if row[0] == key:
progress_ratio_string, percent, reset_icon = self._compute_progress_info(progress)
treeiter = self.store.get_iter(Gtk.TreePath(i))
self.store[treeiter][3] = progress_ratio_string
self.store[treeiter][4] = percent
self.store[treeiter][5] = reset_icon
solving_progress.connect("progress_updated", on_progress_updated)
self.store = Gtk.ListStore(str, str, str, str, int, str)
@asyncio.coroutine
def coro():
for file_name, title, author in entries:
progress = solving_progress.get(file_name)
progress_ratio_string, percent, reset_icon = self._compute_progress_info(progress)
self.store.append([file_name, title, author, progress_ratio_string, percent, reset_icon])
yield from asyncio.sleep(0)
create_task(coro())
self.tv.set_model(self.store)
self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
self.tv.set_cursor(conf.get("learncombo%s" % learn_category_id))
scrollwin = Gtk.ScrolledWindow()
scrollwin.add(self.tv)
scrollwin.show_all()
self.box.pack_start(scrollwin, True, True, 0)
self.box.show_all()
return self.box
def _make_view(self, model, title, showProgress, vbox):
view = Gtk.TreeView(model)
view.append_column(Gtk.TreeViewColumn(
title, Gtk.CellRendererText(), text=0))
if showProgress:
view.append_column(Gtk.TreeViewColumn(
"Progress", Gtk.CellRendererProgress(), value=1))
vbox.pack_start(view, True, True, 0)
def treeviewcolumn_progress(self, tree, title, col):
cell = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn()
tree.append_column(column)
column.set_title(title)
column.pack_start(cell, True)
column.add_attribute(cell, 'value', col)
column.set_resizable(False)
def load(self, persp):
self.persp = persp
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.tv = Gtk.TreeView()
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Title"), renderer, text=1)
self.tv.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Source"), renderer, text=2)
self.tv.append_column(column)
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4)
self.tv.append_column(column)
self.tv.connect("row-activated", self.row_activated)
def on_progress_updated(solving_progress, key, progress):
for i, row in enumerate(self.store):
if row[0] == key:
solved = progress.count(1)
percent = 0 if not solved else round(
(solved * 100.) / len(progress))
treeiter = self.store.get_iter(Gtk.TreePath(i))
self.store[treeiter][3] = "%s / %s" % (solved,
len(progress))
self.store[treeiter][4] = percent
lessons_solving_progress.connect("progress_updated",
on_progress_updated)
self.store = Gtk.ListStore(str, str, str, str, int)
for file_name, title, author in LESSONS:
progress = lessons_solving_progress.get(file_name)
solved = progress.count(1)
percent = 0 if not solved else round(
(solved * 100.) / len(progress))
self.store.append([
file_name, title, author,
"%s / %s" % (solved, len(progress)), percent
])
self.tv.set_model(self.store)
self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
self.tv.set_cursor(0)
scrollwin = Gtk.ScrolledWindow()
scrollwin.add(self.tv)
scrollwin.show_all()
self.box.pack_start(scrollwin, True, True, 0)
self.box.show_all()
return self.box
def activate(self):
if self.first_run:
self.init_layout()
self.first_run = False
learn_home = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
box = Gtk.Box()
self.tv = Gtk.TreeView()
color = Gdk.RGBA()
color.parse("lightblue")
for i, col in enumerate((_("lichess"), _("wtharvey"), _("yacpdb"), _("lessons"))):
renderer = Gtk.CellRendererProgress()
renderer.set_orientation(Gtk.Orientation.VERTICAL)
renderer.props.height = 100
renderer.props.inverted = True
renderer.props.cell_background_rgba = color
column = Gtk.TreeViewColumn(col, renderer, text=i * 2, value=i * 2 + 1)
self.tv.append_column(column)
self.store = Gtk.ListStore(str, int, str, int, str, int, str, int)
self.update_progress(None, None, None)
self.tv.set_model(self.store)
self.tv.get_selection().set_mode(Gtk.SelectionMode.NONE)
puzzles_solving_progress.connect("progress_updated", self.update_progress)
lessons_solving_progress.connect("progress_updated", self.update_progress)
box.pack_start(self.tv, False, False, 6)
label = Gtk.Label(xpad=6, xalign=0)
label.set_markup("<b>%s</b>" % _("Progress"))
learn_home.pack_start(label, False, False, 6)
learn_home.pack_start(box, False, False, 0)
learn_home.show_all()
if not self.first_run:
self.notebooks["learnhome"].remove_page(-1)
self.notebooks["learnhome"].append_page(learn_home)
self.panels = [panel.Sidepanel().load(self) for panel in self.sidePanels]
for panel, instance in zip(self.sidePanels, self.panels):
if not self.first_run:
self.notebooks[panel.__name__].remove_page(-1)
self.notebooks[panel.__name__].append_page(instance)
instance.show()
perspective_manager.activate_perspective("learn")
def __init__(self, view, attrs):
super(ProgressBar, self).__init__()
self.view = view
self.attrs = attrs
self.renderer = Gtk.CellRendererProgress()
orientation, inverted = self.orientations.get(
self.attrs.get('orientation', 'left_to_right'))
self.renderer.set_orientation(orientation)
self.renderer.set_property('inverted', inverted)
self.renderer.set_property('yalign', 0)
def __init__(self, wtree, config):
MainWindowElement.__init__(self, wtree, config, "chat")
qst_add, qst_rem, qst_edit, qst_list = self._getw(
"qst_add", "qst_remove", "qst_edit", "qst_list")
self._store = Gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_FLOAT,
gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
qst_list.set_model(self._store)
qst_list.connect("row-activated", self._send_qst)
def render_remaining(col, rend, model, iter):
id, e = model.get(iter, 0, 5)
try:
q, c = self._qsts[id]
except KeyError:
e = None
if not e:
s = ""
elif c > 90:
s = "%i mins" % (c / 60)
else:
s = "%i sec" % c
rend.set_property("text", s)
typ = Gtk.TreeViewColumn("Type", Gtk.CellRendererText(), text=1)
frq = Gtk.TreeViewColumn("Freq", Gtk.CellRendererText(), text=2)
r = Gtk.CellRendererProgress()
cnt = Gtk.TreeViewColumn("Remaining", r, value=3)
cnt.set_cell_data_func(r, render_remaining)
msg = Gtk.TreeViewColumn("Content", Gtk.CellRendererText(), text=4)
r = Gtk.CellRendererToggle()
r.connect("toggled", self._toggle_qst, self._store, 5, 0, 2)
enb = Gtk.TreeViewColumn("On", r, active=5)
qst_list.append_column(typ)
qst_list.append_column(frq)
qst_list.append_column(cnt)
qst_list.append_column(enb)
qst_list.append_column(msg)
self._qsts = {}
self.reconfigure()
qst_add.connect("clicked", self._add_qst, qst_list)
qst_rem.connect("clicked", self._rem_qst, qst_list)
qst_edit.connect("clicked", self._edit_qst, qst_list)
gobject.timeout_add(1000, self._tick)
def __init__(self, database):
""" log box """
builder = Gtk.Builder() # glade
builder.add_from_file(
os.path.dirname(os.path.abspath(__file__)) +
"/../assets/ui/logger.glade")
self.database = database
# log list
self.notebook = builder.get_object("log-notebook")
self.log_box = builder.get_object("log-box")
self.scrolled = builder.get_object("scrolled")
self.log_liststore = Gtk.ListStore(int, int, str, str, int, str, str,
int, str, int)
self.log_tree = Gtk.TreeView(model=self.log_liststore)
self.id = 0
self.extensions = Extensions()
for i, column_title in enumerate(
["#", "Status", "Start time", "End time", "Pid", "Target",
"Task"]):
if i == 1:
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(column_title, renderer, value=1)
column.set_min_width(100)
column.add_attribute(renderer, "pulse",
7) #renderer.text = " "
else:
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(column_title, renderer, text=i)
self.log_tree.append_column(column)
# get logs from the database
self.refresh(self.database)
self.log_tree.show()
# pulse progress bar every second
GObject.timeout_add(100, self._pulse_progressbars)
# connect events
self.log_tree.connect("button_press_event", self.mouse_click)
self.log_tree.connect("row-activated", self.on_row_activated)
self.log_tree.connect('size-allocate', self._scroll)
# multi selection
selection = self.log_tree.get_selection()
selection.set_mode(Gtk.SelectionMode.MULTIPLE)
self.log_box.add(self.log_tree)
def __init__(self):
super(ProgressList, self).__init__()
self.xid2iter = dict()
self.piter = None
self.props.show_expanders = True
self.get_selection().props.mode = Gtk.SelectionMode.SINGLE
self.col_file = Gtk.TreeViewColumn(_("File"))
self.col_file.props.sort_column_id = 0
self.col_file.props.sort_indicator = True
self.cr_file = Gtk.CellRendererText()
iconrenderer = Gtk.CellRendererPixbuf()
textrenderer = Gtk.CellRendererText()
progressrenderer = Gtk.CellRendererProgress()
self.col_file.pack_start(iconrenderer, False)
self.col_file.pack_start(self.cr_file, False)
self.col_file.set_cell_data_func(self.cr_file, self.on_filename_data)
self.col_file.set_cell_data_func(iconrenderer, self.on_icon_data)
self.col_direction = Gtk.TreeViewColumn("<->", textrenderer)
self.col_direction.set_cell_data_func(textrenderer,
self.on_direction_data)
self.col_status = Gtk.TreeViewColumn(_("Status"), textrenderer)
self.col_status.set_cell_data_func(textrenderer, self.on_status_data)
self.col_progress = Gtk.TreeViewColumn(_("Progress"), progressrenderer)
self.col_progress.set_cell_data_func(progressrenderer,
self.on_progress_data)
self.col_transferred = Gtk.TreeViewColumn(_("Transferred bytes"),
textrenderer)
self.col_transferred.set_cell_data_func(textrenderer,
self.on_transferred_data)
self.col_transfer_rate = Gtk.TreeViewColumn(_("Transfer rate"),
textrenderer)
self.col_transfer_rate.set_cell_data_func(textrenderer,
self.on_transfer_rate_data)
self.col_time = Gtk.TreeViewColumn(_("Time"), textrenderer)
self.col_time.set_cell_data_func(textrenderer, self.on_time_data)
self.append_column(self.col_file)
self.append_column(self.col_direction)
self.append_column(self.col_status)
self.append_column(self.col_progress)
self.append_column(self.col_transferred)
self.append_column(self.col_transfer_rate)
self.append_column(self.col_time)
self.props.model = Gtk.TreeStore(object)
def __init__(self):
Gtk.TreeView.__init__(self)
self.get_selection().set_mode(0)
# downview.set_rubber_banding(True)
self.set_property('headers-visible', False)
column = Gtk.TreeViewColumn('id')
renderer = Gtk.CellRendererText()
column.pack_start(renderer, False)
column.add_attribute(renderer, 'text', 0)
self.append_column(column)
column = Gtk.TreeViewColumn('status')
renderer = Gtk.CellRendererPixbuf()
column.pack_start(renderer, False)
column.set_cell_data_func(renderer,
status_cell_data_func,
func_data=None)
self.append_column(column)
column = Gtk.TreeViewColumn('progress')
column.set_fixed_width(120)
renderer = Gtk.CellRendererProgress()
column.pack_start(renderer, False)
column.add_attribute(renderer, 'value', 2)
self.append_column(column)
column = Gtk.TreeViewColumn('size')
renderer = Gtk.CellRendererText()
column.pack_start(renderer, False)
column.set_cell_data_func(renderer,
status_size_data_func,
func_data=None)
# column.add_attribute(renderer, 'text', 3)
self.append_column(column)
column = Gtk.TreeViewColumn('host')
renderer = Gtk.CellRendererText()
column.pack_start(renderer, False)
column.add_attribute(renderer, 'text', 5)
self.append_column(column)
column = Gtk.TreeViewColumn('err')
renderer = Gtk.CellRendererText()
column.pack_start(renderer, False)
column.add_attribute(renderer, 'text', 6)
self.append_column(column)
column = Gtk.TreeViewColumn('set')
renderer = Gtk.CellRendererText()
column.pack_start(renderer, True)
column.add_attribute(renderer, 'text', 4)
self.append_column(column)
def __init__(self, hide_nonblocking=False):
"""
:param bool hide_nonblocking: if True, tasks that do not block
the exit dialog are not displayed
"""
self.box = Gtk.VBox()
self.hide_nonblocking = hide_nonblocking
scroll = Gtk.ScrolledWindow()
self.store = Gtk.ListStore(int, str, str, str, str, bool)
self.view = Gtk.TreeView(self.store)
self.view.set_headers_visible(False)
self.view.get_style_context().add_class("task_view_tree")
scroll.add(self.view)
self.box.pack_start(scroll, True, True, 0)
# Initialize the tree view
self.close_col = Gtk.TreeViewColumn("Close")
cell = Gtk.CellRendererPixbuf()
self.close_col.pack_end(cell, False)
self.close_col.add_attribute(cell, "icon_name", COL_CANCEL_PIXBUF)
self.view.append_column(self.close_col)
self.progress = Gtk.CellRendererProgress()
col = Gtk.TreeViewColumn("Progress",
self.progress,
value=COL_PROGRESS,
text=COL_PROGRESS_TEXT)
col.set_cell_data_func(self.progress, self._set_progress)
col.set_expand(True)
self.view.append_column(col)
self.playpause_col = Gtk.TreeViewColumn("Play Pause")
cell = Gtk.CellRendererPixbuf()
self.playpause_col.pack_end(cell, False)
self.playpause_col.add_attribute(cell, "icon_name",
COL_PLAYPAUSE_PIXBUF)
self.view.append_column(self.playpause_col)
# Connect to a click on the tree view
self.view.connect("button_press_event", self.__on_click)
self.pulse = 0
self.timeout = None
self.on_empty = None
self.box.connect("destroy", self.__destroy)
# Initial fill: we need to do this, since the widget will not get
# notifications for tasks that have started before it is created
self.start_monitoring()
self.refresh()
def build(self):
# Check if we can run.
if not (len(self.app.services) and len(self.app.outputs)):
dialog = Gtk.MessageDialog(self.app.mainWindow, 0, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, "Can not run backups")
dialog.format_secondary_text(
"You have to configure at least one service and one output before running the backups.")
dialog.run()
dialog.destroy()
return False
# Start running.
self.mainBox = mainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
mainBox.add(Gtk.Label('Running Backups...'))
self.startButton = startButton = Gtk.Button(label='Start')
startButton.connect('clicked', lambda button: self.on_start())
mainBox.add(startButton)
self.runner = runner = self.app.getRunner()
handler = runner.progressHandler
# Set up the backup list with progressbars
liststore = Gtk.ListStore(str, float)
first_store_item = None
for service in runner.services:
list_iter = liststore.append([service.getPrettyId(), 0.0])
if not first_store_item: first_store_item = list_iter
treeview = Gtk.TreeView(model=liststore)
mainBox.add(treeview)
renderer_text = Gtk.CellRendererText()
column_text = Gtk.TreeViewColumn("Text", renderer_text, text=0)
treeview.append_column(column_text)
renderer_progress = Gtk.CellRendererProgress()
column_progress = Gtk.TreeViewColumn("Progress", renderer_progress,
value=1)
treeview.append_column(column_progress)
handler.screen = self
handler.app = self.app
handler.liststore = liststore
handler.list_iter = first_store_item
handler.gui_finished_callback = lambda: self.on_finished()
return mainBox
def make_view( self, model ):
""" Form a view for the Tree Model """
self.view = Gtk.TreeView( model )
#self.view.set_reorderable(True)
#self.toggle_dl = Gtk.CellRendererToggle()
#self.toggle_dl.set_property('activatable', True)
#self.cell01 = Gtk.CellRendererText()
self.renderer0 = Gtk.CellRendererText()
self.renderer1 = Gtk.CellRendererText()
self.renderer2 = Gtk.CellRendererText()
self.renderer3 = Gtk.CellRendererText()
self.renderer4 = Gtk.CellRendererProgress()
#self.renderer5 = Gtk.CellRendererText()
#self.toggle_dl.connect( 'toggled', self.toggle_dl_cb, model )
#self.column0.pack_start(self.toggle_dl, False)
#self.column0.pack_start(self.renderer1, True)
#self.column0.add_attribute(self.toggle_dl, 'active', False)
#self.column0.add_attribute(self.toggle_dl, 'visible', 1)
#self.column0.add_attribute(self.cell01, 'text', 2)
self.column0 = Gtk.TreeViewColumn("Nom", self.renderer1, text=1 )
self.column1 = Gtk.TreeViewColumn("Date", self.renderer1, text=2 )
self.column2 = Gtk.TreeViewColumn("Durée", self.renderer1, text=3 )
self.column3 = Gtk.TreeViewColumn("Titre", self.renderer2, text=4 )
self.column4 = Gtk.TreeViewColumn("Progression", self.renderer4, text=5 , value=6)
#self.column5 = Gtk.TreeViewColumn("tooltip", self.renderer2, text=7 )
self.view.append_column( self.column0 )
self.view.append_column( self.column1 )
self.view.append_column( self.column2 )
self.view.append_column( self.column3 )
self.view.append_column( self.column4 )
#self.view.append_column( self.column5 )
self.column0.set_resizable(True)
self.column1.set_resizable(True)
self.column2.set_resizable(True)
self.column3.set_resizable(True)
self.column4.set_resizable(True)
#self.column5.set_resizable(True)
#self.view.connect("row-activated", self.row_click, model)
#self.view.expand_all()
self.view.connect("row-activated", self.row_download_click)
self.view.set_tooltip_column(7)
self.view.set_enable_search(False)
return self.view
def _add_column(self):
renderer = Gtk.CellRendererProgress()
component.get("TorrentView").add_column(
header=STATUS_NAME,
render=renderer,
col_types=str,
hidden=False,
position=None,
status_field=[STATUS_MESSAGE],
function=self._render_cell,
sortid=0,
column_type="progress",
)
def __init__(self, icons):
Gtk.ScrolledWindow.__init__(self)
BasePane.__init__(self)
self.state = DisplayState()
self.pane_name = _("Progress")
self.tv = Gtk.TreeView()
# customization
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.add(self.tv)
self.tv.set_headers_visible(False)
self.tv.connect("button-press-event", self._on_button_pressed)
# icon
self.icons = icons
tp = Gtk.CellRendererPixbuf()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
column = Gtk.TreeViewColumn("Icon", tp, pixbuf=PendingStore.COL_ICON)
self.tv.append_column(column)
# name
tr = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Name", tr, markup=PendingStore.COL_STATUS)
column.set_min_width(200)
column.set_expand(True)
self.tv.append_column(column)
# progress
tp = Gtk.CellRendererProgress()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
tp.set_property("text", "")
column = Gtk.TreeViewColumn("Progress",
tp,
value=PendingStore.COL_PROGRESS,
pulse=PendingStore.COL_PULSE)
column.set_min_width(200)
self.tv.append_column(column)
# cancel icon
tpix = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("Cancel",
tpix,
stock_id=PendingStore.COL_CANCEL)
self.tv.append_column(column)
# fake columns that eats the extra space at the end
tt = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Cancel", tt)
self.tv.append_column(column)
# add it
store = PendingStore(icons)
self.tv.set_model(store)
def _createList(self):
#url,title,progress, downloadtype
self.fileStore = Gtk.ListStore(str, str, float, str, str)
theList = Gtk.TreeView(model=self.fileStore)
theList.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
theList.set_grid_lines(Gtk.TreeViewGridLines.BOTH)
for n, name in enumerate(
[_t("COL1"), _t("COL2"),
_t("COL3"), _t("COL4")]):
if n < 2:
cell = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(name, cell, text=n)
column.set_resizable(False) #Since it does not work
if n == 1:
column.set_max_width(300)
column.set_expand(True)
elif n == 2:
cell = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(name, cell, value=n)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_alignment(0.5)
else:
cell = Gtk.CellRendererText()
cell.set_property('xalign', 0.5)
cell.set_property('cell-background', 'lightblue')
cell.set_property('foreground', 'darkgreen')
column = Gtk.TreeViewColumn(name, cell, text=n)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_max_width(40)
column.set_alignment(0.5)
theList.append_column(column)
#append an invisible column
cell = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("fullurl", cell, text=4)
column.set_visible(False)
theList.append_column(column)
theList.set_tooltip_text(_t("TIP_LIST"))
self.selection = theList.get_selection()
self.selection.connect("changed", self.on_selected)
theList.connect("button_press_event", self.on_contextMenu)
theList.connect('key_press_event', self.on_List_key_press)
theList.connect("row-activated", self.on_row_doubleClicked)
swH = Gtk.ScrolledWindow()
swH.add(theList)
swH.connect("drag-data-received", self.on_drag_data_received)
return swH
def __init__(self, model):
"""
L{TaskListView} initializing.
@arg model:The interface of the tree view.
@type model:L{TaskListModel}
"""
Gtk.TreeView.__init__(self, model)
# Set up columns
column = Gtk.TreeViewColumn(_('Tasks'))
column.set_expand(True)
column.set_resizable(True)
self.append_column(column)
renderer = Gtk.CellRendererPixbuf()
column.pack_start(renderer, False)
column.set_cell_data_func(renderer, self._status_data_func)
renderer = Gtk.CellRendererText()
column.pack_start(renderer, True)
column.set_cell_data_func(renderer, self._desc_data_func)
column = Gtk.TreeViewColumn(_('Progress'))
column.set_expand(True)
column.set_resizable(True)
self.append_column(column)
renderer = Gtk.CellRendererProgress()
column.pack_start(renderer, True)
column.set_cell_data_func(renderer, self._progress_data_func)
column = Gtk.TreeViewColumn(_('Speed'))
column.set_resizable(True)
self.append_column(column)
renderer = Gtk.CellRendererText()
column.pack_start(renderer, True)
column.set_cell_data_func(renderer, self._speed_data_func)
column = Gtk.TreeViewColumn(_('Connections'))
column.set_resizable(True)
self.append_column(column)
renderer = Gtk.CellRendererText()
column.pack_start(renderer, True)
column.set_cell_data_func(renderer, self._connection_data_func)
def _init_tree_view(self):
tree_view = self._get_tree_view()
column = Gtk.TreeViewColumn(_("Description"),
Gtk.CellRendererText(),
text=1)
column.set_resizable(True)
tree_view.append_column(column)
tree_view.append_column(
Gtk.TreeViewColumn(_("Usage"),
Gtk.CellRendererProgress(),
value=2,
text=3))
tree_view.append_column(
Gtk.TreeViewColumn(_("Active"), Gtk.CellRendererToggle(),
active=4))
# add filler column
tree_view.append_column(Gtk.TreeViewColumn())
tree_view.set_model(self._equipment_store)
def __init__(self, **kw):
Gtk.Window.__init__(self, **kw)
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
# Setting up the self.grid in which the elements are to be positionned
self.grid = Gtk.Grid()
self.grid.set_column_homogeneous(True)
self.grid.set_row_homogeneous(True)
self.add(self.grid)
self.listViewComics = Gtk.TreeView(self.lista_comics)
renderer_text = Gtk.CellRendererText()
renderer_progress = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn('Nombre Archivo', renderer_text, text=0)
column.set_min_width(200)
self.listViewComics.append_column(column)
column = Gtk.TreeViewColumn('Total Páginas', renderer_text, text=1)
column.set_min_width(30)
self.listViewComics.append_column(column)
column = Gtk.TreeViewColumn('Porcentaje_Descargado',
renderer_progress,
value=2)
column.set_min_width(150)
self.listViewComics.append_column(column)
self.grid.attach(self.listViewComics, 0, 0, 5, 15)
self.botonProcesar = Gtk.Button.new_with_label("Procesar")
self.botonProcesar.connect("clicked", self.procesar)
self.grid.attach_next_to(self.botonProcesar, self.listViewComics, 3, 1,
1)
self.botonAgregar = Gtk.Button.new_with_label("Agregar")
self.botonAgregar.connect("clicked", self.agregar)
self.grid.attach_next_to(self.botonAgregar, self.botonProcesar, 1, 1,
1)
self.botonDetener = Gtk.Button.new_with_label("Detener")
self.grid.attach_next_to(self.botonDetener, self.botonAgregar, 1, 1, 1)
self.botonDetener.connect("clicked", self.detener)
self.botonLimpiarTodo = Gtk.Button.new_with_label("Limpiar Todo")
self.botonLimpiarTodo.connect("clicked", self.limpiar_todo)
self.grid.attach_next_to(self.botonLimpiarTodo, self.botonDetener, 1,
1, 1)
self.botonBorrar = Gtk.Button.new_with_label("Borra")
self.grid.attach_next_to(self.botonBorrar, self.botonLimpiarTodo, 1, 1,
1)
def __init__(self, navigation):
self.navigation = navigation
CommonTreeControl.__init__(self, None)
self.set_reorderable(False)
self.set_headers_visible(True)
self.tree_menu = Popup()
"""column config"""
column = Gtk.TreeViewColumn("Name",
Gtk.CellRendererText(),
text=self.text[0])
column.set_resizable(True)
self.append_column(column)
"""column config"""
column = Gtk.TreeViewColumn("Progress",
Gtk.CellRendererProgress(),
text=self.persent[0],
value=self.persent[0])
column.set_resizable(True)
self.append_column(column)
"""column config"""
column = Gtk.TreeViewColumn("Size",
Gtk.CellRendererText(),
text=self.size[0])
column.set_resizable(True)
self.append_column(column)
"""status"""
column = Gtk.TreeViewColumn("Status",
Gtk.CellRendererText(),
text=self.status[0])
column.set_resizable(True)
self.append_column(column)
"""column config"""
column = Gtk.TreeViewColumn("Path",
Gtk.CellRendererText(),
text=self.save_to[0])
column.set_resizable(True)
column.set_expand(True)
self.append_column(column)
self.set_type_plain()
def __init__(self, title, parent, runner):
super().__init__(title, parent, 0)
self.add_buttons(_("_OK"), Gtk.ButtonsType.OK)
self.runner = runner
self.runner_info = {}
self.installing = {}
self.set_default_size(640, 480)
self.renderer_progress = Gtk.CellRendererProgress()
label = Gtk.Label.new(_("Waiting for response from %s") % (settings.SITE_URL))
self.vbox.pack_start(label, False, False, 18)
spinner = Gtk.Spinner(visible=True)
spinner.start()
self.vbox.pack_start(spinner, False, False, 18)
self.show_all()
self.runner_store = Gtk.ListStore(str, str, str, bool, int, str)
jobs.AsyncCall(api.get_runners, self.display_all_versions, self.runner)
