0f157791e4
- allow hiding purge options git-svn-id: http://svn.sabayonlinux.org/projects/entropy/trunk@1842 cd1c1023-2f26-0410-ae45-c471fc1f0318
1176 lines
43 KiB
Python
1176 lines
43 KiB
Python
#!/usr/bin/python -tt
|
|
# -*- coding: iso-8859-1 -*-
|
|
# Yum Exteder (yumex) - A GUI for yum
|
|
# Copyright (C) 2006 Tim Lauridsen < tim<AT>yum-extender<DOT>org >
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
import gtk
|
|
import gobject
|
|
from spritz_setup import const,cleanMarkupSting
|
|
from etpgui.widgets import UI
|
|
from etpgui import *
|
|
from entropyConstants import *
|
|
|
|
from i18n import _
|
|
|
|
TOGGLE_WIDTH = 12
|
|
|
|
class SpritzCategoryView:
|
|
def __init__( self, treeview):
|
|
self.view = treeview
|
|
self.model = self.setup_view()
|
|
|
|
def setup_view( self ):
|
|
""" Setup Category View """
|
|
model = gtk.TreeStore( gobject.TYPE_STRING,gobject.TYPE_STRING )
|
|
self.view.set_model( model )
|
|
cell1 = gtk.CellRendererText()
|
|
column1= gtk.TreeViewColumn( _( "Categories" ), cell1, markup=0 )
|
|
column1.set_resizable( True )
|
|
column1.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column1.set_fixed_width( 150 )
|
|
|
|
self.view.append_column( column1 )
|
|
self.view.set_headers_visible(False)
|
|
return model
|
|
|
|
def populate(self,data,tree=False):
|
|
self.model.clear()
|
|
if tree:
|
|
data.populate(self.model)
|
|
else:
|
|
for el in data:
|
|
self.model.append(None,[el,el])
|
|
|
|
class EntropyPackageView:
|
|
def __init__( self, treeview, qview, ui, etpbase, main_window ):
|
|
|
|
self.selection_width = 20
|
|
self.show_reinstall = True
|
|
self.show_purge = True
|
|
self.loaded_widget = None
|
|
self.loaded_reinstallable = None
|
|
self.loaded_event = None
|
|
self.main_window = main_window
|
|
self.event_click_pos = 0,0
|
|
# default for installed packages
|
|
self.pkg_install_ok = "package-installed-updated.png"
|
|
self.pkg_install_updatable = "package-installed-outdated.png"
|
|
self.pkg_install_new = "package-available.png"
|
|
self.pkg_remove = "package-remove.png"
|
|
self.pkg_purge = "package-purge.png"
|
|
self.pkg_reinstall = "package-reinstall.png"
|
|
self.pkg_install = "package-install.png"
|
|
self.pkg_update = "package-upgrade.png"
|
|
self.pkg_downgrade = "package-downgrade.png"
|
|
self.pkg_undoinstall = "package-undoinstall.png"
|
|
|
|
self.img_pkg_install_ok = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_install_ok,self.pkg_install_ok)
|
|
self.img_pkg_install_updatable = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_install_updatable,self.pkg_install_updatable)
|
|
self.img_pkg_update = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_update,self.pkg_update)
|
|
self.img_pkg_downgrade = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_downgrade,self.pkg_downgrade)
|
|
|
|
self.img_pkg_install_new = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_install_new,self.pkg_install_new)
|
|
|
|
self.img_pkg_remove = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_remove,self.pkg_remove)
|
|
self.img_pkg_undoremove = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_undoremove,self.pkg_remove)
|
|
self.img_pkg_purge = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_purge,self.pkg_purge)
|
|
self.img_pkg_undopurge = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_undopurge,self.pkg_purge)
|
|
self.img_pkg_reinstall = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_reinstall,self.pkg_reinstall)
|
|
self.img_pkg_undoreinstall = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_undoreinstall,self.pkg_reinstall)
|
|
|
|
self.img_pkg_install = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_install,self.pkg_install)
|
|
self.img_pkg_undoinstall = gtk.Image()
|
|
self.set_pixbuf_to_image(self.img_pkg_undoinstall,self.pkg_undoinstall)
|
|
|
|
treeview.set_fixed_height_mode(True)
|
|
self.view = treeview
|
|
self.view.connect("button-release-event", self.load_menu)
|
|
#self.view.connect("button-press-event", self.load_properties_button)
|
|
self.store = self.setupView()
|
|
self.queue = qview.queue
|
|
self.queueView = qview
|
|
self.ui = ui
|
|
self.etpbase = etpbase
|
|
self.clearUpdates()
|
|
|
|
# installed packages right click menu
|
|
self.installed_menu_xml = gtk.glade.XML( const.GLADE_FILE, "packageInstalled",domain="spritz" )
|
|
self.installed_menu = self.installed_menu_xml.get_widget( "packageInstalled" )
|
|
self.installed_menu_xml.signal_autoconnect(self)
|
|
|
|
self.installed_reinstall = self.installed_menu_xml.get_widget( "reinstall" )
|
|
self.installed_undoreinstall = self.installed_menu_xml.get_widget( "undoreinstall" )
|
|
self.installed_purge = self.installed_menu_xml.get_widget( "purge" )
|
|
self.installed_undopurge = self.installed_menu_xml.get_widget( "undopurge" )
|
|
self.installed_remove = self.installed_menu_xml.get_widget( "remove" )
|
|
self.installed_undoremove = self.installed_menu_xml.get_widget( "undoremove" )
|
|
self.installed_reinstall.set_image(self.img_pkg_reinstall)
|
|
self.installed_undoreinstall.set_image(self.img_pkg_undoreinstall)
|
|
self.installed_remove.set_image(self.img_pkg_remove)
|
|
self.installed_undoremove.set_image(self.img_pkg_undoremove)
|
|
self.installed_purge.set_image(self.img_pkg_purge)
|
|
self.installed_undopurge.set_image(self.img_pkg_undopurge)
|
|
|
|
# updates right click menu
|
|
self.updates_menu_xml = gtk.glade.XML( const.GLADE_FILE, "packageUpdates",domain="spritz" )
|
|
self.updates_menu = self.updates_menu_xml.get_widget( "packageUpdates" )
|
|
self.updates_menu_xml.signal_autoconnect(self)
|
|
self.updates_update = self.updates_menu_xml.get_widget( "update" )
|
|
self.updates_undoupdate = self.updates_menu_xml.get_widget( "undoupdate" )
|
|
self.updates_update.set_image(self.img_pkg_update)
|
|
self.updates_undoupdate.set_image(self.img_pkg_downgrade)
|
|
|
|
# install right click menu
|
|
self.install_menu_xml = gtk.glade.XML( const.GLADE_FILE, "packageInstall",domain="spritz" )
|
|
self.install_menu = self.install_menu_xml.get_widget( "packageInstall" )
|
|
self.install_menu_xml.signal_autoconnect(self)
|
|
self.install_install = self.install_menu_xml.get_widget( "install" )
|
|
self.install_undoinstall = self.install_menu_xml.get_widget( "undoinstall" )
|
|
self.install_install.set_image(self.img_pkg_install)
|
|
self.updates_undoupdate.set_image(self.img_pkg_undoinstall)
|
|
|
|
def reset_install_menu(self):
|
|
self.install_install.show()
|
|
self.install_undoinstall.hide()
|
|
|
|
def hide_install_menu(self):
|
|
self.install_install.hide()
|
|
self.install_undoinstall.hide()
|
|
|
|
def reset_updates_menu(self):
|
|
self.updates_undoupdate.hide()
|
|
self.updates_update.show()
|
|
|
|
def hide_updates_menu(self):
|
|
self.updates_undoupdate.hide()
|
|
self.updates_update.hide()
|
|
|
|
def reset_installed_packages_menu(self):
|
|
self.installed_undoremove.hide()
|
|
self.installed_undoreinstall.hide()
|
|
self.installed_undopurge.hide()
|
|
self.installed_remove.show()
|
|
self.installed_reinstall.hide()
|
|
if self.show_reinstall:
|
|
self.installed_reinstall.show()
|
|
self.installed_purge.hide()
|
|
if self.show_purge:
|
|
self.installed_purge.show()
|
|
|
|
def hide_installed_packages_menu(self):
|
|
self.installed_undoremove.hide()
|
|
self.installed_undoreinstall.hide()
|
|
self.installed_undopurge.hide()
|
|
self.installed_remove.hide()
|
|
self.installed_reinstall.hide()
|
|
self.installed_purge.hide()
|
|
|
|
def enable_properties_menu(self, pkg):
|
|
self.etpbase.selected_treeview_item = None
|
|
do = False
|
|
if pkg:
|
|
do = True
|
|
self.etpbase.selected_treeview_item = pkg
|
|
try:
|
|
self.ui.pkgInfoButton.set_sensitive(do)
|
|
except AttributeError:
|
|
pass
|
|
|
|
def load_menu(self, widget, event):
|
|
self.loaded_widget = widget
|
|
self.loaded_event = event
|
|
#if event.button != 3:
|
|
# return True
|
|
|
|
obj = None
|
|
model, myiter = widget.get_selection().get_selected()
|
|
if myiter:
|
|
obj = model.get_value( myiter, 0 )
|
|
self.enable_properties_menu(obj)
|
|
else:
|
|
self.enable_properties_menu(None)
|
|
|
|
if event.x < 10:
|
|
return
|
|
|
|
try:
|
|
row, column, x, y = widget.get_path_at_pos(int(event.x),int(event.y))
|
|
except TypeError:
|
|
return
|
|
|
|
self.event_click_pos = x,y
|
|
if column.get_title() != " S":
|
|
return
|
|
|
|
if obj:
|
|
if obj.action in ["r","rr"]: # installed packages listing
|
|
self.run_installed_menu_stuff(obj)
|
|
elif obj.action in ["u"]: # updatable packages listing
|
|
self.run_updates_menu_stuff(obj)
|
|
elif obj.action in ["i"]:
|
|
self.run_install_menu_stuff(obj)
|
|
|
|
def reposition_menu(self, menu):
|
|
# devo tradurre x=0,y=20 in posizioni assolute
|
|
abs_x, abs_y = self.loaded_event.get_root_coords()
|
|
abs_x -= self.loaded_event.x
|
|
event_y = self.loaded_event.y
|
|
# FIXME: find a better way to properly position menu
|
|
while event_y > self.selection_width+5:
|
|
event_y -= self.selection_width+4
|
|
abs_y += (self.selection_width-event_y)
|
|
return int(abs_x),int(abs_y),True
|
|
|
|
def run_install_menu_stuff(self, obj):
|
|
self.reset_install_menu()
|
|
if obj.queued:
|
|
self.hide_install_menu()
|
|
self.install_undoinstall.show()
|
|
self.install_menu.popup( None, None, self.reposition_menu, self.loaded_event.button, self.loaded_event.time )
|
|
|
|
def run_updates_menu_stuff(self, obj):
|
|
do_show = True
|
|
self.reset_updates_menu()
|
|
if obj.queued:
|
|
self.hide_updates_menu()
|
|
self.updates_undoupdate.show()
|
|
self.updates_menu.popup( None, None, self.reposition_menu, self.loaded_event.button, self.loaded_event.time)
|
|
|
|
def run_installed_menu_stuff(self, obj):
|
|
do_show = True
|
|
self.reset_installed_packages_menu()
|
|
if obj.queued:
|
|
self.hide_installed_packages_menu()
|
|
if obj.queued == "r" and not obj.do_purge:
|
|
self.installed_undoremove.show()
|
|
elif obj.queued == "rr":
|
|
self.installed_undoreinstall.show()
|
|
self.set_loaded_reinstallable(obj)
|
|
elif obj.queued == "r" and obj.do_purge:
|
|
self.installed_undopurge.show()
|
|
else:
|
|
|
|
# is it a system package ?
|
|
if obj.syspkg:
|
|
self.installed_remove.hide()
|
|
self.installed_purge.hide()
|
|
|
|
reinstallable_list = self.etpbase.getPackages("reinstallable")
|
|
if str(obj) not in reinstallable_list:
|
|
if obj.syspkg:
|
|
do_show = False
|
|
self.installed_reinstall.hide()
|
|
else:
|
|
self.set_loaded_reinstallable(obj)
|
|
if not self.loaded_reinstallable:
|
|
self.installed_reinstall.hide()
|
|
if do_show: self.installed_menu.popup( None, None, self.reposition_menu, self.loaded_event.button, self.loaded_event.time )
|
|
|
|
def set_loaded_reinstallable(self, obj):
|
|
reinstallables = self.etpbase.getPackages("reinstallable")
|
|
self.loaded_reinstallable = None
|
|
for to_obj in reinstallables:
|
|
if str(obj) == str(to_obj):
|
|
self.loaded_reinstallable = to_obj
|
|
break
|
|
|
|
def on_remove_activate(self, widget, do_purge = False):
|
|
busyCursor(self.main_window)
|
|
model, iter = self.loaded_widget.get_selection().get_selected()
|
|
obj = self.store.get_value( iter, 0 )
|
|
oldqueued = obj.queued
|
|
oldpurge = obj.do_purge
|
|
obj.queued = "r"
|
|
if do_purge:
|
|
obj.do_purge = True
|
|
status, myaction = self.queue.add(obj)
|
|
if status != 0:
|
|
obj.queued = oldqueued
|
|
obj.do_purge = oldpurge
|
|
self.queueView.refresh()
|
|
normalCursor(self.main_window)
|
|
|
|
def on_reinstall_activate(self, widget):
|
|
busyCursor(self.main_window)
|
|
model, iter = self.loaded_widget.get_selection().get_selected()
|
|
obj = self.store.get_value( iter, 0 )
|
|
oldqueued = obj.queued
|
|
obj.queued = "rr"
|
|
oldqueued_reinstallable = self.loaded_reinstallable.queued
|
|
self.loaded_reinstallable.queued = "rr"
|
|
status, myaction = self.queue.add(self.loaded_reinstallable)
|
|
if status != 0:
|
|
obj.queued = oldqueued
|
|
self.loaded_reinstallable.queued = oldqueued_reinstallable
|
|
self.queueView.refresh()
|
|
normalCursor(self.main_window)
|
|
|
|
def on_undoreinstall_activate(self, widget):
|
|
busyCursor(self.main_window)
|
|
model, iter = self.loaded_widget.get_selection().get_selected()
|
|
obj = self.store.get_value( iter, 0 )
|
|
obj.queued = None
|
|
self.remove_queued(self.loaded_reinstallable)
|
|
self.queueView.refresh()
|
|
normalCursor(self.main_window)
|
|
|
|
def on_undoremove_activate(self, widget):
|
|
busyCursor(self.main_window)
|
|
model, iter = self.loaded_widget.get_selection().get_selected()
|
|
obj = self.store.get_value( iter, 0 )
|
|
self.remove_queued(obj)
|
|
obj.do_purge = False
|
|
self.queueView.refresh()
|
|
normalCursor(self.main_window)
|
|
|
|
def remove_queued(self, obj):
|
|
oldqueued = obj.queued
|
|
obj.queued = None
|
|
status, myaction = self.queue.remove(obj)
|
|
if status != 0:
|
|
obj.queued = oldqueued
|
|
self.view.queue_draw()
|
|
return status
|
|
|
|
def on_purge_activate(self, widget):
|
|
self.on_remove_activate(widget, True)
|
|
self.view.queue_draw()
|
|
|
|
def on_undopurge_activate(self, widget):
|
|
self.on_undoremove_activate(widget)
|
|
self.view.queue_draw()
|
|
|
|
def on_update_activate(self, widget):
|
|
self.on_install_update_activate(widget, "u")
|
|
self.view.queue_draw()
|
|
|
|
def on_undoupdate_activate(self, widget):
|
|
self.on_undoinstall_undoupdate_activate(widget)
|
|
self.view.queue_draw()
|
|
|
|
def on_install_activate(self, widget):
|
|
self.on_install_update_activate(widget, "i")
|
|
self.view.queue_draw()
|
|
|
|
def on_undoinstall_activate(self, widget):
|
|
self.on_undoinstall_undoupdate_activate(widget)
|
|
self.view.queue_draw()
|
|
|
|
def on_install_update_activate(self, widget, action):
|
|
busyCursor(self.main_window)
|
|
model, iter = self.loaded_widget.get_selection().get_selected()
|
|
obj = self.store.get_value( iter, 0 )
|
|
oldqueued = obj.queued
|
|
obj.queued = action
|
|
status, myaction = self.queue.add(obj)
|
|
if status != 0:
|
|
obj.queued = oldqueued
|
|
self.queueView.refresh()
|
|
normalCursor(self.main_window)
|
|
self.view.queue_draw()
|
|
|
|
def on_undoinstall_undoupdate_activate(self, widget):
|
|
busyCursor(self.main_window)
|
|
model, iter = self.loaded_widget.get_selection().get_selected()
|
|
obj = self.store.get_value( iter, 0 )
|
|
self.remove_queued(obj)
|
|
self.queueView.refresh()
|
|
normalCursor(self.main_window)
|
|
self.view.queue_draw()
|
|
|
|
def setupView( self ):
|
|
store = gtk.TreeStore( gobject.TYPE_PYOBJECT )#, gobject.TYPE_STRING )
|
|
self.view.set_model( store )
|
|
|
|
# Setup resent column
|
|
cell1 = gtk.CellRendererPixbuf()
|
|
self.set_pixbuf_to_cell(cell1, self.pkg_install_ok )
|
|
column1 = gtk.TreeViewColumn( " S", cell1 )
|
|
column1.set_cell_data_func( cell1, self.new_pixbuf )
|
|
column1.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column1.set_fixed_width( self.selection_width+20 )
|
|
column1.set_sort_column_id( -1 )
|
|
self.view.append_column( column1 )
|
|
column1.set_clickable( False )
|
|
|
|
#self.create_text_column( _( "Package" ), 'name' , size=300)
|
|
self.create_text_column( _( "Package" ), 'namedesc' , size=300)
|
|
self.create_text_column( _( "Rev." ), 'revision' , size=40 )
|
|
self.create_text_column( _( "Slot" ), 'slot' , size = 40 )
|
|
self.create_text_column( _( "Repository" ), 'repoid', size = 100 )
|
|
self.view.set_search_column( 1 )
|
|
self.view.set_enable_search(False)
|
|
return store
|
|
|
|
def clear(self):
|
|
self.store.clear()
|
|
|
|
def populate(self, pkgs, widget = None):
|
|
self.clear()
|
|
if widget == None:
|
|
self.ui.viewPkg.set_model(None)
|
|
else:
|
|
widget.set_model(None)
|
|
for po in pkgs:
|
|
self.store.append( None, (po,) ) # str(po)) )
|
|
if widget == None:
|
|
self.ui.viewPkg.set_model(self.store)
|
|
else:
|
|
widget.set_model(self.store)
|
|
|
|
def set_pixbuf_to_cell(self, cell, filename):
|
|
pixbuf = gtk.gdk.pixbuf_new_from_file(const.PIXMAPS_PATH+"/packages/"+filename)
|
|
cell.set_property( 'pixbuf', pixbuf )
|
|
|
|
def set_pixbuf_to_image(self, img, filename):
|
|
img.set_from_file(const.PIXMAPS_PATH+"/packages/"+filename)
|
|
|
|
def create_text_column( self, hdr, property, size, sortcol = None):
|
|
"""
|
|
Create a TreeViewColumn with text and set
|
|
the sorting properties and add it to the view
|
|
"""
|
|
cell = gtk.CellRendererText() # Size Column
|
|
column = gtk.TreeViewColumn( hdr, cell )
|
|
column.set_resizable( True )
|
|
column.set_cell_data_func( cell, self.get_data_text, property )
|
|
column.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column.set_fixed_width( size )
|
|
column.set_sort_column_id( -1 )
|
|
self.view.append_column( column )
|
|
return column
|
|
|
|
def get_data_text( self, column, cell, model, iter, property ):
|
|
obj = model.get_value( iter, 0 )
|
|
if obj:
|
|
cell.set_property('markup',getattr( obj, property ))
|
|
cell.set_property('foreground',obj.color)
|
|
|
|
def selectAll(self):
|
|
list = [x[0] for x in self.store if not x[0].queued == x[0].action]
|
|
if not list:
|
|
return
|
|
for obj in list:
|
|
obj.queued = obj.action
|
|
self.clearUpdates()
|
|
self.updates['u'] = self.queue.packages['u'][:]
|
|
self.updates['i'] = self.queue.packages['i'][:]
|
|
self.updates['r'] = self.queue.packages['r'][:]
|
|
status, myaction = self.queue.add(list)
|
|
if status == 0:
|
|
self.updates['u'] = [x for x in self.queue.packages['u'] if x not in self.updates['u']]
|
|
self.updates['i'] = [x for x in self.queue.packages['i'] if x not in self.updates['i']]
|
|
self.updates['r'] = [x for x in self.queue.packages['r'] if x not in self.updates['r']]
|
|
else:
|
|
for obj in list:
|
|
obj.queued = None
|
|
self.queueView.refresh()
|
|
self.view.queue_draw()
|
|
|
|
def clearUpdates(self):
|
|
self.updates = {}
|
|
self.updates['u'] = []
|
|
self.updates['r'] = []
|
|
self.updates['i'] = []
|
|
|
|
def deselectAll(self):
|
|
xlist = [x[0] for x in self.store if x[0].queued == x[0].action]
|
|
xlist += [x for x in self.updates['u']+self.updates['i']+self.updates['r'] if x not in xlist]
|
|
if not xlist:
|
|
return
|
|
for obj in xlist:
|
|
obj.queued = None
|
|
self.queue.remove(xlist)
|
|
self.clearUpdates()
|
|
self.queueView.refresh()
|
|
self.view.queue_draw()
|
|
|
|
def new_pixbuf( self, column, cell, model, iter ):
|
|
"""
|
|
Cell Data function for recent Column, shows pixmap
|
|
if recent Value is True.
|
|
"""
|
|
pkg = model.get_value( iter, 0 )
|
|
if pkg:
|
|
if not pkg.queued:
|
|
if pkg.action in ["r","rr"]:
|
|
self.set_pixbuf_to_cell(cell, self.pkg_install_ok)
|
|
elif pkg.action == "i":
|
|
self.set_pixbuf_to_cell(cell, self.pkg_install_new)
|
|
else:
|
|
self.set_pixbuf_to_cell(cell, self.pkg_install_updatable)
|
|
else:
|
|
if pkg.queued == "r" and not pkg.do_purge:
|
|
self.set_pixbuf_to_cell(cell, self.pkg_remove)
|
|
if pkg.queued == "r" and pkg.do_purge:
|
|
self.set_pixbuf_to_cell(cell, self.pkg_purge)
|
|
elif pkg.queued == "rr":
|
|
self.set_pixbuf_to_cell(cell, self.pkg_reinstall)
|
|
elif pkg.queued == "i":
|
|
self.set_pixbuf_to_cell(cell, self.pkg_install)
|
|
elif pkg.queued == "u":
|
|
self.set_pixbuf_to_cell(cell, self.pkg_update)
|
|
|
|
else:
|
|
cell.set_property( 'visible', False )
|
|
|
|
class EntropyQueueView:
|
|
""" Queue View Class"""
|
|
def __init__( self, widget, queue ):
|
|
self.view = widget
|
|
self.model = self.setup_view()
|
|
self.queue = queue
|
|
|
|
def setup_view( self ):
|
|
""" Create Notebook list for single page """
|
|
model = gtk.TreeStore( gobject.TYPE_STRING, gobject.TYPE_STRING )
|
|
self.view.set_model( model )
|
|
cell1 = gtk.CellRendererText()
|
|
column1= gtk.TreeViewColumn( _( "Packages" ), cell1, markup=0 )
|
|
column1.set_resizable( True )
|
|
self.view.append_column( column1 )
|
|
|
|
cell2 = gtk.CellRendererText()
|
|
column2= gtk.TreeViewColumn( _( "Description" ), cell2, text=1 )
|
|
column2.set_resizable( True )
|
|
self.view.append_column( column2 )
|
|
model.set_sort_column_id( 0, gtk.SORT_ASCENDING )
|
|
self.view.get_selection().set_mode( gtk.SELECTION_MULTIPLE )
|
|
return model
|
|
|
|
def deleteSelected( self ):
|
|
rmvlist = []
|
|
model, paths = self.view.get_selection().get_selected_rows()
|
|
for p in paths:
|
|
row = model[p]
|
|
if row.parent != None:
|
|
rmvlist.append( row[0] )
|
|
for pkg in self.getPkgsFromList( rmvlist ):
|
|
pkg.queued = None
|
|
pkg.set_select( not pkg.selected )
|
|
f = lambda x: str( x ) not in rmvlist
|
|
for action in ['u', 'i', 'r','rr']:
|
|
list = self.queue.get(action)
|
|
if list:
|
|
self.queue.packages[action] = filter( f, list )
|
|
self.refresh()
|
|
|
|
def getPkgsFromList( self, rlist ):
|
|
rclist = []
|
|
f = lambda x: str( x ) in rlist
|
|
for action in ['u', 'i', 'r','rr']:
|
|
list = self.queue.packages[action]
|
|
if list:
|
|
rclist += filter( f, list )
|
|
return rclist
|
|
|
|
def refresh ( self ):
|
|
""" Populate view with data from queue """
|
|
self.model.clear()
|
|
label = "<b>%s</b>" % (_( "Packages To Reinstall" ),)
|
|
list = self.queue.packages['rr']
|
|
if len( list ) > 0:
|
|
self.populate_list( label, list )
|
|
label = "<b>%s</b>" % (_( "Packages To Update" ),)
|
|
list = self.queue.packages['u']
|
|
if len( list ) > 0:
|
|
self.populate_list( label, list )
|
|
label = "<b>%s</b>" % (_( "Packages To Install" ),)
|
|
list = self.queue.packages['i']
|
|
if len( list ) > 0:
|
|
self.populate_list( label, list )
|
|
label = "<b>%s</b>" % (_( "Packages To Remove" ),)
|
|
list = self.queue.packages['r']
|
|
if len( list ) > 0:
|
|
self.populate_list( label, list )
|
|
self.view.expand_all()
|
|
|
|
def populate_list( self, label, mylist ):
|
|
parent = self.model.append( None, [label, ""] )
|
|
for pkg in mylist:
|
|
self.model.append( parent, [str( pkg ), pkg.description] )
|
|
|
|
class EntropyFilesView:
|
|
""" Queue View Class"""
|
|
def __init__( self, widget ):
|
|
self.view = widget
|
|
self.model = self.setup_view()
|
|
|
|
def setup_view( self ):
|
|
""" Create Notebook list for single page """
|
|
model = gtk.TreeStore( gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING )
|
|
self.view.set_model( model )
|
|
|
|
cell0 = gtk.CellRendererText()
|
|
column0 = gtk.TreeViewColumn( "", cell0, markup = 0 )
|
|
column0.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column0.set_fixed_width( 2 )
|
|
self.view.append_column( column0 )
|
|
|
|
cell1 = gtk.CellRendererText()
|
|
column1 = gtk.TreeViewColumn( _( "Proposed" ), cell1, markup = 1 )
|
|
column1.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column1.set_fixed_width( 200 )
|
|
column1.set_resizable( True )
|
|
self.view.append_column( column1 )
|
|
|
|
cell2 = gtk.CellRendererText()
|
|
column2 = gtk.TreeViewColumn( _( "Destination" ), cell2, markup = 2 )
|
|
column2.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column2.set_fixed_width( 200 )
|
|
column2.set_resizable( True )
|
|
self.view.append_column( column2 )
|
|
|
|
cell3 = gtk.CellRendererText()
|
|
column3 = gtk.TreeViewColumn( _( "Rev." ), cell3, text=3 )
|
|
column3.set_resizable( True )
|
|
column3.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column3.set_fixed_width( 30 )
|
|
self.view.append_column( column3 )
|
|
model.set_sort_column_id( 0, gtk.SORT_ASCENDING )
|
|
self.view.get_selection().set_mode( gtk.SELECTION_SINGLE )
|
|
return model
|
|
|
|
def populate( self, scandata ):
|
|
self.model.clear()
|
|
keys = scandata.keys()
|
|
keys.sort()
|
|
for key in keys:
|
|
self.model.append(None,[
|
|
key,
|
|
os.path.basename(scandata[key]['source']),
|
|
scandata[key]['destination'],
|
|
scandata[key]['revision']
|
|
]
|
|
)
|
|
|
|
class EntropyAdvisoriesView:
|
|
""" Queue View Class"""
|
|
def __init__( self, widget, ui, etpbase ):
|
|
self.view = widget
|
|
self.model = self.setup_view()
|
|
self.etpbase = etpbase
|
|
self.ui = ui
|
|
|
|
def setup_view( self ):
|
|
model = gtk.ListStore(
|
|
gobject.TYPE_PYOBJECT,
|
|
gobject.TYPE_STRING,
|
|
gobject.TYPE_STRING,
|
|
gobject.TYPE_STRING
|
|
)
|
|
self.view.set_model( model )
|
|
|
|
# Setup resent column
|
|
cell0 = gtk.CellRendererPixbuf()
|
|
self.set_icon_to_cell(cell0, 'gtk-apply' )
|
|
column0 = gtk.TreeViewColumn( _("Status"), cell0 )
|
|
column0.set_cell_data_func( cell0, self.new_icon )
|
|
column0.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column0.set_fixed_width( 50 )
|
|
self.view.append_column( column0 )
|
|
|
|
cell1 = gtk.CellRendererText()
|
|
column1 = gtk.TreeViewColumn( _("GLSA id."), cell1, markup = 1 )
|
|
column1.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column1.set_fixed_width( 80 )
|
|
column1.set_resizable( True )
|
|
column1.set_cell_data_func( cell1, self.get_data_text )
|
|
self.view.append_column( column1 )
|
|
|
|
cell2 = gtk.CellRendererText()
|
|
column2 = gtk.TreeViewColumn( _( "Package key" ), cell2, markup = 2 )
|
|
column2.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column2.set_fixed_width( 210 )
|
|
column2.set_resizable( True )
|
|
column2.set_cell_data_func( cell2, self.get_data_text )
|
|
self.view.append_column( column2 )
|
|
|
|
cell3 = gtk.CellRendererText()
|
|
column3 = gtk.TreeViewColumn( _( "Description" ), cell3, markup = 3 )
|
|
column3.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
|
|
column3.set_fixed_width( 190 )
|
|
column3.set_resizable( True )
|
|
column3.set_cell_data_func( cell3, self.get_data_text )
|
|
self.view.append_column( column3 )
|
|
|
|
self.view.connect("button-release-event", self.set_advisory_id)
|
|
self.view.get_selection().set_mode( gtk.SELECTION_SINGLE )
|
|
model.set_sort_column_id( 1, gtk.SORT_ASCENDING )
|
|
return model
|
|
|
|
def set_advisory_id(self, widget, event):
|
|
|
|
model, myiter = widget.get_selection().get_selected()
|
|
if myiter:
|
|
key, affected, data = model.get_value( myiter, 0 )
|
|
if key != None:
|
|
self.enable_properties_menu((key,affected,data))
|
|
return
|
|
self.enable_properties_menu(None)
|
|
|
|
def enable_properties_menu(self, data):
|
|
self.etpbase.selected_advisory_item = None
|
|
do = False
|
|
if data:
|
|
do = True
|
|
self.etpbase.selected_advisory_item = data
|
|
self.ui.advInfoButton.set_sensitive(do)
|
|
|
|
def set_icon_to_cell(self, cell, icon):
|
|
cell.set_property( 'icon-name', icon )
|
|
|
|
def new_icon( self, column, cell, model, iter ):
|
|
key, affected, data = model.get_value( iter, 0 )
|
|
if key == None:
|
|
affected = False
|
|
if affected:
|
|
self.set_icon_to_cell(cell, 'gtk-cancel')
|
|
else:
|
|
self.set_icon_to_cell(cell, 'gtk-apply')
|
|
|
|
def get_data_text( self, column, cell, model, iter ):
|
|
key, affected, data = model.get_value( iter, 0 )
|
|
if key == None:
|
|
affected = False
|
|
if affected:
|
|
cell.set_property('background',"#A71B1B")
|
|
cell.set_property('foreground',"#FFFFFF")
|
|
else:
|
|
cell.set_property('background',"darkgreen")
|
|
cell.set_property('foreground',"#FFFFFF")
|
|
|
|
|
|
def populate( self, securityConn, adv_metadata, show ):
|
|
|
|
self.model.clear()
|
|
self.enable_properties_menu(None)
|
|
|
|
only_affected = False
|
|
only_unaffected = False
|
|
all = False
|
|
if show == "affected":
|
|
only_affected = True
|
|
elif show == "applied":
|
|
only_unaffected = True
|
|
else:
|
|
all = True
|
|
|
|
identifiers = {}
|
|
for key in adv_metadata:
|
|
affected = securityConn.is_affected(key)
|
|
if all:
|
|
identifiers[key] = affected
|
|
elif only_affected and not affected:
|
|
continue
|
|
elif only_unaffected and affected:
|
|
continue
|
|
identifiers[key] = affected
|
|
|
|
if not identifiers:
|
|
self.model.append(
|
|
[
|
|
(None,None,None),
|
|
"---------",
|
|
"<b>%s</b>" % (_("No advisories"),),
|
|
"<small>%s</small>" % (_("There are no items to show"),)
|
|
]
|
|
)
|
|
|
|
for key in identifiers:
|
|
if not adv_metadata[key]['affected']:
|
|
continue
|
|
affected_data = adv_metadata[key]['affected'].keys()
|
|
if not affected_data:
|
|
continue
|
|
for a_key in affected_data:
|
|
mydata = adv_metadata[key]
|
|
self.model.append(
|
|
[
|
|
(key,identifiers[key],adv_metadata[key].copy(),),
|
|
key,
|
|
"<b>%s</b>" % (a_key,),
|
|
"<small>%s</small>" % (mydata['title'],)
|
|
]
|
|
)
|
|
|
|
|
|
class CategoriesView:
|
|
def __init__( self, treeview,qview):
|
|
self.view = treeview
|
|
self.model = self.setup_view()
|
|
self.queue = qview.queue
|
|
self.queueView = qview
|
|
self.etpbase = None # it will se set later
|
|
self.currentCategory = None
|
|
self.icon_theme = gtk.icon_theme_get_default()
|
|
|
|
|
|
def setup_view( self ):
|
|
""" Setup Group View """
|
|
model = gtk.TreeStore(gobject.TYPE_BOOLEAN, # Installed
|
|
gobject.TYPE_STRING, # Group Name
|
|
gobject.TYPE_STRING, # Group Id
|
|
gobject.TYPE_BOOLEAN, # In queue
|
|
gobject.TYPE_BOOLEAN) # isCategory
|
|
|
|
|
|
self.view.set_model( model )
|
|
column = gtk.TreeViewColumn(None, None)
|
|
# Selection checkbox
|
|
selection = gtk.CellRendererToggle() # Selection
|
|
selection.set_property( 'activatable', True )
|
|
column.pack_start(selection, False)
|
|
column.set_cell_data_func( selection, self.setCheckbox )
|
|
selection.connect( "toggled", self.on_toggled )
|
|
self.view.append_column( column )
|
|
|
|
column = gtk.TreeViewColumn(None, None)
|
|
# Queue Status (install/remove group)
|
|
state = gtk.CellRendererPixbuf() # Queue Status
|
|
state.set_property('stock-size', 1)
|
|
column.pack_start(state, False)
|
|
column.set_cell_data_func( state, self.queue_pixbuf )
|
|
|
|
# category/group icons
|
|
icon = gtk.CellRendererPixbuf()
|
|
icon.set_property('stock-size', 1)
|
|
column.pack_start(icon, False)
|
|
column.set_cell_data_func( icon, self.grp_pixbuf )
|
|
|
|
category = gtk.CellRendererText()
|
|
column.pack_start(category, False)
|
|
column.add_attribute(category, 'markup', 1)
|
|
|
|
self.view.append_column( column )
|
|
self.view.set_headers_visible(False)
|
|
return model
|
|
|
|
def setCheckbox( self, column, cell, model, iter ):
|
|
isCategory = model.get_value( iter, 4 )
|
|
state = model.get_value( iter, 0 )
|
|
if isCategory:
|
|
cell.set_property( 'visible', False)
|
|
else:
|
|
cell.set_property( 'visible', True)
|
|
cell.set_property('active',state)
|
|
|
|
def on_toggled( self, widget, path ):
|
|
""" Group selection handler """
|
|
iter = self.model.get_iter( path )
|
|
grpid = self.model.get_value( iter, 2 )
|
|
inst = self.model.get_value( iter, 0 )
|
|
action = self.queue.hasGroup(grpid)
|
|
if action:
|
|
self.queue.removeGroup(grpid,action)
|
|
self._updatePackages(grpid,False,None)
|
|
self.model.set_value( iter, 3,False )
|
|
else:
|
|
if inst:
|
|
self.queue.addGroup(grpid,'r') # Add for remove
|
|
self._updatePackages(grpid,True,'r')
|
|
else:
|
|
self.queue.addGroup(grpid,'i') # Add for install
|
|
self._updatePackages(grpid,True,'i')
|
|
self.model.set_value( iter, 3,True )
|
|
self.model.set_value( iter, 0, not inst )
|
|
|
|
|
|
def _updatePackages(self,id,add,action):
|
|
grp = self.etpbase.comps.return_group(id)
|
|
pkgs = self.etpbase._getByGroup(grp,['m','d'])
|
|
# Add group packages to queue
|
|
if add:
|
|
for po in pkgs:
|
|
if not po.queued:
|
|
if action == 'i' and po.available : # Install
|
|
po.queued = po.action
|
|
self.queue.add(po)
|
|
po.set_select( True )
|
|
elif action == 'r' and not po.available: # Remove
|
|
po.queued = po.action
|
|
self.queue.add(po)
|
|
po.set_select( False )
|
|
# Remove group packages from queue
|
|
else:
|
|
for po in pkgs:
|
|
if po.queued:
|
|
po.queued = None
|
|
self.queue.remove(po)
|
|
po.set_select( not po.selected )
|
|
self.queueView.refresh()
|
|
|
|
def populate(self,data):
|
|
self.model.clear()
|
|
for cat in data:
|
|
self.model.append(None,[None,cat,cat,False,True])
|
|
|
|
def queue_pixbuf( self, column, cell, model, iter ):
|
|
"""
|
|
Cell Data function for recent Column, shows pixmap
|
|
if recent Value is True.
|
|
"""
|
|
grpid = model.get_value( iter, 2 )
|
|
queued = model.get_value( iter, 3 )
|
|
action = self.queue.hasGroup(grpid)
|
|
if action:
|
|
if action == 'i':
|
|
icon = 'network-server'
|
|
else:
|
|
icon = 'edit-delete'
|
|
cell.set_property( 'visible', True )
|
|
cell.set_property( 'icon-name', icon )
|
|
cell.set_property( 'visible', queued )
|
|
|
|
def grp_pixbuf( self, column, cell, model, iter ):
|
|
"""
|
|
Cell Data function for recent Column, shows pixmap
|
|
if recent Value is True.
|
|
"""
|
|
grpid = model.get_value( iter, 2 )
|
|
pix = None
|
|
fn = "/usr/share/pixmaps/comps/%s.png" % grpid
|
|
if os.access(fn, os.R_OK):
|
|
pix = self._get_pix(fn)
|
|
if pix:
|
|
cell.set_property( 'visible', True )
|
|
cell.set_property( 'pixbuf', pix )
|
|
else:
|
|
cell.set_property( 'visible', False )
|
|
|
|
|
|
def _get_pix(self, fn):
|
|
imgsize = 24
|
|
pix = gtk.gdk.pixbuf_new_from_file(fn)
|
|
if pix.get_height() != imgsize or pix.get_width() != imgsize:
|
|
pix = pix.scale_simple(imgsize, imgsize,
|
|
gtk.gdk.INTERP_BILINEAR)
|
|
return pix
|
|
|
|
|
|
class EntropyRepoView:
|
|
"""
|
|
This class controls the repo TreeView
|
|
"""
|
|
def __init__( self, widget, EquoConnection, ui):
|
|
self.view = widget
|
|
self.headers = [_('Repository'),_('Filename')]
|
|
self.store = self.setup_view()
|
|
self.Equo = EquoConnection
|
|
self.ui = ui
|
|
import dialogs
|
|
self.okDialog = dialogs.okDialog
|
|
|
|
def on_active_toggled( self, widget, path):
|
|
""" Repo select/unselect handler """
|
|
myiter = self.store.get_iter( path )
|
|
state = self.store.get_value(myiter,0)
|
|
repoid = self.store.get_value(myiter,3)
|
|
if repoid != etpConst['officialrepositoryid']:
|
|
if state:
|
|
self.store.set_value(myiter,1, not state)
|
|
self.Equo.disableRepository(repoid)
|
|
initConfig_entropyConstants(etpSys['rootdir'])
|
|
else:
|
|
self.Equo.enableRepository(repoid)
|
|
initConfig_entropyConstants(etpSys['rootdir'])
|
|
msg = "%s '%s' %s" % (_("You should press the button"),_("Regenerate Cache"),_("now"))
|
|
self.okDialog(self.ui.main,msg)
|
|
self.store.set_value(myiter,0, not state)
|
|
|
|
def on_update_toggled( self, widget, path):
|
|
""" Repo select/unselect handler """
|
|
myiter = self.store.get_iter( path )
|
|
state = self.store.get_value(myiter,1)
|
|
active = self.store.get_value(myiter,0)
|
|
if active:
|
|
self.store.set_value(myiter,1, not state)
|
|
|
|
def setup_view( self ):
|
|
""" Create models and columns for the Repo TextView """
|
|
store = gtk.ListStore( 'gboolean', 'gboolean', gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
|
|
self.view.set_model( store )
|
|
|
|
# Setup Selection Column
|
|
cell1 = gtk.CellRendererToggle() # Selection
|
|
cell1.set_property( 'activatable', True )
|
|
column1 = gtk.TreeViewColumn( _("Active"), cell1 )
|
|
column1.add_attribute( cell1, "active", 0 )
|
|
column1.set_resizable( True )
|
|
column1.set_sort_column_id( -1 )
|
|
self.view.append_column( column1 )
|
|
cell1.connect( "toggled", self.on_active_toggled )
|
|
|
|
# Setup Selection Column
|
|
cell2 = gtk.CellRendererToggle() # Selection
|
|
cell2.set_property( 'activatable', True )
|
|
column2 = gtk.TreeViewColumn( _("Update"), cell2 )
|
|
column2.add_attribute( cell2, "active", 1 )
|
|
column2.set_resizable( True )
|
|
column2.set_sort_column_id( -1 )
|
|
self.view.append_column( column2 )
|
|
cell2.connect( "toggled", self.on_update_toggled )
|
|
|
|
# Setup revision column
|
|
self.create_text_column( _('Revision'),2 )
|
|
|
|
# Setup reponame & repofile column's
|
|
self.create_text_column( _('Repository Identifier'),3 )
|
|
self.create_text_column( _('Description'),4 )
|
|
self.view.set_search_column( 1 )
|
|
self.view.set_reorderable( False )
|
|
return store
|
|
|
|
def create_text_column( self, hdr,colno):
|
|
cell = gtk.CellRendererText() # Size Column
|
|
column = gtk.TreeViewColumn( hdr, cell, text=colno )
|
|
column.set_resizable( True )
|
|
self.view.append_column( column )
|
|
|
|
def populate(self):
|
|
self.store.clear()
|
|
""" Populate a repo liststore with data """
|
|
for repo in etpRepositoriesOrder:
|
|
repodata = etpRepositories[repo]
|
|
self.store.append([1,1,repodata['dbrevision'],repo,repodata['description']])
|
|
# excluded ones
|
|
for repo in etpRepositoriesExcluded:
|
|
repodata = etpRepositoriesExcluded[repo]
|
|
self.store.append([0,0,repodata['dbrevision'],repo,repodata['description']])
|
|
|
|
def new_pixbuf( self, column, cell, model, myiter ):
|
|
gpg = model.get_value( myiter, 3 )
|
|
if gpg:
|
|
cell.set_property( 'visible', True )
|
|
else:
|
|
cell.set_property( 'visible',False)
|
|
|
|
def get_selected( self ):
|
|
selected = []
|
|
for elem in self.store:
|
|
state = elem[0]
|
|
selection = elem[1]
|
|
name = elem[3]
|
|
if state and selection:
|
|
selected.append( name )
|
|
return selected
|
|
|
|
def get_notselected( self ):
|
|
notselected = []
|
|
for elem in self.store:
|
|
state = elem[0]
|
|
name = elem[1]
|
|
if not state:
|
|
notselected.append( name )
|
|
return notselected
|
|
|
|
def deselect_all( self ):
|
|
iterator = self.store.get_iter_first()
|
|
while iterator != None:
|
|
self.store.set_value( iterator, 0, False )
|
|
iterator = self.store.iter_next( iterator )
|
|
|
|
def select_all( self ):
|
|
iterator = self.store.get_iter_first()
|
|
while iterator != None:
|
|
self.store.set_value( iterator, 0, True )
|
|
iterator = self.store.iter_next( iterator )
|
|
|
|
def get_repoid(self, iterdata):
|
|
model, myiter = iterdata
|
|
return model.get_value( myiter, 3 )
|
|
|
|
def select_by_keys( self, keys):
|
|
iterator = self.store.get_iter_first()
|
|
while iterator != None:
|
|
repoid = self.store.get_value( iterator, 1 )
|
|
if repoid in keys:
|
|
self.store.set_value( iterator, 0, True )
|
|
else:
|
|
self.store.set_value( iterator, 0, False)
|
|
iterator = self.store.iter_next( iterator )
|
|
|
|
class EntropyRepositoryMirrorsView:
|
|
"""
|
|
This class controls the repo TreeView
|
|
"""
|
|
def __init__( self, widget):
|
|
self.view = widget
|
|
self.headers = [""]
|
|
self.store = self.setup_view()
|
|
|
|
def setup_view( self ):
|
|
""" Create models and columns for the Repo TextView """
|
|
store = gtk.ListStore(str)
|
|
self.view.set_model( store )
|
|
|
|
# Setup Repository URL column
|
|
self.create_text_column( "", 0 )
|
|
|
|
# Setup reponame & repofile column's
|
|
self.view.set_search_column( 1 )
|
|
self.view.set_reorderable( False )
|
|
return store
|
|
|
|
def create_text_column( self, hdr, colno):
|
|
cell = gtk.CellRendererText() # Size Column
|
|
column = gtk.TreeViewColumn( hdr, cell, text=colno )
|
|
column.set_resizable( True )
|
|
self.view.append_column( column )
|
|
|
|
def populate(self):
|
|
""" Populate a repo liststore with data """
|
|
self.store.clear()
|
|
|
|
def get_selected( self ):
|
|
selected = []
|
|
for elem in self.store:
|
|
name = elem[0]
|
|
if name:
|
|
selected.append( name )
|
|
return selected
|
|
|
|
def get_all( self ):
|
|
return [x[0] for x in self.store]
|
|
|
|
def add(self, url):
|
|
self.store.append([str(url)])
|
|
|
|
def remove_selected(self):
|
|
urls = self.get_selected()
|
|
self.remove(urls)
|
|
|
|
def get_text(self, urldata):
|
|
model, myiter = urldata
|
|
return model.get_value( myiter, 0 )
|
|
|
|
def remove(self, urldata):
|
|
model, myiter = urldata
|
|
self.store.remove(myiter)
|