def enable_plugin():
global menuitem1, menuitem2, enabled, initialized
if initialized == False:
debug.dprint(plugin_name + " enable_plugin: not initialized!")
return False
elif not is_installed:
debug.dprint(plugin_name +
" enable_plugin: target command not installed.")
return False
debug.dprint(plugin_name + " enable_plugin: generating new menuitem")
if is_root():
menuitem1 = manager.new_menuitem(_("Profuse"))
debug.dprint(plugin_name +
" enabling plugin to run_as_user user='******'")
menuitem1.connect("activate", run_as_user)
elif privileges.can_su:
menuitem1 = manager.new_menuitem(_("Profuse"))
debug.dprint(plugin_name +
" enabling plugin to run_as_root, user='******'")
menuitem1.connect("activate", run_as_root)
else:
menuitem1 = manager.new_menuitem(_("Profuse (user mode)"))
debug.dprint(plugin_name +
" enabling plugin to run_as_user, user='******'")
menuitem1.connect("activate", run_as_user)
menuitem2 = manager.new_menuitem(_("Profuse (su mode)"))
debug.dprint(plugin_name +
" enabling plugin to run_as_root, user='******'")
menuitem2.connect("activate", run_as_root)
enabled = True
return True
def notebook_changed(self, widget, pointer, index):
"""Catch when the user changes the notebook"""
package = self.package
debug.dprint("PackageNotebook notebook_changed(); self.summary.ebuild " +self.summary.ebuild +
" self.loaded_version['deps'] : " + str(self.loaded_version["deps"]))
if index == 1:
if self.loaded_version["deps"] != self.summary.ebuild or not self.loaded["deps"]:
debug.dprint("PackageNotebook notebook_changed(); fill the deps view!")
self.deps_view.fill_depends_tree(self.deps_view, package, self.summary.ebuild)
self.loaded["deps"] = True
self.loaded_version["deps"] = self.summary.ebuild
elif index == 2:
if not self.loaded["changelog"]:
# fill in the change log
#load_textfile(self.changelog, package, "changelog")
self.changelog.update(self.summary.ebuild, True)
self.loaded["changelog"] = True
elif index == 3:
debug.dprint("PackageNotebook notebook_changed(); load installed files for: " + str(self.summary.ebuild))
if not self.loaded["installed"] or self.loaded_version["installed"] != self.summary.ebuild:
# load list of installed files
load_installed_files(self.installed_window, self.installed_files, package, self.summary.ebuild )
self.loaded["installed"] = True
self.loaded_version["installed"] = self.summary.ebuild
elif index == 4:
debug.dprint("PackageNotebook notebook_changed(); self.summary.ebuild = " + str(self.summary.ebuild))
if not self.loaded["ebuild"] or self.loaded_version["ebuild"] != self.summary.ebuild:
#load_textfile(self.ebuild, package, "best_ebuild")
#load_textfile(self.ebuild, package, "version_ebuild", self.summary.ebuild)
self.ebuild.update(self.summary.ebuild, True)
self.loaded["ebuild"] = True
self.loaded_version["ebuild"] = self.summary.ebuild
elif index == 5:
debug.dprint("PackageNotebook notebook_changed(); self.summary.ebuild = " + str(self.summary.ebuild))
child = self.use_flag_page.child
if not child is None:
debug.dprint("PackageNotebook: removing use_view_widget")
self.use_flag_page.remove(child)
frame = gtk.VBox()
ebuild = self.summary.ebuild
props = self.summary.package.get_properties(ebuild)
use_flags = props.get_use_flags()
self.use_flag_view = UseFlagWidget(use_flags, ebuild)
self.use_flag_view.show()
frame.pack_start(self.use_flag_view)
if utils.is_root() or utils.can_gksu():
button = gtk.Button("Save USE Flags")
button.connect('clicked', self.save_use_flags_clicked)
button.set_size_request(100,50)
button.show()
frame.pack_end(button,expand=False,fill=False);
frame.show()
self.use_flag_page.add_with_viewport(frame)
self.use_flag_page.show()
else:
for i in self.plugin_package_tabs:
#Search through the plugins dictionary and select the correct one.
if self.plugin_package_tabs[i][2] == index:
self.plugin_package_tabs[i][0]( package )
def disable_plugin():
global manager, enabled
if initialized == False:
return
if is_root():
manager.del_menuitem(menuitem1)
else:
manager.del_menuitem(menuitem1)
manager.del_menuitem(menuitem2)
enabled = False
def emerge_package(self, package, sudo=False):
"""Emerge the package."""
if (sudo or (not utils.is_root() and utils.can_sudo())) \
and not config.Prefs.emerge.pretend:
self.setup_command(
package.get_name(), 'sudo -p "Password: "******"emerge" +
config.Prefs.emerge.get_string() + package.full_name)
def sync_tree(self, *widget):
"""Sync the portage tree and reload it when done."""
sync = config.Prefs.globals.Sync
if config.Prefs.emerge.verbose:
sync += " --verbose"
if config.Prefs.emerge.nospinner:
sync += " --nospinner "
if utils.is_root():
self.setup_command("Sync Portage Tree", sync)
elif utils.can_sudo():
self.setup_command("Sync Portage Tree",
'sudo -p "Password: " ' + sync)
else:
self.check_for_root()
def enable_plugin():
global menuitem1, menuitem2, enabled, initialized
if initialized == False:
debug.dprint(plugin_name + " enable_plugin: not initialized!")
return False
elif not is_installed:
debug.dprint(plugin_name + " enable_plugin: target command not installed.")
return False
debug.dprint(plugin_name + " enable_plugin: generating new menuitem")
menuitem1 = manager.new_menuitem(_("Etc-Proposals"))
if is_root():
debug.dprint(plugin_name + " enabling plugin to run_as_user")
menuitem1.connect("activate", run_as_user)
else:
debug.dprint(plugin_name + " enabling plugin to run_as_root")
menuitem1.connect("activate", run_as_root)
enabled = True
return True
def upgrades_loaded_dialog_response(self, widget, response):
""" Get and parse user's response """
if response == 0: # Yes was selected; upgrade all
#self.load_upgrades_list()
#self.loaded_callback["Upgradable"] = self.upgrade_packages
if not utils.is_root() and utils.can_sudo() \
and not config.Prefs.emerge.pretend:
self.setup_command(
'world', 'sudo -p "Password: "******"emerge --update" +
config.Prefs.emerge.get_string() + 'world')
else:
# load the upgrades view to select which packages
self.widget["view_filter"].set_active(SHOW_UPGRADE)
# get rid of the dialog
self.upgrades_loaded_dialog.destroy()
def enable_plugin():
global menuitem1, menuitem2, enabled, initialized
if initialized == False:
debug.dprint(plugin_name + " enable_plugin: not initialized!")
return False
elif not is_installed:
debug.dprint(plugin_name + " enable_plugin: target command not installed.")
return False
debug.dprint(plugin_name + " enable_plugin: generating new menuitem")
menuitem1 = manager.new_menuitem(_("Gpytage"))
#config_path = os.path.join(portage_lib.settings.config_root, portage_lib.settings.user_config_dir)
#if os.access(config_path, os.W_OK):
if is_root():
debug.dprint(plugin_name + " enabling plugin to run_as_user")
menuitem1.connect("activate", run_as_user)
else:
debug.dprint(plugin_name + " enabling plugin to run_as_root")
menuitem1.connect("activate", run_as_root)
enabled = True
return True
try:
import portage
import portage_const
import portage_manifest as manifest
PORTAGE22 = False
except ImportError:
exit(_('Could not find portage module.\n'
'Are you sure this is a Gentoo system?'))
print >>stderr, ("PORTAGELIB: portage version = " + portage.VERSION)
#thread_id = os.getpid()
thread_id = thread.get_ident()
if is_root(): # then import some modules and run it directly
import set_config
def get_user_config(file, name=None, ebuild=None):
""" depricated function. this is now part of the db.user_configs module
Function for parsing package.use, package.mask, package.unmask
and package.keywords.
Returns /etc/portage/<file> as a dictionary of ebuilds, with
dict[ebuild] = list of flags.
If name is given, it will be parsed for ebuilds with xmatch('match-all'),
and only those ebuilds will be returned in dict.
If <ebuild> is given, it will be matched against each line in <file>.
For package.use/keywords, a list of applicable flags is returned.
For package.mask/unmask, a list containing the matching lines is returned.
def _clicked(self, treeview, *args):
""" Handles treeview clicks """
debug.dprint("VIEWS: Package view _clicked() signal caught")
# get the selection
package = utils.get_treeview_selection(treeview, MODEL_ITEM["package"])
#debug.dprint("VIEWS: package = %s" % package.full_name)
if (not package and not self.toggle) or package.full_name == _("None"):
self.mainwindow_callback("package changed", {
'package': None,
'caller': 'VIEWS: Package view _clicked()'
})
return False
if self.toggle != None: # for upgrade view
iter = self.get_model().get_iter(self.toggle)
check = self.view_model[MODEL_NAMES[self.current_view]].get_value(
iter, MODEL_ITEM["checkbox"])
check = not check
self.view_model[MODEL_NAMES[self.current_view]].set_value(
iter, MODEL_ITEM["checkbox"], check)
package.is_checked = check
#~ if self.view_model[MODEL_NAMES[self.current_view]].get_value(iter, MODEL_ITEM["package"]) == None:
#~ #debug.dprint("VIEWS: _clicked(): Toggling all upgradable deps")
#~ # package == None for "Upgradable Dependencies" row
#~ # so select or deselect all deps
#~ iter = self.view_model[MODEL_NAMES[self.current_view]].iter_children(iter)
#~ while iter:
#~ self.view_model[MODEL_NAMES[self.current_view]].set_value(iter, MODEL_ITEM["checkbox"], check)
#~ iter = self.view_model[MODEL_NAMES[self.current_view]].iter_next(iter)
self.dopopup = False # don't popup menu if clicked on checkbox
self.toggle = None
return True # we've got it sorted
else:
self.mainwindow_callback("package changed", {
'package': package,
'caller': 'VIEWS: Package view _clicked()'
})
self._last_selected = package.full_name
#pop up menu if was rmb-click
if self.dopopup:
if utils.is_root():
if package.get_best_ebuild() != package.get_latest_ebuild(
): # i.e. no ~arch keyword
self.popup_menuitems["add-keyword"].show()
else:
self.popup_menuitems["add-keyword"].hide()
installed = package.get_installed()
havebest = False
if installed:
self.popup_menuitems["unmerge"].show()
if package.get_best_ebuild() in installed:
havebest = True
else:
self.popup_menuitems["unmerge"].hide()
if havebest:
self.popup_menuitems["emerge"].hide()
self.popup_menuitems["pretend-emerge"].hide()
else:
self.popup_menuitems["emerge"].show()
self.popup_menuitems["pretend-emerge"].show()
self.popup_menuitems["sudo-emerge"].hide()
self.popup_menuitems["sudo-unmerge"].hide()
else:
self.popup_menuitems["emerge"].hide()
self.popup_menuitems["unmerge"].hide()
if utils.can_gksu() and \
(package.get_best_ebuild() != package.get_latest_ebuild()):
self.popup_menuitems["add-keyword"].show()
else:
self.popup_menuitems["add-keyword"].hide()
installed = package.get_installed()
havebest = False
if installed and utils.can_sudo():
self.popup_menuitems["sudo-unmerge"].show()
if package.get_best_ebuild() in installed:
havebest = True
else:
self.popup_menuitems["sudo-unmerge"].hide()
if havebest:
self.popup_menuitems["sudo-emerge"].hide()
self.popup_menuitems["pretend-emerge"].hide()
else:
if utils.can_sudo():
self.popup_menuitems["sudo-emerge"].show()
else:
self.popup_menuitems["sudo-emerge"].hide()
self.popup_menuitems["pretend-emerge"].show()
self.popup_menu.popup(None, None, None, None, self.event.button,
self.event.time)
self.dopopup = False
self.event = None
return True
def do_table_popup(self, eventbox, event):
self.selected_ebuild = eventbox.ebuild
self.selected_arch = eventbox.arch
# inteligently show/hide keywords submenu archs
self.do_keyword_menuitems(eventbox.ebuild)
# moved these from is_root bit as we can sudo them now
if utils.is_root() or utils.can_gksu():
if '~' in eventbox.text:
self.popup_menuitems["add-keyword"].show()
self.popup_menuitems["add-ebuild-keyword"].show()
else:
self.popup_menuitems["add-keyword"].hide()
self.popup_menuitems["add-ebuild-keyword"].hide()
if '(+)' in eventbox.text:
self.popup_menuitems["remove-keyword"].show()
# get the config entry and convert it to string for easier searching
config_entry = str(
db.userconfigs.get_atom('KEYWORDS', None, eventbox.ebuild))
debug.dprint("SUMMARY: do_table_popup(); ebuild = %s, in config_entry = %s : %s" \
%(eventbox.ebuild, config_entry, str(eventbox.ebuild in config_entry)))
if eventbox.ebuild in config_entry:
self.popup_menuitems["remove-keyword-ebuild"].show()
else:
self.popup_menuitems["remove-keyword-ebuild"].hide()
else:
self.popup_menuitems["remove-keyword"].hide()
self.popup_menuitems["remove-keyword-ebuild"].hide()
if 'M' in eventbox.text:
self.popup_menuitems["package-unmask"].show()
else:
self.popup_menuitems["package-unmask"].hide()
if '[' in eventbox.text:
self.popup_menuitems["un-package-unmask"].show()
self.popup_menuitems["package-mask"].hide()
else:
self.popup_menuitems["un-package-unmask"].hide()
self.popup_menuitems["package-mask"].show()
else:
self.popup_menuitems["add-keyword"].hide()
self.popup_menuitems["add-ebuild-keyword"].hide()
self.popup_menuitems["remove-keyword"].hide()
self.popup_menuitems["remove-keyword-ebuild"].hide()
self.popup_menuitems["package-unmask"].hide()
self.popup_menuitems["un-package-unmask"].hide()
if utils.is_root():
#if '~' in eventbox.text:
# self.popup_menuitems["add-keyword"].show()
#else: self.popup_menuitems["add-keyword"].hide()
#if '(+)' in eventbox.text:
# self.popup_menuitems["remove-keyword"].show()
#else: self.popup_menuitems["remove-keyword"].hide()
#if 'M' in eventbox.text:
# self.popup_menuitems["package-unmask"].show()
#else: self.popup_menuitems["package-unmask"].hide()
#if '[' in eventbox.text:
# self.popup_menuitems["un-package-unmask"].show()
#else: self.popup_menuitems["un-package-unmask"].hide()
if eventbox.ebuild in self.installed:
self.popup_menuitems["unmerge"].show()
self.popup_menuitems["emerge"].hide()
self.popup_menuitems["pretend-emerge"].hide()
else:
self.popup_menuitems["unmerge"].hide()
self.popup_menuitems["emerge"].show()
self.popup_menuitems["pretend-emerge"].show()
self.popup_menuitems["sudo-emerge"].hide()
self.popup_menuitems["sudo-unmerge"].hide()
else:
self.popup_menuitems["emerge"].hide()
self.popup_menuitems["unmerge"].hide()
#self.popup_menuitems["add-keyword"].hide()
#self.popup_menuitems["remove-keyword"].hide()
#self.popup_menuitems["package-unmask"].hide()
#self.popup_menuitems["un-package-unmask"].hide()
if eventbox.ebuild in self.installed:
if utils.can_sudo():
self.popup_menuitems["sudo-unmerge"].show()
else:
self.popup_menuitems["sudo-unmerge"].hide()
self.popup_menuitems["sudo-emerge"].hide()
self.popup_menuitems["pretend-emerge"].hide()
else:
self.popup_menuitems["sudo-unmerge"].hide()
if utils.can_sudo():
self.popup_menuitems["sudo-emerge"].show()
else:
self.popup_menuitems["sudo-emerge"].hide()
self.popup_menuitems["pretend-emerge"].show()
self.popup_menu.popup(None, None, None, event.button, event.time)
# de-select the table cell. Would be nice to leave it selected,
# but it doesn't get de-selected when the menu is closed.
eventbox.emit("leave-notify-event",
gtk.gdk.Event(gtk.gdk.LEAVE_NOTIFY))
return True
def __init__(self):
debug.dprint("MAINWINDOW: process id = %d ****************" %
os.getpid())
# set unfinished items to not be sensitive
#self.wtree.get_widget("contents2").set_sensitive(False)
# self.wtree.get_widget("btn_help").set_sensitive(False)
# Initialize our subclasses
PluginHandler.__init__(self)
self.status = StatusHandler(self.wtree.get_widget("statusbar2"),
self.wtree.get_widget("progressbar1"),
self.category_view, self.package_view,
self.current_pkg_path,
self.current_pkg_cursor, self.plugin_views)
# get an empty tooltip
##self.synctooltip = gtk.Tooltips()
self.sync_tip = _(
" Synchronise Package Database \n The last sync was done:\n")
# set the sync label to the saved one set in the options
self.widget["btn_sync"].set_label(config.Prefs.globals.Sync_label)
self.widget["view_refresh"].set_sensitive(False)
# restore last window width/height
if config.Prefs.main.xpos and config.Prefs.main.ypos:
self.mainwindow.move(config.Prefs.main.xpos,
config.Prefs.main.ypos)
self.mainwindow.resize(config.Prefs.main.width,
config.Prefs.main.height)
# connect gtk callback for window movement and resize events
self.mainwindow.connect("configure-event", self.size_update)
# restore maximized state and set window-state-event
# handler to keep track of it
if config.Prefs.main.maximized:
self.mainwindow.maximize()
self.mainwindow.connect("window-state-event",
self.on_window_state_event)
# move horizontal and vertical panes
#debug.dprint("MAINWINDOW: __init__() before hpane; " +
#"%d, vpane; %d"
#%(config.Prefs.main.hpane, config.Prefs.main.vpane))
self.hpane = self.wtree.get_widget("hpane")
self.hpane.set_position(config.Prefs.main.hpane)
self.hpane.connect("notify", self.on_pane_notify)
self.vpane = self.wtree.get_widget("vpane")
self.vpane.set_position(config.Prefs.main.vpane)
self.vpane.connect("notify", self.on_pane_notify)
# Intercept the window delete event signal
self.mainwindow.connect('delete-event', self.confirm_delete)
# initialize some variable to fix the hpane jump bug
#self.hpane_bug_count = 0
#self.hpane_bug = True
# initialize now so that the update_db_callback doesn't puke
self.status.set_statusbar2("Starting")
# set if we are root or not
self.is_root = utils.is_root()
debug.dprint("MAINWINDOW: __init__(); is_root = " + str(self.is_root))
if config.Prefs.main.show_nag_dialog:
# let the user know if he can emerge or not
self.check_for_root()
self.toolbar_expander = self.wtree.get_widget("toolbar_expander")
# This should be set in the glade file, but doesn't seem to work ?
self.toolbar_expander.set_expand(True)
# populate the view_filter menu
self.widget["view_filter_list"] = gtk.ListStore(str)
for i in [
_("All Packages"),
_("Installed Packages"),
_("Search Results"),
_("Upgradable Packages"),
_("Deprecated Packages"),
_("Sets")
]:
self.widget["view_filter_list"].append([i])
self.widget["view_filter"].set_model(self.widget["view_filter_list"])
self.widget["view_filter"].set_active(SHOW_ALL)
self.setup_plugins()
callbacks = {
"action_callback": self.action_callback,
"re_init_portage": self.re_init_portage,
"set_package_actions_sensitive": self.set_package_actions_sensitive
}
self.assign_packagebook(self.wtree, callbacks,
self.plugin_package_tabs)
# initialize our data
self.init_data()
self.search_dispatcher = Dispatcher(self.search_done)
debug.dprint("MAINWINDOW: Showing main window")
self.mainwindow.show_all()
if self.is_root:
# hide warning toolbar widget
debug.dprint("MAINWINDOW: __init__(); hiding btn_root_warning")
self.wtree.get_widget("btn_root_warning").hide()
def _clicked(self, treeview, *args):
""" Handle treeview clicks """
name, package = self.get_selected()
# has the selection really changed?
if name != self._last_selected:
debug.dprint("DependsView: dependency change detected")
# then call the callback if it exists!
if self._depend_changed:
self._last_selected = name
self._depend_changed(package)
# save current selection as last selected
self._last_selected = name
#pop up menu if was rmb-click and have a valid package
if self.dopopup and package:
if utils.is_root():
if package.get_best_ebuild() != package.get_latest_ebuild(
): # i.e. no ~arch keyword
self.popup_menuitems["add-keyword"].show()
else:
self.popup_menuitems["add-keyword"].hide()
installed = package.get_installed()
havebest = False
if installed:
#self.popup_menuitems["unmerge"].show()
if package.get_best_ebuild() in installed:
havebest = True
else:
pass
#self.popup_menuitems["unmerge"].hide()
if havebest:
self.popup_menuitems["emerge --oneshot"].hide()
self.popup_menuitems["pretend-emerge"].hide()
else:
self.popup_menuitems["emerge --oneshot"].show()
self.popup_menuitems["pretend-emerge"].show()
self.popup_menuitems["sudo-emerge --oneshot"].hide()
#self.popup_menuitems["sudo-unmerge"].hide()
else:
self.popup_menuitems["emerge --oneshot"].hide()
#self.popup_menuitems["unmerge"].hide()
if utils.can_gksu() and \
(package.get_best_ebuild() != package.get_latest_ebuild()):
self.popup_menuitems["add-keyword"].show()
else:
self.popup_menuitems["add-keyword"].hide()
installed = package.get_installed()
havebest = False
if installed and utils.can_sudo():
#self.popup_menuitems["sudo-unmerge"].show()
if package.get_best_ebuild() in installed:
havebest = True
else:
pass
#self.popup_menuitems["sudo-unmerge"].hide()
if havebest:
self.popup_menuitems["sudo-emerge --oneshot"].hide()
self.popup_menuitems["pretend-emerge"].hide()
else:
if utils.can_sudo():
self.popup_menuitems["sudo-emerge --oneshot"].show()
else:
self.popup_menuitems["sudo-emerge --oneshot"].hide()
self.popup_menuitems["pretend-emerge"].show()
self.popup_menu.popup(None, None, None, self.event.button,
self.event.time)
self.dopopup = False
self.event = None
return True
def __init__(self, package, setup_command, re_init_portage):
""" Initialize Advanced Emerge Dialog window """
# Preserve passed parameters
self.package = package
self.setup_command = setup_command
self.re_init_portage = re_init_portage
self.arch = backends.portage_lib.get_arch()
self.system_use_flags = backends.portage_lib.settings.SystemUseFlags
self.emerge_unmerge = "emerge"
self.is_root = utils.is_root()
self.package_use_flags = db.userconfigs.get_user_config(
'USE', package.full_name)
self.current_verInfo = None
# Parse glade file
self.gladefile = config.Prefs.DATA_PATH + "glade/advemerge.glade"
self.wtree = Gtk.Builder()
self.wtree.add_from_file(self.gladefile)
self.wtree.set_translation_domain(config.Prefs.APP)
# register callbacks
callbacks = {
"on_ok_clicked":
self.ok_clicked,
"on_help_clicked":
self.help_clicked,
"on_cancel_clicked":
self.cancel_clicked,
#"on_cbAsk_clicked": self.Ask_clicked,
"on_cbOnlyDeps_clicked":
(self.set_one_of, 'cbOnlyDeps', 'cbNoDeps'),
"on_cbNoDeps_clicked": (self.set_one_of, 'cbNoDeps', 'cbOnlyDeps'),
"on_cbQuiet_clicked": (self.set_one_of, 'cbQuiet', 'cbVerbose'),
"on_cbVerbose_clicked": (self.set_one_of, 'cbVerbose', 'cbQuiet'),
"on_cbBuildPkg_clicked":
(self.set_one_of, 'cbBuildPkg', 'cbBuildPkgOnly'),
"on_cbBuildPkgOnly_clicked":
(self.set_one_of, 'cbBuildPkgOnly', 'cbBuildPkg'),
"on_cbUsePkg_clicked":
(self.set_one_of, 'cbUsePkg', 'cbUsePkgOnly'),
"on_cbUsePkgOnly_clicked": (self.set_one_of, 'cbUsePkgOnly',
'cbUsePkg'),
"on_cmbVersion_changed":
self.version_changed,
"on_cmbEmerge_changed":
self.emerge_changed,
"on_btnPkgUse_clicked":
self.on_package_use_commit,
"on_btnMakeConf_clicked":
self.on_make_conf_commit,
"on_btnPkgKeywords_clicked":
self.on_package_keywords_commit,
"on_cbColorY_clicked": (self.set_one_of, 'cbColorY', 'cbColorN'),
"on_cbColorN_clicked": (self.set_one_of, 'cbColorN', 'cbColorY'),
"on_cbColumns_clicked": (self.set_all, 'cbColumns', 'cbPretend'),
'on_cbWithBDepsY_clicked': (self.set_one_of, 'cbWithBDepsY',
'cbWithBDepsN'),
'on_cbWithBDepsN_clicked': (self.set_one_of, 'cbWithBDepsN',
'cbWithBDepsY'),
'on_cbGetBinPkg_clicked': (self.set_one_of, 'cbGetBinPkg',
'cbGetBinPkgOnly'),
'on_cbGetBinPkgOnly_clicked': (self.set_one_of, 'cbGetBinPkgOnly',
'cbGetBinPkg'),
"on_toggled":
self.on_toggled
}
self.wtree.connect_signals(callbacks)
self.window = self.wtree.get_object("adv_emerge_dialog")
self.use_flags_frame = self.wtree.get_object("frameUseFlags")
self.keywords_frame = self.wtree.get_object("frameKeywords")
self.window.set_title(
_("Advanced Emerge Settings for %s") % package.full_name)
self.command_textview = self.wtree.get_object("command_textview")
self.command_buffer = self.command_textview.get_buffer()
style = self.keywords_frame.get_style().copy()
# Fixme needs porting ???
# <<<<<<< ours
# #self.bgcolor = style.bg[Gtk.StateType.NORMAL]
# self.bgcolor = style.bg[Gladeui.PropertyState.NORMAL]
# #self.command_textview.modify_base(Gtk.StateType.NORMAL, self.bgcolor)
# self.command_textview.modify_base(Gladeui.PropertyState.NORMAL, self.bgcolor)
# =======
# self.bgcolor = style.bg[Gladeui.PropertyState.NORMAL]
# self.command_textview.modify_base(Gladeui.PropertyState.NORMAL, self.bgcolor)
# >>>>>>> theirs
self.btnMakeConf = self.wtree.get_object("btnMakeConf")
self.btnPkgUse = self.wtree.get_object("btnPkgUse")
self.btnPkgKeywords = self.wtree.get_object("btnPkgKeywords")
if not self.is_root and not utils.can_gksu():
debug.dprint("ADVEMERGE: self.is_root = %s, utils.can_gksu = %s" %
(self.is_root, utils.can_gksu))
self.btnMakeConf.hide()
self.btnPkgUse.hide()
self.btnPkgKeywords.hide()
# Connect option toggles to on_toggled
for checkbutton in self.wtree.get_object("table2").get_children():
if isinstance(checkbutton, Gtk.CheckButton):
checkbutton.connect("toggled", self.on_toggled)
#else:
# debug.dprint("ADVEMERGE: table2 has child not of type Gtk.CheckButton")
# debug.dprint(checkbutton)
if not config.Prefs.advemerge.showuseflags:
self.use_flags_frame.hide()
if not config.Prefs.advemerge.showkeywords:
self.keywords_frame.hide()
# Make tool tips available
#self.tooltips = Gtk.Tooltips()
# Build version combo list
self.get_versions()
# Build a formatted combo list from the versioninfo list
self.comboList = Gtk.ListStore(str)
index = 0
for x in range(len(self.verList)):
ver = self.verList[x]
info = ver["number"]
slot = ver["slot"]
if slot != '0':
info += ''.join([' [', _('Slot:%s') % slot, ']'])
if not ver["available"]:
info += _(' {unavailable}')
elif not ver["stable"]:
info += _(' (unstable)')
if ver["hard_masked"]:
info += _(' [MASKED]')
if ver["best"]:
if ver["best_downgrades"]:
info += _(' (recommended) (downgrade)')
else:
info += _(' (recommended)')
index = x
if ver["installed"]:
info += _(' [installed]')
self.comboList.append([info])
# Build version combobox
self.combobox = self.wtree.get_object("cmbVersion")
self.combobox.set_model(self.comboList)
cell = Gtk.CellRendererText()
self.combobox.pack_start(cell, True)
self.combobox.add_attribute(cell, 'text', 0)
self.combobox.set_active(
index) # select "recommended" ebuild by default
# emerge / unmerge combobox:
self.emerge_combolist = Gtk.ListStore(str)
iter = self.emerge_combolist.append(["emerge"])
self.emerge_combolist.append(["unmerge"])
self.emerge_combobox = self.wtree.get_object("cmbEmerge")
self.emerge_combobox.set_model(self.emerge_combolist)
cell = Gtk.CellRendererText()
self.emerge_combobox.pack_start(cell, True)
self.emerge_combobox.add_attribute(cell, 'text', 0)
self.emerge_combobox.set_active_iter(iter)
# Set any emerge options the user wants defaulted
if config.Prefs.emerge.pretend:
self.wtree.get_object("cbPretend").set_active(True)
if config.Prefs.emerge.verbose:
self.wtree.get_object("cbVerbose").set_active(True)
## this now just references --update, which is probably not the desired behaviour.
## perhaps the current version should be indicated somewhere in the dialog
#if config.Prefs.emerge.upgradeonly:
# self.wtree.get_object("cbUpgradeOnly").set_active(True)
if config.Prefs.emerge.fetch:
self.wtree.get_object("cbFetchOnly").set_active(True)
if config.Prefs.emerge.nospinner:
self.wtree.get_object("cbNoSpinner").set_active(True)
# show command in command_label
self.display_emerge_command()
