def get_use_flags(self, ebuild=None):
""" Get use flags selected by user """
if not ebuild:
iter = self.combobox.get_active_iter()
model = self.combobox.get_model()
sel_ver = model.get_value(iter, 0)
verInfo = self.get_verInfo(sel_ver)
ebuild = verInfo["name"]
flaglist = []
ebuild_use_flags = get_reduced_flags(ebuild)
for child in self.ufList:
flag = child[1]
if flag in ebuild_use_flags:
flag_active = True
else:
flag_active = False
if child[0].get_active():
if not flag_active:
flaglist.append(flag)
else:
if flag_active:
flaglist.append('-' + flag)
flags = ' '.join(flaglist)
debug.dprint("ADVEMERGE: get_use_flags(); flags = %s" % str(flags))
return flags
def _add_list(self, atomized_depends_list, depends_view,
parent_iter=None, add_satisfied=1, ebuild = None, is_new_child = False,
depth=0, dep_depth=0):
"""Add atomized dependencies to the tree"""
#debug.dprint(" * DependsTree: add_atomized_depends_list() 110: new depth level = "
#+ str(depth))
if ebuild and is_new_child:
self.parent_use_flags[depth] = get_reduced_flags(ebuild)
#debug.dprint(" * DependsTree: add_atomized_depends_list():" +
#" parent_use_flags = reduced: " + str(self.parent_use_flags[depth]))
elif is_new_child: # and atomized_depends_list[0].mytype not in ['LAZY']:
self.parent_use_flags[depth] = portage_lib.settings.SystemUseFlags
#debug.dprint(" * DependsTree: add_atomized_depends_list(): 122, is_new_child " +
# " parent_use_flags = system only")
for atom in atomized_depends_list:
satisfied = atom.is_satisfied(self.parent_use_flags[depth])
if add_satisfied or not satisfied: # then add deps to treeview
#debug.dprint(
# "DependsTree:_add_list(); 129 atom '%s', mytype '%s', satisfied '%s'"
# % (atom.get_depname(), atom.mytype, satisfied))
if satisfied == []:
satisfied = False
iter = self.insert_before(parent_iter, None)
add_kids, add_satisfied = self.update_row(iter, atom, satisfied,
add_satisfied, depends_view)
#debug.dprint(
# "DependsTree:_add_list(); 136 atom '%s', mytype '%s', add_kids=%s satisfied '%s'"
# % (atom.get_depname(), atom.mytype, add_kids, satisfied))
self.update_kids(atom, add_kids, add_satisfied, satisfied, depth,
dep_depth, depends_view, iter)
return
def show_props(ebuild):
# Use flags
ebuild_use_flags = get_reduced_flags(ebuild)
# parent module defined use_flags
if use_flags and config.Prefs.summary.showuseflags:
#debug.dprint("SUMMARY: SHOW_PROPS(); use_flags = " +str(use_flags))
final_use, use_expand_hidden, usemasked, useforced = portage_lib.get_cpv_use(ebuild)
iuse_output = False
myflags = filter_flags(iuse, use_expand_hidden, usemasked, useforced)
if myflags != []:
iuse_output = True
append(_("IUSE: "), "property")
append(", ".join(myflags))
nl()
_usemasked = set(usemasked).intersection(abs_list(iuse))
if _usemasked:
append(_("Masked flags: "), "property")
show_flags(_usemasked, ebuild_use_flags)
nl()
_useforced = set(useforced).intersection(abs_list(iuse))
if _useforced:
append(_("Forced flags: "), "property")
show_flags(_useforced, ebuild_use_flags)
nl()
myflags = filter_flags(use_flags, use_expand_hidden, usemasked, useforced)
if myflags != []:
append(_("Use flags settings: "), "property")
show_flags(myflags, ebuild_use_flags)
nl()
myflags = filter_flags(final_use, use_expand_hidden, usemasked, useforced)
if myflags != [] or iuse_output:
append(_("Final environment Use flags: "), "property")
show_flags(myflags, ebuild_use_flags, id_overrides=True)
nl(2)
# Keywords
if keywords and config.Prefs.summary.showkeywords:
append(_("Keywords: "), "property")
first_keyword = True
for keyword in keywords:
if not first_keyword:
append(", ", "value")
else:
first_keyword = False
append(keyword, "value")
nl(2)
# License
if licenses and config.Prefs.summary.showlicense:
append(_("License: "), "property")
_licenses = licenses.split()
x = 0
for license in _licenses:
if license not in ["||","(",")"]:
if x > 0:
append( ', ')
append_url(license, self.license_dir + license, "blue")
x += 1
nl()
def __init__(self, use_flags, ebuild):
gtk.Widget.__init__(self)
self.ebuild = ebuild
debug.dprint("USEFLAGDIALOG: __INIT__()")
size = len(use_flags)
maxcol = 3
maxrow = (size-1) / (maxcol+1)
table = gtk.Table(maxrow+2, maxcol+1, True)
if maxrow+1 >= 6:
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.add(scrolledwindow)
scrolledwindow.add_with_viewport(table)
scrolledwindow.set_size_request(1,100)
scrolledwindow.show()
else:
self.add(table)
self.ufList = []
col = 0
row = 0
ebuild_use_flags = get_reduced_flags(ebuild)
for flag in use_flags:
if flag[0] == '-':
button = UseFlagCheckbuttons(flag[1:], "-")
elif flag[0] == '+':
button = UseFlagCheckbuttons(flag[1:], "+")
else:
button = UseFlagCheckbuttons(flag, "")
myflag = abs_flag(flag)
if flag in ebuild_use_flags:
button.enable_box.set_active(True)
if flag[0] == '-':
button.disable_box.set_active(True)
elif flag[0] == '+':
button.disable_box.set_active(False)
self.ufList.append([button, flag])
button.set_has_tooltip=True
try:
button.set_tooltip_text(portage_lib.settings.UseFlagDict[myflag.lower()][2])
except KeyError:
button.set_tooltip_text(_('Unsupported use flag'))
table.attach(button, col, col+1, row, row+1)
#connect to grab-focus so we can detect changes
button.connect('grab-focus', self.on_toggled)
button.show()
#increment column and row
col+=1
if col > maxcol:
col = 0
row += 1
table.show()
self.show()
def get_use_flags(self, ebuild=None):
debug.dprint("USEFLAGS: get_use_flags()")
flaglist = []
if ebuild is None:
ebuild_use_flags = get_reduced_flags(self.ebuild)
else:
ebuild_use_flags = get_reduced_flags(ebuild)
for child in self.ufList:
#flag = child[1]
flag = child[0].get_flag()
base_flag = abs_flag(flag)
if flag[0] == '+':
if not flag[1:] in ebuild_use_flags:
flaglist.append(flag)
elif flag[0] == '-':
if not flag in ebuild_use_flags:
flaglist.append(flag)
flags = ' '.join(flaglist)
debug.dprint("USEFLAGS: get_use_flags(); flags = %s" %str(flags))
return flags
def build_use_flag_widget(self, use_flags, ebuild):
""" Create a table layout and populate it with
checkbox widgets representing the available
use flags
"""
debug.dprint("ADVEMERGE: build_use_flag_widget()")
UseFlagFrame = self.wtree.get_widget("frameUseFlags")
button_make_conf = self.wtree.get_widget("button_make_conf")
button_package_use = self.wtree.get_widget("button_package_use")
# If frame has any children, remove them
child = UseFlagFrame.child
if child != None:
UseFlagFrame.remove(child)
# If no use flags, hide the frame
if not use_flags:
UseFlagFrame.hide()
self.btnMakeConf.hide()
self.btnPkgUse.hide()
else:
UseFlagFrame.show()
if self.is_root or utils.can_gksu():
self.btnPkgUse.show()
if config.Prefs.advemerge.show_make_conf_button:
self.btnMakeConf.show()
else:
self.btnMakeConf.hide()
# Build table to hold checkboxes
size = 30
maxcol = 3 # = number of columns - 1 = index of last column
maxrow = (size - 1) / (maxcol + 1) # = number of rows - 1
# resize the table if it's taller than it is wide
table = gtk.Table(maxrow + 1, maxcol + 1, True)
if maxrow + 1 >= 6: # perhaps have this number configurable?
# perhaps add window based on size (in pixels) of table somehow...
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
UseFlagFrame.add(scrolledwindow)
scrolledwindow.add_with_viewport(table)
scrolledwindow.set_size_request(1, 100) # min height of 100 pixels
scrolledwindow.show()
else:
UseFlagFrame.add(table)
self.ufList = []
# Iterate through use flags collection, create checkboxes
# and attach to table
col = 0
row = 0
ebuild_use_flags = get_reduced_flags(ebuild)
for flag in use_flags:
flag_active = False
myflag = abs_flag(flag)
if myflag in ebuild_use_flags:
flag_active = True
button = gtk.CheckButton(flag)
button.set_use_underline(False)
button.set_active(flag_active)
self.ufList.append([button, flag])
# Add tooltip, attach button to table and show it off
# Use lower case flag, since that is how it is stored
# in the UseFlagDict. In case flag doesn't exist
# we'll trap the error
button.set_has_tooltip(True)
try:
button.set_tooltip_text(
portage_lib.settings.UseFlagDict[flag.lower()][2])
except KeyError:
button.set_tooltip_text(_('Unsupported use flag'))
table.attach(button, col, col + 1, row, row + 1)
# connect to on_toggled so we can show changes
button.connect("toggled", self.on_toggled)
button.show()
# Increment col & row counters
col += 1
if col > maxcol:
col = 0
row += 1
# Display the entire table
table.show()
def add_atomized_depends_to_tree(self,
atomized_depends_list,
depends_view,
parent_iter=None,
add_satisfied=1,
ebuild=None,
is_new_child=False):
"""Add atomized dependencies to the tree"""
#debug.dprint(" * DependsTree: add_atomized_depends_list(): new depth level = " + str(self.dep_depth))
if ebuild and is_new_child:
self.parent_use_flags[self.dep_depth] = get_reduced_flags(ebuild)
#debug.dprint(" * DependsTree: add_atomized_depends_list(): parent_use_flags = reduced: " + str(self.parent_use_flags[self.dep_depth]))
elif is_new_child:
self.parent_use_flags[
self.dep_depth] = portage_lib.settings.SystemUseFlags
#debug.dprint(" * DependsTree: add_atomized_depends_list(): parent_use_flags = system only")
for atom in atomized_depends_list:
dep_atomized_list = []
satisfied = atom.is_satisfied(
self.parent_use_flags[self.dep_depth])
if satisfied:
icon = gtk.STOCK_YES
add_kids = 0
else:
icon = gtk.STOCK_NO
add_kids = 1
if add_satisfied or not satisfied: # then add deps to treeview
#debug.dprint("DependsTree: atom '%s', type '%s', satisfied '%s'" % (atom.get_depname(), atom.type, satisfied))
iter = self.insert_before(parent_iter, None)
if atom.type == 'USING':
text = _("Using %s") % atom.useflag
if satisfied == -1:
icon = gtk.STOCK_REMOVE # -1 ==> irrelevant
add_kids = -1 # add kids but don't expand unsatisfied deps
add_satisfied = 1
elif atom.type == 'NOTUSING':
text = _("Not Using %s") % atom.useflag
if satisfied == -1:
icon = gtk.STOCK_REMOVE # -1 ==> irrelevant
add_kids = -1 # add kids but don't expand unsatisfied deps
add_satisfied = 1
elif atom.type == 'DEP':
text = atom.get_depname()
if not satisfied and self.dep_depth < 4:
add_kids = 1
elif atom.type == 'BLOCKER':
text = "!" + atom.get_depname()
if not satisfied: icon = gtk.STOCK_DIALOG_WARNING
elif atom.type == 'OPTION':
text = _("Any of:")
add_kids = -1 # add kids but don't expand unsatisfied deps
add_satisfied = 1
elif atom.type == 'GROUP':
text = _("All of:")
add_kids = -1 # add kids but don't expand unsatisfied deps
add_satisfied = 1
elif atom.type == 'REVISIONABLE':
text = '~' + atom.get_depname()
if not satisfied and self.dep_depth < 4:
add_kids = 1
if icon:
self.set_value(
iter, self.column["icon"],
depends_view.render_icon(icon,
size=gtk.ICON_SIZE_MENU,
detail=None))
self.set_value(iter, self.column["depend"], text)
self.set_value(iter, self.column["satisfied"], bool(satisfied))
self.set_value(iter, self.column["required_use"],
atom.get_required_use())
if atom.type in ['DEP', 'BLOCKER', 'REVISIONABLE']:
depname = portage_lib.get_full_name(atom.name)
if not depname:
debug.dprint(
" * DependsTree: add_atomized_depends_list(): No depname found for '%s'"
% atom.name or atom.useflag)
continue
#pack = Package(depname)
pack = db.db.get_package(depname)
self.set_value(iter, self.column["package"], pack)
#debug.dprint("DependsTree: add_atomized_depends_list(): add_kids = " \
# +str(add_kids) + " add_satisfied = " + str(add_satisfied))
# add kids if we should
if add_kids < 0 and add_satisfied != -1:
self.add_atomized_depends_to_tree(atom.children,
depends_view, iter,
add_kids)
elif add_kids > 0 and not satisfied and self.dep_depth <= 4:
# be carefull of depth
best, keyworded, masked = portage_lib.get_dep_ebuild(
atom.__repr__())
#debug.dprint("DependsTree: add_atomized_depends_list(): results = " + ', '.join([best,keyworded,masked]))
# get the least unstable dep_ebuild that satisfies the dep
if best != '':
dep_ebuild = best
elif keyworded != '':
dep_ebuild = keyworded
else:
dep_ebuild = masked
if dep_ebuild:
dep_deps = get_depends(pack, dep_ebuild)
dep_atomized_list = atomize_depends_list(dep_deps)
if dep_atomized_list == None: dep_atomized_list = []
#debug.dprint("DependsTree: add_atomized_depends_list(): DEP new atomized_list for: " \
# + atom.get_depname() + ' = ' + str(dep_atomized_list) + ' ' + dep_ebuild)
self.dep_depth += 1
self.add_atomized_depends_to_tree(dep_atomized_list,
depends_view,
iter,
add_kids,
ebuild=dep_ebuild,
is_new_child=True)
self.dep_depth -= 1
