--- a/src/packagemanager.py Fri Sep 27 11:21:00 2013 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4998 +0,0 @@
-#!/usr/bin/python2.6
-#
-# CDDL HEADER START
-#
-# The contents of this file are subject to the terms of the
-# Common Development and Distribution License (the "License").
-# You may not use this file except in compliance with the License.
-#
-# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
-# or http://www.opensolaris.org/os/licensing.
-# See the License for the specific language governing permissions
-# and limitations under the License.
-#
-# When distributing Covered Code, include this CDDL HEADER in each
-# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
-# If applicable, add the following below this CDDL HEADER, with the
-# fields enclosed by brackets "[]" replaced with your own identifying
-# information: Portions Copyright [yyyy] [name of copyright owner]
-#
-# CDDL HEADER END
-#
-# Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
-#
-
-NOTEBOOK_PACKAGE_LIST_PAGE = 0 # Main Package List page index
-NOTEBOOK_START_PAGE = 1 # Main View Start page index
-INFO_NOTEBOOK_DEPENDENCIES_PAGE = 2 # Dependencies Tab index
-INFO_NOTEBOOK_LICENSE_PAGE = 3 # License Tab index
-INFO_NOTEBOOK_VERSIONS_PAGE = 4 # Versions Tab index
-PM_LAUNCH_OPEN_CMD = "pm-launch: OPEN:" # Command to tell pm-launch to open link.
-PUBLISHER_ALL = 0 # Index for "All Publishers" string
-PUBLISHER_INSTALLED = 1 # Index for "All Installed Packages" string
-PUBLISHER_ALL_SEARCH = 2 # Index for "All Publishers (Search)" string
-PUBLISHER_ADD = 3 # Index for "Add..." string
-SHOW_INFO_DELAY = 100 # Delay before showing selected package information
-SHOW_DEPENDENCIES_DELAY = 100 # Delay before showing selected package dependencies
-SHOW_LICENSE_DELAY = 100 # Delay before showing license information
-SHOW_VERSIONS_DELAY = 100 # Delay before showing versions information
-RESIZE_DELAY = 600 # Delay before handling resize for startpage
-INC_RESULTS_DELAY = 800 # Delay before updating incremental search results
-SEARCH_STR_FORMAT = "<%s>"
-MIN_APP_WIDTH = 750 # Minimum application width
-MIN_APP_HEIGHT = 500 # Minimum application height
-SECTION_ID_OFFSET = 10000 # Offset to allow Sections to be identified
- # in category tree
-RECENT_SEARCH_ID_OFFSET = 10999 # Offset to allow Recent Search Sections
- # to be identified in category tree
-RECENT_SEARCH_ID = RECENT_SEARCH_ID_OFFSET + 1 # Recent Search Section ID
-CATEGORY_TOGGLE_ICON_WIDTH = 16 # Width of category toggle icon
-STATUS_COLUMN_INDEX = 2 # Index of Status Column in Application TreeView
-GDK_2BUTTON_PRESS = 5 # gtk.gdk._2BUTTON_PRESS causes pylint warning
-GDK_RIGHT_BUTTON = 3 # normally button 3 = right click
-
-VIEW_COMBOBOX_WIDTH_PADDING = 72 # Padding for View combobox, icon, spacing and dropdown
-VIEW_COMBOBOX_MIN_WIDTH = 143 # Min width for View combobox, 10pt default font
-VIEW_COMBOBOX_MAX_WIDTH = 312 # Max width for View combobox, 20pt default font
-PUBLISHER_VIEW_MIN_PADDING = 25 # Min space between Publisher and View comboboxes
-
-# Location for themable icons
-ICON_LOCATION = "usr/share/package-manager/icons"
-
-import getopt
-import pwd
-import os
-import sys
-import time
-import locale
-import itertools
-import socket
-import gettext
-import signal
-import re
-from xml.sax import saxutils
-from threading import Thread
-from gettext import ngettext
-
-try:
- import gobject
- import gnome
- gobject.threads_init()
- import gtk
- import gtk.glade
- import pygtk
- pygtk.require("2.0")
-except ImportError:
- sys.exit(1)
-import pkg.misc as misc
-import pkg.client.progress as progress
-import pkg.client.api_errors as api_errors
-import pkg.client.api as api
-import pkg.client.publisher as publisher
-import pkg.portable as portable
-import pkg.fmri as fmri
-import pkg.nrlock as nrlock
-import pkg.gui.beadmin as beadm
-import pkg.gui.cache as cache
-import pkg.gui.detailspanel as detailspanel
-import pkg.gui.entrystyle as entrystyle
-import pkg.gui.enumerations as enumerations
-import pkg.gui.exportconfirm as exportconfirm
-import pkg.gui.globalexceptionhandler as globalexceptionhandler
-import pkg.gui.imageinfo as imageinfo
-import pkg.gui.installupdate as installupdate
-import pkg.gui.misc as gui_misc
-import pkg.gui.pmgconf as gconf
-import pkg.gui.pmlogging as logging
-import pkg.gui.preferences as preferences
-import pkg.gui.repository as repository
-import pkg.gui.searcherror as searcherror
-import pkg.gui.startpage as startpage
-import pkg.gui.webinstall as webinstall
-import pkg.gui.versioninfo as versioninfo
-from pkg.client import global_settings
-
-logger = global_settings.logger
-
-# Put _() in the global namespace
-import __builtin__
-__builtin__._ = gettext.gettext
-
-REGEX_STRIP_MARKUP = re.compile(r'<.*?>')
-REGEX_STRIP_RESULT = re.compile(r'\(\d+\) ?')
-
-class PackageManager:
- def __init__(self, title):
- self.allow_links = False
- self.program_title = title
- signal.signal(signal.SIGINT, self.__main_application_quit)
- self.is_admin = portable.is_admin()
- self.user_rights = True
- self.api_lock = nrlock.NRLock()
- self.__reset_home_dir()
- self.api_o = None
- self.cache_o = None
- self.child = None
- self.img_timestamp = None
- self.gconf = gconf.PMGConf()
- self.set_section = 0
- self.after_install_remove = False
- self.in_search_mode = False
- self.search_results_id = 0
- self.search_results = []
- self.in_recent_search = False
- self.recent_searches = {}
- self.recent_searches_cat_iter = None
- self.adding_recent_search = False
- self.recent_searches_list = []
- self.previous_search_text = None
-
- global_settings.client_name = gui_misc.get_pm_name()
-
- # This call only affects sockets created by Python. The
- # transport framework uses the defaults in global_settings,
- # which may be overridden in the environment. The default
- # socket module should only be used in rare cases by ancillary
- # code, making it safe to code the value here, at least for now.
- socket.setdefaulttimeout(30) # in secs
-
- try:
- self.application_dir = os.environ["PACKAGE_MANAGER_ROOT"]
- except KeyError:
- self.application_dir = "/"
- misc.setlocale(locale.LC_ALL, "")
- for module in (gettext, gtk.glade):
- module.bindtextdomain("pkg", os.path.join(
- self.application_dir,
- "usr/share/locale"))
- module.textdomain("pkg")
- gui_misc.init_for_help(self.application_dir)
- self.startpage = startpage.StartPage(self, self.application_dir)
- self.gdk_window = None
- self.cancelled = False # For background processes
- self.image_directory = None
- gtk.rc_parse('~/.gtkrc-1.2-gnome2') # Load gtk theme
- self.progress_stop_thread = True
- self.progress_thread_stopped = True
- self.update_all_proceed = False
- self.application_path = None
- self.default_publisher = None
- self.current_repos_with_search_errors = []
- self.exiting = False
- self.first_run = True
- self.info_pkgstem = None
- self.dependencies_pkgstem = None
- self.license_pkgstem = None
- self.versions_pkgstem = None
- self.selected_pkg_name = None
- self.selected_pkg_pub = None
- self.selected_pkgstem = None
- self.selected_model = None
- self.selected_path = None
- self.all_selected = 0
- self.selected_pkgs = {}
- self.package_names = {}
- self.special_package_names = []
- self.to_install_update = {}
- self.to_remove = {}
- self.in_startpage_startup = self.gconf.show_startpage
- self.visible_status_id = 0
- self.same_publisher_on_setup = False
- self.force_reload_packages = True
- self.icon_theme = None
- self.installed_icon = None
- self.not_installed_icon = None
- self.update_available_icon = None
- self.window_icon = None
- self.filter_options = []
- self.__setup_theme_icons()
- self.publisher_options = {
- PUBLISHER_ALL : _("All Publishers"),
- PUBLISHER_INSTALLED : _("All Installed Packages"),
- PUBLISHER_ALL_SEARCH : _("All Publishers (Search)"),
- PUBLISHER_ADD : _("Add...")
- }
- self.max_filter_length = 0
- self.pubs_info = {}
- self.pubs_display_name = {}
- self.last_visible_publisher = None
- self.publisher_changed = True
- self.search_start = 0
- self.search_time_sec = 0
- self.publisher_being_searched = None
- self.section_list = None
- self.filter_list = self.__get_new_filter_liststore()
- self.length_visible_list = 0
- self.application_list = None
- self.a11y_application_treeview = None
- self.application_treeview_range = None
- self.application_treeview_initialized = False
- self.application_select_column = None
- self.category_list = None
- self.repositories_list = None
- self.repo_combobox_all_pubs_index = 0
- self.repo_combobox_all_pubs_installed_index = 0
- self.repo_combobox_all_pubs_search_index = 0
- self.repo_combobox_add_index = 0
- self.pr = progress.NullProgressTracker()
- self.pylintstub = None
- self.category_expanded_paths = {}
- self.category_active_paths = {}
- self.error_logged = False
-
- # Create Widgets and show gui
- self.builder = gtk.Builder()
- self.gladefile = os.path.join(self.application_dir,
- "usr/share/package-manager/packagemanager.ui")
- self.builder.add_from_file(self.gladefile)
-
- self.w_main_window = self.builder.get_object("mainwindow")
- self.w_main_window.set_icon(self.window_icon)
- self.w_main_hpaned = self.builder.get_object("main_hpaned")
- self.w_main_vpaned = self.builder.get_object("main_vpaned")
-
- self.w_publisher_combobox_hbox = \
- self.builder.get_object("publisher_combobox_hbox")
- self.w_view_combobox_hbox = self.builder.get_object("view_combobox_hbox")
-
- self.w_application_treeview = \
- self.builder.get_object("applicationtreeview")
- self.w_application_treeview.set_enable_search(True)
- self.w_application_treeview.set_search_equal_func(
- self.__applicationtreeview_compare_func)
-
- self.w_categories_treeview = self.builder.get_object("categoriestreeview")
- self.w_categories_treeview.set_search_equal_func(
- self.__categoriestreeview_compare_func)
-
- self.w_info_notebook = self.builder.get_object("details_notebook")
- self.w_startpage_scrolled_window = \
- self.builder.get_object("startpage_scrolled_window")
- self.w_startpage_eventbox = \
- self.builder.get_object("startpage_eventbox")
- self.w_startpage_eventbox.modify_bg(gtk.STATE_NORMAL,
- gtk.gdk.color_parse("white"))
-
- self.w_main_statusbar = self.builder.get_object("statusbar")
- #Allow markup in StatusBar
- self.w_main_statusbar_label = \
- gui_misc.get_statusbar_label(self.w_main_statusbar)
- if self.w_main_statusbar_label:
- self.w_main_statusbar_label.set_use_markup(True)
-
- self.w_statusbar_hbox = self.builder.get_object("statusbar_hbox")
- self.w_logalert_frame = self.builder.get_object("logalert_frame")
-
- self.w_progress_frame = self.builder.get_object("progress_frame")
- self.w_status_progressbar = self.builder.get_object("status_progressbar")
- self.w_status_progressbar.set_pulse_step(0.1)
- self.w_progress_frame.hide()
-
- self.w_main_view_notebook = \
- self.builder.get_object("main_view_notebook")
- self.w_searchentry = self.builder.get_object("searchentry")
- self.w_searchentry.set_tooltip_text(
- _("Type text to search for the package."))
- self.entrystyle = entrystyle.EntryStyle(self.w_searchentry)
- self.search_completion = gtk.ListStore(str)
- self.w_package_menu = self.builder.get_object("package_menu")
- self.w_reload_button = self.builder.get_object("reload_button")
- self.w_reload_button.set_tooltip_text(
- _("Refresh list of packages and package status"))
- self.w_installupdate_button = \
- self.builder.get_object("install_update_button")
- self.w_installupdate_button.set_tooltip_text(
- _("Select packages by marking the checkbox and click "
- "to Install/Update"))
- self.w_remove_button = self.builder.get_object("remove_button")
- self.w_remove_button.set_tooltip_text(
- _("Select packages by marking the checkbox and click "
- "to Remove selected"))
- self.w_updateall_button = self.builder.get_object("update_all_button")
- self.w_updateall_button.set_tooltip_text(
- _("Checks if updates are available"))
- self.w_repository_combobox = self.builder.get_object("repositorycombobox")
- self.w_filter_combobox = self.builder.get_object("filtercombobox")
- self.w_packageicon_image = self.builder.get_object("packageimage")
- self.w_reload_menuitem = self.builder.get_object("file_reload")
- gui_misc.set_icon_for_button_and_menuitem('pm-refresh',
- self.w_reload_button, self.w_reload_menuitem)
- self.w_version_info_menuitem = \
- self.builder.get_object("package_version_info")
- self.__set_image_for_menuitem(self.w_version_info_menuitem,
- gtk.STOCK_INFO)
- self.w_version_info_menuitem.set_sensitive(False)
- self.w_installupdate_menuitem = \
- self.builder.get_object("package_install_update")
- gui_misc.set_icon_for_button_and_menuitem('pm-install_update',
- self.w_installupdate_button, self.w_installupdate_menuitem)
- self.w_remove_menuitem = self.builder.get_object("package_remove")
- gui_misc.set_icon_for_button_and_menuitem('pm-remove',
- self.w_remove_button, self.w_remove_menuitem)
- self.w_updateall_menuitem = self.builder.get_object("package_update_all")
- gui_misc.set_icon_for_button_and_menuitem('pm-update_all',
- self.w_updateall_button, self.w_updateall_menuitem)
- self.w_quit_menuitem = self.builder.get_object("file_quit")
- self.w_be_menuitem = self.builder.get_object("file_be")
- self.w_export_selections_menuitem = self.builder.get_object(
- "file_export_selections")
- self.w_manage_publishers_menuitem = self.builder.get_object(
- "file_manage_publishers")
- self.w_add_publisher_menuitem = self.builder.get_object(
- "file_add_publisher")
- self.w_cut_menuitem = self.builder.get_object("edit_cut")
- self.w_copy_menuitem = self.builder.get_object("edit_copy")
- self.w_paste_menuitem = self.builder.get_object("edit_paste")
- self.w_delete_menuitem = self.builder.get_object("edit_delete")
- self.w_selectall_menuitem = self.builder.get_object("edit_select_all")
- help_stock_item = gtk.stock_lookup("gtk-help")
- if help_stock_item:
- help_menu_item = self.builder.get_object("help")
- help_menu_item.set_label(help_stock_item[1])
-
- self.w_selectupdates_menuitem = \
- self.builder.get_object("edit_select_updates")
- self.w_deselect_menuitem = self.builder.get_object("edit_deselect")
- self.w_clear_search_menuitem = self.builder.get_object("clear")
- self.__set_image_for_menuitem(self.w_clear_search_menuitem,
- gtk.STOCK_CLEAR)
- self.w_help_about_menuitem = self.builder.get_object("help_about")
- self.w_online_help_menuitem = self.builder.get_object("online_help")
- self.__set_image_for_menuitem(self.w_online_help_menuitem,
- gtk.STOCK_HELP)
- self.w_main_clipboard = gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
- self.saved_filter_combobox_active = self.gconf.initial_show_filter
- self.search_button = self.builder.get_object("do_search")
- self.search_button.set_tooltip_text(_("Search"))
- self.w_search_menuitem = self.builder.get_object("search")
- self.__set_image_for_menuitem(self.w_search_menuitem,
- gtk.STOCK_FIND)
- self.w_gotolist_menuitem = self.builder.get_object("gotolist")
- self.w_edit_preferences_menuitem = self.builder.get_object(
- "edit_preferences")
- self.w_log_menuitem = self.builder.get_object("log")
- self.w_logalert_eventbox = self.builder.get_object(
- "logalert_eventbox")
- self.progress_cancel = self.builder.get_object("progress_cancel")
- self.progress_cancel.set_tooltip_text(
- _("Cancel current operation"))
- self.is_all_publishers = False
- self.is_all_publishers_installed = False
- self.is_all_publishers_search = False
- self.saved_repository_combobox_active = -1
- self.saved_section_active = 0
- self.saved_application_list = None
- self.saved_application_list_filter = None
- self.saved_application_list_sort = None
- self.saved_category_list = None
- self.saved_section_list = None
- self.section_categories_list = {}
- self.statusbar_message_id = 0
- toolbar = self.builder.get_object("toolbutton2")
- toolbar.set_expand(True)
- self.detailspanel = detailspanel.DetailsPanel(self, self.builder)
- self.exportconfirm = exportconfirm.ExportConfirm(self.builder,
- self.window_icon, self.gconf, self)
- is_normal_logging_setup = gui_misc.setup_logging()
- self.logging = logging.PMLogging(self.builder, self.window_icon,
- is_normal_logging_setup)
- self.preferences = preferences.Preferences(self, self.builder,
- self.window_icon, self.gconf)
- self.searcherror = searcherror.SearchError(self.builder,
- self.gconf, self)
- self.versioninfo = versioninfo.VersionInfo(self.builder, self)
- self.__init_repository_tree_view()
- self.w_main_window.set_title(self.program_title)
-
- if self.gconf.show_startpage:
- self.__setup_startpage(self.gconf.show_startpage)
-
- self.__setup_signals()
-
- self.installupdate = None
- self.package_selection = None
- self.application_list_filter = None
- self.application_list_sort = None
- self.application_refilter_id = 0
- self.last_status_id = 0
- self.last_show_info_id = 0
- self.show_info_id = 0
- self.last_show_dependencies_id = 0
- self.show_dependencies_id = 0
- self.last_show_licenses_id = 0
- self.show_licenses_id = 0
- self.last_show_versions_id = 0
- self.show_versions_id = 0
- self.resize_id = 0
- self.last_resize = (0, 0)
- self.in_setup = True
- self.__set_initial_sizes()
- self.w_main_window.show_all()
- self.__setup_busy_cursor()
- if self.gconf.show_startpage:
- self.__setup_notebook_page_view()
- else:
- self.w_main_view_notebook.set_current_page(
- NOTEBOOK_PACKAGE_LIST_PAGE)
- self.logging.set_modal_and_transient(self.w_main_window)
- self.preferences.set_modal_and_transient(self.w_main_window)
- self.searcherror.set_modal_and_transient(self.w_main_window)
- self.versioninfo.set_modal_and_transient(self.w_main_window)
-
- self.__setup_text_signals()
-
- # Theme: prevent cell background being set for Inverse themes
- self.is_inverse_theme = False
- self.theme_name = None
- self.__setup_theme_properties()
-
- @staticmethod
- def __set_image_for_menuitem(widget, stock_id):
- image_widget = gtk.image_new_from_stock(stock_id,
- gtk.ICON_SIZE_MENU)
- widget.set_image(image_widget)
-
- def __setup_signals(self):
- ''' Setup signals required for widgets in Package Manager main
- view which are got from GtkBuilder'''
- signals_table = [
- (self.w_main_window, "delete_event",
- self.__on_mainwindow_delete_event),
- (self.w_main_window, "check_resize",
- self.__on_mainwindow_check_resize),
- (self.w_main_window, "key_press_event",
- self.__on_mainwindow_key_press_event),
- (self.w_main_window, "style_set",
- self.__on_mainwindow_style_set),
- (self.w_searchentry, "changed",
- self.__on_searchentry_changed),
- (self.w_searchentry, "focus_in_event",
- self.__on_searchentry_focus_in),
- (self.w_searchentry, "focus_out_event",
- self.__on_searchentry_focus_out),
- (self.w_searchentry, "activate",
- self.__do_search),
- (self.w_searchentry, "icon_press",
- self.__on_clear_search),
- (self.w_filter_combobox, "changed",
- self.__on_filtercombobox_changed),
- (self.w_repository_combobox, "changed",
- self.__on_repositorycombobox_changed),
- (self.w_export_selections_menuitem, "activate",
- self.__on_file_export_selections),
- (self.w_quit_menuitem, "activate",
- self.__on_file_quit_activate),
- (self.w_be_menuitem, "activate",
- self.__on_file_be_activate),
- (self.w_version_info_menuitem, "activate",
- self.__on_version_info),
- (self.w_installupdate_menuitem, "activate",
- self.__on_install_update),
- (self.w_manage_publishers_menuitem, "activate",
- self.__on_file_manage_publishers),
- (self.w_add_publisher_menuitem, "activate",
- self.__on_file_add_publisher),
- (self.w_remove_menuitem, "activate",
- self.__on_remove),
- (self.w_help_about_menuitem, "activate",
- self.__on_help_about),
- (self.w_online_help_menuitem, "activate",
- self.__on_help_help),
- (self.w_paste_menuitem, "activate",
- self.__on_edit_paste),
- (self.w_delete_menuitem, "activate",
- self.__on_delete),
- (self.w_copy_menuitem, "activate",
- self.__on_copy),
- (self.w_cut_menuitem, "activate",
- self.__on_cut),
- (self.w_search_menuitem, "activate",
- self.__on_edit_search_clicked),
- (self.w_gotolist_menuitem, "activate",
- self.__on_goto_list_clicked),
- (self.w_clear_search_menuitem, "activate",
- self.__on_clear_search),
- (self.search_button, "clicked",
- self.__do_search),
- (self.search_button, "button_press_event",
- self.__do_search),
- (self.progress_cancel, "clicked",
- self.__on_progress_cancel_clicked),
- (self.w_selectall_menuitem, "activate",
- self.__on_select_all),
- (self.w_selectupdates_menuitem, "activate",
- self.__on_select_updates),
- (self.w_deselect_menuitem, "activate",
- self.__on_deselect),
- (self.w_edit_preferences_menuitem, "activate",
- self.__on_preferences),
- (self.w_log_menuitem, "activate",
- self.__on_log_activate),
- (self.w_updateall_menuitem, "activate",
- self.__on_update_all),
- (self.w_updateall_button, "clicked",
- self.__on_update_all),
- (self.w_reload_menuitem, "activate",
- self.__on_reload),
- (self.w_reload_button, "clicked",
- self.__on_reload),
- (self.w_installupdate_button, "clicked",
- self.__on_install_update),
- (self.w_remove_button, "clicked",
- self.__on_remove),
- (self.w_info_notebook, "switch_page",
- self.__on_notebook_change),
- (self.w_logalert_eventbox, "button_press_event",
- self.__on_logalert_button_press_event),
- (self.w_application_treeview, "button_press_event",
- self.__on_applicationtreeview_button_and_key_events),
- (self.w_application_treeview, "key_press_event",
- self.__on_applicationtreeview_button_and_key_events),
- (self.w_application_treeview, "query_tooltip",
- self.__on_applicationtreeview_query_tooltip),
- ]
- for widget, signal_name, callback in signals_table:
- widget.connect(signal_name, callback)
-
- self.exportconfirm.setup_signals()
- self.logging.setup_signals()
- self.preferences.setup_signals()
- self.searcherror.setup_signals()
- self.versioninfo.setup_signals()
-
- def __setup_theme_properties(self):
- s = gtk.settings_get_default()
- self.theme_name = s.get_property("gtk-theme-name")
-
- # Theme: set correct Text fg colour for theme in the Search Entry Field
- style = self.w_application_treeview.get_style().copy()
- self.entrystyle.set_theme_colour(style.fg[gtk.STATE_NORMAL])
-
- if self.theme_name == "HighContrastInverse" or \
- self.theme_name == "HighContrastLargePrintInverse":
- self.is_inverse_theme = True
- else:
- self.is_inverse_theme = False
-
- def __setup_notebook_page_view(self):
- self.w_main_view_notebook.set_current_page(NOTEBOOK_START_PAGE)
- self.w_selectall_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(False)
-
- def __set_initial_sizes(self):
- if self.gconf.initial_app_width >= MIN_APP_WIDTH and \
- self.gconf.initial_app_height >= MIN_APP_HEIGHT:
- self.w_main_window.resize(self.gconf.initial_app_width,
- self.gconf.initial_app_height)
- if self.gconf.initial_app_hpos > 0:
- self.w_main_hpaned.set_position(self.gconf.initial_app_hpos)
- if self.gconf.initial_app_vpos > 0:
- self.w_main_vpaned.set_position(self.gconf.initial_app_vpos)
-
- def __setup_busy_cursor(self):
- gdk_win = self.w_main_window.get_window()
- self.gdk_window = gtk.gdk.Window(gdk_win, gtk.gdk.screen_width(),
- gtk.gdk.screen_height(), gtk.gdk.WINDOW_CHILD, 0, gtk.gdk.INPUT_ONLY)
- gdk_cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
-
- self.gdk_window.set_cursor(gdk_cursor)
-
- def __on_file_export_selections(self, menuitem):
- self.exportconfirm.activate(self.selected_pkgs)
-
- def __on_mainwindow_style_set(self, widget, previous_style):
- if self.first_run:
- return
- self.last_resize = -1
- # Theme: setup Theme properties
- self.__setup_theme_properties()
-
- # Theme: setup icons for Theme
- self.__setup_theme_icons()
- self.__reset_view_icons()
-
- # Theme: setup Dialog Icons for Theme
- self.w_main_window.set_icon(self.window_icon)
- self.exportconfirm.set_window_icon(self.window_icon)
- self.logging.set_window_icon(self.window_icon)
- self.preferences.set_window_icon(self.window_icon)
-
- # Theme: setup Main list Selection icon for Theme
- if self.application_select_column:
- self.application_select_column.set_widget(
- self.get_theme_selection_coloumn_image())
-
- # Theme: setup Main list status icons
- self.__reset_application_list_status_icons(self.application_list)
- # Theme: saved application list is cached with old theme icons
- self.__reset_application_list_status_icons(self.saved_application_list)
-
- #Theme: refresh Details icons if package selected
- if self.selected_pkgstem != None:
- self.__process_package_selection()
-
- def get_theme_selection_coloumn_image(self):
- select_image = gtk.Image()
- select_image.set_from_pixbuf(gui_misc.get_icon(
- self.icon_theme, 'selection'))
- select_image.set_tooltip_text(_("Click to toggle selections"))
- select_image.show()
- return select_image
-
- def __setup_theme_icons(self):
- self.icon_theme = gtk.icon_theme_get_default()
- icon_location = os.path.join(self.application_dir, ICON_LOCATION)
- self.icon_theme.append_search_path(icon_location)
- self.installed_icon = gui_misc.get_icon(self.icon_theme,
- 'status_installed')
- self.not_installed_icon = gui_misc.get_icon(self.icon_theme,
- 'status_notinstalled')
- self.update_available_icon = gui_misc.get_icon(self.icon_theme,
- 'status_newupdate')
- self.window_icon = gui_misc.get_icon(self.icon_theme,
- 'packagemanager', 48)
- self.filter_options = [
- (enumerations.FILTER_ALL,
- gui_misc.get_icon(self.icon_theme, 'filter_all'),
- _('All Packages')),
- (enumerations.FILTER_INSTALLED, self.installed_icon,
- _('Installed Packages')),
- (enumerations.FILTER_UPDATES, self.update_available_icon,
- _('Updates')),
- (enumerations.FILTER_NOT_INSTALLED, self.not_installed_icon,
- _('Not Installed Packages')),
- (-1, None, ""),
- (enumerations.FILTER_SELECTED,
- gui_misc.get_icon(self.icon_theme, 'filter_selected'),
- _('Selected Packages'))
- ]
-
- def __reset_application_list_status_icons(self, app_list):
- if app_list == None or len(app_list) == 0:
- return
- app_itr = app_list.get_iter_first()
-
- while app_itr:
- status = app_list.get_value(app_itr, enumerations.STATUS_COLUMN)
- if status == api.PackageInfo.INSTALLED:
- app_list.set(app_itr, enumerations.STATUS_ICON_COLUMN,
- self.installed_icon)
- elif status == api.PackageInfo.KNOWN:
- app_list.set(app_itr, enumerations.STATUS_ICON_COLUMN,
- self.not_installed_icon)
- elif status == api.PackageInfo.UPGRADABLE:
- app_list.set(app_itr, enumerations.STATUS_ICON_COLUMN,
- self.update_available_icon)
- app_itr = app_list.iter_next(app_itr)
-
- def __reset_view_icons(self):
- filter_itr = self.filter_list.get_iter_first()
- if filter_itr == None or \
- len(self.filter_list) != len(self.filter_options):
- return
- max_length = 0
- for filter_id, pixbuf, label in self.filter_options:
- self.filter_list.set(filter_itr, enumerations.FILTER_ICON, pixbuf)
- filter_itr = self.filter_list.iter_next(filter_itr)
- if filter_id == -1:
- continue
- max_length = gui_misc.get_max_text_length(
- max_length, label, self.w_filter_combobox)
- self.__setup_max_filter_length(max_length)
-
- def __setup_max_filter_length(self, max_length):
- if max_length < VIEW_COMBOBOX_MIN_WIDTH:
- self.max_filter_length = VIEW_COMBOBOX_MIN_WIDTH
- elif max_length > VIEW_COMBOBOX_MAX_WIDTH:
- self.max_filter_length = VIEW_COMBOBOX_MAX_WIDTH
- else:
- self.max_filter_length = max_length
- self.w_filter_combobox.set_size_request(
- self.max_filter_length + VIEW_COMBOBOX_WIDTH_PADDING, -1)
-
- def __set_search_text_mode(self, style):
- self.entrystyle.set_search_text_mode(style)
-
- def __search_completion_cb(self, entry):
- text = entry.get_text()
- if text:
- if text not in [row[0] for row in self.search_completion]:
- len_search_completion = len(self.search_completion)
- if len_search_completion > 0 and \
- len_search_completion >= \
- self.gconf.max_search_completion:
- itr = self.search_completion.get_iter_first()
- if itr:
- self.search_completion.remove(itr)
- self.search_completion.append([text])
- return
-
- def __setup_text_signals(self):
- self.detailspanel.setup_text_signals(
- self.__on_text_buffer_has_selection,
- self.__on_textview_focus_in,
- self.__on_textview_focus_out)
- self.w_searchentry.connect(
- "notify::cursor-position", self.__on_searchentry_selection)
- self.w_searchentry.connect(
- "notify::selection-bound", self.__on_searchentry_selection)
-
- def __on_textview_focus_in(self, widget, event):
- char_count = widget.get_buffer().get_char_count()
- if char_count > 0:
- self.w_selectall_menuitem.set_sensitive(True)
- else:
- self.w_selectall_menuitem.set_sensitive(False)
- bounds = widget.get_buffer().get_selection_bounds()
- if bounds:
- offset1 = bounds[0].get_offset()
- offset2 = bounds[1].get_offset()
- if abs(offset2 - offset1) == char_count:
- self.w_selectall_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(True)
- self.w_copy_menuitem.set_sensitive(True)
- else:
- self.w_deselect_menuitem.set_sensitive(False)
-
- def __on_textview_focus_out(self, widget, event):
- self.__enable_disable_select_all()
- self.__enable_disable_deselect()
- self.w_copy_menuitem.set_sensitive(False)
-
- def __on_text_buffer_has_selection(self, obj, pspec):
- if obj.get_selection_bounds():
- self.w_copy_menuitem.set_sensitive(True)
- self.w_deselect_menuitem.set_sensitive(True)
- else:
- self.w_copy_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(False)
-
- def __set_all_publishers_search_mode(self):
- if self.is_all_publishers_search:
- return
- self.__setup_before_all_publishers_search_mode()
-
- def __setup_startpage(self, show_startpage):
- self.startpage.setup_startpage(show_startpage)
- if show_startpage or self.gconf.start_insearch:
- self.w_main_view_notebook.set_current_page(
- NOTEBOOK_START_PAGE)
- if self.gconf.start_insearch:
- self.startpage.document.clear()
- else:
- self.w_main_view_notebook.set_current_page(
- NOTEBOOK_PACKAGE_LIST_PAGE)
- self.w_startpage_scrolled_window.add(self.startpage.view)
-
- def __process_api_search_error(self, error):
- self.current_repos_with_search_errors = []
-
- for pub, err in error.failed_servers:
- logger.error(_("Publisher: %(o)s failed to respond\n%(msg)s") % \
- {"o": pub, "msg": err})
- gui_misc.notify_log_error(self)
- for pub in error.invalid_servers:
- logger.error(_("Publisher: %s: invalid response\n"
- "A valid response was not returned.") % pub)
- gui_misc.notify_log_error(self)
- for pub, err in error.unsupported_servers:
- self.current_repos_with_search_errors.append(
- (pub, _("unsupported search"), err))
-
- def __on_logalert_button_press_event(self, widget, event):
- if len(self.current_repos_with_search_errors) > 0:
- self.__handle_api_search_error(True)
- return
- if self.error_logged:
- self.__on_log_activate(None)
-
- def __handle_api_search_error(self, show_all=False):
- if self.exiting:
- return
- if len(self.current_repos_with_search_errors) == 0:
- if not self.error_logged:
- self.w_logalert_frame.hide()
- return
-
- repo_count = 0
- for item in self.current_repos_with_search_errors:
- if show_all or (item[0] not in self.gconf.not_show_repos):
- repo_count += 1
- if repo_count == 0:
- if not self.error_logged:
- self.w_logalert_frame.hide()
- return
-
- self.w_logalert_frame.set_tooltip_text(
- _("Search Errors: click to view"))
-
- self.w_logalert_frame.show()
- self.searcherror.display_search_errors(show_all)
-
- def __get_publisher_combobox_index(self, pub_name):
- index = -1
- model = self.w_repository_combobox.get_model()
- for entry in model:
- if entry[enumerations.REPOSITORY_PREFIX] == pub_name:
- index = entry[enumerations.REPOSITORY_ID]
- break
- return index
-
- def __handle_browse_publisher(self, index):
- if index == -1:
- return
- self.w_repository_combobox.grab_focus()
- self.w_repository_combobox.set_active(index)
-
- def handle_search_all_publishers(self):
- term = self.previous_search_text
- self.__set_search_start()
- self.is_all_publishers_installed = False
- self.is_all_publishers = False
- self.w_repository_combobox.set_active(
- self.repo_combobox_all_pubs_search_index)
- self.__set_search_text_mode(enumerations.SEARCH_STYLE_NORMAL)
- self.w_searchentry.set_text(term)
- gobject.idle_add(self.__do_search)
-
- def handle_view_all_publishers_installed(self):
- self.w_filter_combobox.set_active(enumerations.FILTER_ALL)
- self.__set_main_view_package_list()
- self.update_statusbar()
-
- def get_start_end_strings(self):
- if self.w_main_statusbar_label:
- s1 = "<b>"
- e1 = "</b>"
- else:
- s1 = e1 = '"'
- return s1, e1
-
- def browse_publisher(self, pub):
- index = self.__get_publisher_combobox_index(pub)
- gobject.idle_add(self.__handle_browse_publisher, index)
-
- def goto_recent_search(self, recent_search):
- category_tree = self.w_categories_treeview.get_model()
- if category_tree == None:
- return
- rs_iter = category_tree.iter_children(
- self.recent_searches_cat_iter)
- rs_path = category_tree.get_path(self.recent_searches_cat_iter)
- if not self.w_categories_treeview.row_expanded(rs_path):
- self.w_categories_treeview.expand_row(rs_path, False)
- while rs_iter:
- rs_value = category_tree.get_value(rs_iter,
- enumerations.CATEGORY_VISIBLE_NAME)
- if rs_value == recent_search:
- path = category_tree.get_path(rs_iter)
- self.w_categories_treeview.set_cursor(path)
- self.w_categories_treeview.scroll_to_cell(path)
- return
- rs_iter = category_tree.iter_next(rs_iter)
- return
-
- def set_view_all_packages(self):
- self.w_filter_combobox.set_active(enumerations.FILTER_ALL)
- self.w_filter_combobox.grab_focus()
-
- def invoke_webinstall(self, link):
- self.set_busy_cursor()
- try:
- gobject.spawn_async([self.application_path, "-i", link])
- except gobject.GError:
- self.startpage.link_load_error(link)
- self.unset_busy_cursor()
- return
- gobject.timeout_add(1500, self.unset_busy_cursor)
-
- def open_link(self, link):
- self.set_busy_cursor()
-
- if not self.allow_links:
- # Links not allowed.
- self.startpage.link_load_error(link)
- self.unset_busy_cursor()
- return
- elif not self.is_admin:
- # Not a privileged user? Show links directly.
- try:
- gnome.url_show(link)
- gobject.timeout_add(1000,
- self.unset_busy_cursor)
- except gobject.GError:
- self.startpage.link_load_error(link)
- self.unset_busy_cursor()
- return
-
- # XXX PackageManager shouldn't run as a privileged user!
- # Opening links relies on the packagemanager having been
- # launched by the pm-launch process. The pm-launch process
- # monitors the output of its child process for special commands
- # such as the one used to below to launch links. This causes
- # the pm-launch program to open this link as the original user
- # that executed pm-launch instead of as the current, privileged
- # user the packagemanager is likely running as.
- try:
- # XXX There's no way to know if opening the link failed
- # using this method; the assumption is that the user
- # will be informed somehow by the launcher or browser.
- print "%s%s" % (PM_LAUNCH_OPEN_CMD, link)
- sys.stdout.flush()
- gobject.timeout_add(1000, self.unset_busy_cursor)
- except IOError, ex:
- # Any exception from the above likely means that the
- # link wasn't loaded. For example, an IOError or
- # some other exception might be raised if the launch
- # process was killed.
- self.startpage.link_load_error(link)
- self.unset_busy_cursor()
-
- # Log the error for post-mortem evaluation.
- logger.error(str(ex))
- except Exception, ex:
- self.startpage.link_load_error(link)
- self.unset_busy_cursor()
- logger.error(str(ex))
-
- @staticmethod
- def __get_new_application_liststore():
- return gtk.ListStore(
- gobject.TYPE_BOOLEAN, # enumerations.MARK_COLUMN
- gtk.gdk.Pixbuf, # enumerations.STATUS_ICON_COLUMN
- gobject.TYPE_STRING, # enumerations.NAME_COLUMN
- gobject.TYPE_STRING, # enumerations.DESCRIPTION_COLUMN
- gobject.TYPE_INT, # enumerations.STATUS_COLUMN
- gobject.TYPE_STRING, # enumerations.STEM_COLUMN
- gobject.TYPE_STRING, # enumerations.ACTUAL_NAME_COLUMN
- gobject.TYPE_BOOLEAN, # enumerations.IS_VISIBLE_COLUMN
- gobject.TYPE_PYOBJECT, # enumerations.CATEGORY_LIST_COLUMN
- gobject.TYPE_STRING, # enumerations.PUBLISHER_COLUMN
- gobject.TYPE_STRING, # enumerations.PUBLISHER_PREFIX_COLUMN
- gobject.TYPE_BOOLEAN # enumerations.RENAMED_COLUMN
- )
-
- @staticmethod
- def __get_new_category_liststore():
- return gtk.TreeStore(
- gobject.TYPE_INT, # enumerations.CATEGORY_ID
- gobject.TYPE_STRING, # enumerations.CATEGORY_NAME
- gobject.TYPE_STRING, # enumerations.CATEGORY_VISIBLE_NAME
- gobject.TYPE_STRING, # enumerations.CATEGORY_DESCRIPTION
- gobject.TYPE_PYOBJECT, # enumerations.SECTION_LIST_OBJECT
- gobject.TYPE_BOOLEAN, # enumerations.CATEGORY_IS_VISIBLE
- )
-
- @staticmethod
- def __get_new_section_liststore():
- return gtk.ListStore(
- gobject.TYPE_INT, # enumerations.SECTION_ID
- gobject.TYPE_STRING, # enumerations.SECTION_NAME
- gobject.TYPE_BOOLEAN, # enumerations.SECTION_ENABLED
- )
-
- @staticmethod
- def __get_new_filter_liststore():
- return gtk.ListStore(
- gobject.TYPE_INT, # enumerations.FILTER_ID
- gtk.gdk.Pixbuf, # enumerations.FILTER_ICON
- gobject.TYPE_STRING, # enumerations.FILTER_NAME
- )
-
- @staticmethod
- def __get_new_repositories_liststore():
- return gtk.ListStore(
- gobject.TYPE_INT, # enumerations.REPOSITORY_ID
- gobject.TYPE_STRING, # enumerations.REPOSITORY_DISPLAY_NAME
- gobject.TYPE_STRING, # enumerations.REPOSITORY_PREFIX
- gobject.TYPE_STRING, # enumerations.REPOSITORY_ALIAS
- )
-
- def __init_application_tree_view(self, application_list,
- application_list_filter, application_list_sort,
- application_sort_column):
- ##APPLICATION MAIN TREEVIEW
- if application_list_filter == None:
- application_list_filter = application_list.filter_new()
- if application_list_sort == None:
- application_list_sort = \
- gtk.TreeModelSort(application_list_filter)
- application_list_sort.set_sort_column_id(
- application_sort_column, gtk.SORT_ASCENDING)
- application_list_sort.set_sort_func(
- enumerations.STATUS_ICON_COLUMN,
- self.__column_sort_func,
- enumerations.STATUS_ICON_COLUMN)
- application_list_sort.set_sort_func(
- enumerations.DESCRIPTION_COLUMN,
- self.__column_sort_func,
- enumerations.DESCRIPTION_COLUMN)
- toggle_renderer = gtk.CellRendererToggle()
-
- column = gtk.TreeViewColumn("", toggle_renderer,
- active = enumerations.MARK_COLUMN)
- column.set_cell_data_func(toggle_renderer, self.cell_data_function, self)
- column.set_clickable(True)
- column.connect('clicked', self.__select_column_clicked)
- select_image = self.get_theme_selection_coloumn_image()
- column.set_widget(select_image)
- self.w_application_treeview.append_column(column)
- self.application_select_column = column
-
- name_renderer = gtk.CellRendererText()
- column = gtk.TreeViewColumn(_("Name"), name_renderer,
- text = enumerations.NAME_COLUMN)
- column.set_resizable(True)
- column.set_min_width(150)
- column.set_sort_column_id(enumerations.NAME_COLUMN)
- column.set_sort_indicator(True)
- column.set_cell_data_func(name_renderer, self.cell_data_function, self)
- column.connect_after('clicked',
- self.__application_treeview_column_sorted, None)
- self.w_application_treeview.append_column(column)
- column = self.__create_icon_column(_("Status"), True,
- enumerations.STATUS_ICON_COLUMN, True)
- column.set_sort_column_id(enumerations.STATUS_ICON_COLUMN)
- column.set_sort_indicator(True)
- column.connect_after('clicked',
- self.__application_treeview_column_sorted, None)
- self.w_application_treeview.append_column(column)
- if self.is_all_publishers_search or self.is_all_publishers_installed or \
- self.is_all_publishers or self.in_recent_search:
- repository_renderer = gtk.CellRendererText()
- column = gtk.TreeViewColumn(_('Publisher'),
- repository_renderer,
- markup = enumerations.PUBLISHER_COLUMN)
- column.set_sort_column_id(enumerations.PUBLISHER_COLUMN)
- column.set_resizable(True)
- column.set_sort_indicator(True)
- column.set_cell_data_func(repository_renderer,
- self.cell_data_function, self)
- column.connect_after('clicked',
- self.__application_treeview_column_sorted, None)
- self.w_application_treeview.append_column(column)
- application_list_sort.set_sort_func(
- enumerations.PUBLISHER_COLUMN,
- self.__column_sort_func,
- enumerations.PUBLISHER_COLUMN)
- description_renderer = gtk.CellRendererText()
- column = gtk.TreeViewColumn(_('Summary'),
- description_renderer,
- text = enumerations.DESCRIPTION_COLUMN)
- column.set_sort_column_id(enumerations.DESCRIPTION_COLUMN)
- column.set_resizable(True)
- column.set_sort_indicator(True)
- column.set_cell_data_func(description_renderer,
- self.cell_data_function, self)
- column.connect_after('clicked',
- self.__application_treeview_column_sorted, None)
- self.w_application_treeview.append_column(column)
- #Added selection listener
- self.package_selection = self.w_application_treeview.get_selection()
- self.application_list = application_list
- self.application_list_filter = application_list_filter
- self.application_list_sort = application_list_sort
- toggle_renderer.connect('toggled', self.__active_pane_toggle,
- application_list_sort)
-
- def __init_tree_views(self, application_list, category_list,
- section_list, application_list_filter = None,
- application_list_sort = None,
- application_sort_column = enumerations.NAME_COLUMN):
- '''This function connects treeviews with their models and also applies
- filters'''
- if self.exiting:
- return
- if category_list == None:
- self.w_application_treeview.set_model(None)
- self.__remove_treeview_columns(self.w_application_treeview)
- elif application_list == None:
- self.w_categories_treeview.set_model(None)
- self.__remove_treeview_columns(self.w_categories_treeview)
- else:
- self.__disconnect_models()
- self.__remove_treeview_columns(self.w_application_treeview)
- self.__remove_treeview_columns(self.w_categories_treeview)
- # The logic for set section needs to be here as some sections
- # might be not enabled. In such situation we are setting the set
- # section to "All Categories" one.
- if section_list != None:
- row = section_list[self.set_section]
- if row[enumerations.SECTION_ENABLED] and \
- self.set_section >= 0 and \
- self.set_section < len(section_list):
- if row[enumerations.SECTION_ID] != self.set_section:
- self.set_section = 0
- else:
- self.set_section = 0
-
- if application_list != None:
- self.__init_application_tree_view(application_list,
- application_list_filter, application_list_sort,
- application_sort_column)
-
- if self.first_run:
- # When vadj changes we need to set image descriptions
- # on visible status icons. This catches moving the scroll bars
- # and scrolling up and down using keyboard.
- vadj = self.w_application_treeview.get_vadjustment()
- vadj.connect('value-changed',
- self.__application_treeview_vadjustment_changed, None)
-
- # When the size of the application_treeview changes
- # we need to set image descriptions on visible status icons.
- self.w_application_treeview.connect('size-allocate',
- self.__application_treeview_size_allocate, None)
-
- category_selection = self.w_categories_treeview.get_selection()
- if category_list != None:
- ##CATEGORIES TREEVIEW
- enumerations.CATEGORY_VISIBLE_NAME_r = gtk.CellRendererText()
- column = gtk.TreeViewColumn(_('Name'),
- enumerations.CATEGORY_VISIBLE_NAME_r,
- markup = enumerations.CATEGORY_VISIBLE_NAME)
- enumerations.CATEGORY_VISIBLE_NAME_r.set_property("xalign", 0.0)
- self.w_categories_treeview.append_column(column)
- #Added selection listener
- category_selection.set_mode(gtk.SELECTION_SINGLE)
- self.w_categories_treeview.set_search_column(
- enumerations.CATEGORY_VISIBLE_NAME)
-
- if section_list != None:
- self.section_list = section_list
- if category_list != None:
- self.category_list = category_list
-
- if application_list != None:
- self.w_application_treeview.set_model(
- self.application_list_sort)
- if application_list_filter == None:
- self.application_list_filter.set_visible_func(
- self.__application_filter)
-
- if self.first_run:
- category_selection.connect("changed",
- self.__on_category_selection_changed, None)
- self.w_categories_treeview.connect("row-activated",
- self.__on_category_row_activated, None)
- self.w_categories_treeview.connect("focus-in-event",
- self.__on_category_focus_in, None)
- self.w_categories_treeview.connect("button_press_event",
- self.__on_categoriestreeview_button_press_event, None)
- self.w_categories_treeview.connect("row-collapsed",
- self.__on_categoriestreeview_row_collapsed, None)
- self.w_categories_treeview.connect("row-expanded",
- self.__on_categoriestreeview_row_expanded, None)
- self.package_selection.set_mode(gtk.SELECTION_SINGLE)
- self.package_selection.connect("changed",
- self.__on_package_selection_changed, None)
- if category_list != None and section_list != None:
- self.__add_categories_to_tree(category_list, section_list)
- self.a11y_application_treeview = \
- self.w_application_treeview.get_accessible()
- obj = self.a11y_application_treeview.get_column_header(0)
- if obj != None:
- obj.set_name(_("all selection toggle"))
- self.process_package_list_end()
-
- def __setup_filter_combobox(self):
- render_pixbuf = gtk.CellRendererPixbuf()
- self.w_filter_combobox.pack_start(render_pixbuf, expand = True)
- self.w_filter_combobox.add_attribute(render_pixbuf, "pixbuf",
- enumerations.FILTER_ICON)
- self.w_filter_combobox.set_cell_data_func(render_pixbuf,
- self.filter_cell_data_function,
- (self, enumerations.FILTER_ICON))
-
- cell = gtk.CellRendererText()
- self.w_filter_combobox.pack_start(cell, True)
- self.w_filter_combobox.add_attribute(cell, 'text',
- enumerations.FILTER_NAME)
- self.w_filter_combobox.set_cell_data_func(cell,
- self.filter_cell_data_function,
- (self, enumerations.FILTER_NAME))
- self.w_filter_combobox.set_row_separator_func(
- self.combobox_filter_id_separator)
- self.w_filter_combobox.set_model(self.filter_list)
- self.w_filter_combobox.set_active(self.gconf.initial_show_filter)
-
- def __select_column_clicked(self, data):
- self.set_busy_cursor()
- gobject.idle_add(self.__toggle_select_all,
- self.w_selectall_menuitem.props.sensitive)
-
- def __application_treeview_column_sorted(self, widget, user_data):
- self.__set_visible_status(False)
-
- def __init_repository_tree_view(self):
- cell = gtk.CellRendererText()
- self.w_repository_combobox.pack_start(cell, True)
- self.w_repository_combobox.add_attribute(cell, 'text',
- enumerations.REPOSITORY_DISPLAY_NAME)
- self.w_repository_combobox.set_row_separator_func(
- self.combobox_id_separator)
-
- def __application_treeview_size_allocate(self, widget, allocation, user_data):
- # We ignore any changes in the size during initialization.
- if self.visible_status_id == 0:
- self.visible_status_id = gobject.idle_add(
- self.__set_visible_status)
-
- def __application_treeview_vadjustment_changed(self, widget, user_data):
- self.__set_visible_status()
-
- def __set_accessible_status(self, model, itr):
- status = model.get_value(itr, enumerations.STATUS_COLUMN)
- if status == api.PackageInfo.INSTALLED:
- desc = _("Installed")
- elif status == api.PackageInfo.KNOWN:
- desc = _("Not Installed")
- elif status == api.PackageInfo.UPGRADABLE:
- desc = _("Updates Available")
- else:
- desc = None
- if desc != None:
- obj = self.a11y_application_treeview.ref_at(
- int(model.get_string_from_iter(itr)),
- STATUS_COLUMN_INDEX)
- obj.set_image_description(desc)
-
- def __set_visible_status(self, check_range = True):
- self.visible_status_id = 0
- if self.w_main_view_notebook.get_current_page() != \
- NOTEBOOK_PACKAGE_LIST_PAGE:
- return
- if self.__doing_search():
- return
-
- a11y_enabled = False
- if self.a11y_application_treeview.get_n_accessible_children() != 0:
- a11y_enabled = True
-
- if not a11y_enabled:
- return
-
- visible_range = self.w_application_treeview.get_visible_range()
- if visible_range == None:
- return
- a11y_start = visible_range[0][0]
- a11y_end = visible_range[1][0]
-
- # We use check_range only for accessibility purposes to
- # reduce the amount of processing to be done in that case.
- # Switching Publishers need to use default range
- if self.publisher_changed:
- check_range = False
- self.publisher_changed = False
- if self.in_search_mode:
- check_range = False
-
- if self.application_treeview_range != None:
- if check_range and a11y_enabled:
- old_start = self.application_treeview_range[0][0]
- old_end = self.application_treeview_range[1][0]
- # Old range is the same or smaller than new range
- # so do nothing
- if (a11y_start >= old_start and
- a11y_end <= old_end):
- a11y_end = a11y_start - 1
- else:
- if a11y_start < old_end:
- if a11y_end < old_end:
- if a11y_end >= old_start:
- a11y_end = old_start
- else:
- a11y_start = old_end
- self.application_treeview_range = visible_range
-
- sort_filt_model = \
- self.w_application_treeview.get_model() #gtk.TreeModelSort
-
- if a11y_enabled:
- sf_itr = sort_filt_model.get_iter_from_string(
- str(a11y_start))
- while a11y_start <= a11y_end:
- self.__set_accessible_status(sort_filt_model, sf_itr)
- a11y_start += 1
- sf_itr = sort_filt_model.iter_next(sf_itr)
-
- def __doing_search(self):
- return self.search_start > 0
-
- def __create_icon_column(self, name, expand_pixbuf, enum_value, set_data_func):
- column = gtk.TreeViewColumn()
- column.set_title(name)
- #Commented, since there was funny jumping of the icons
- #column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
- render_pixbuf = gtk.CellRendererPixbuf()
- column.pack_start(render_pixbuf, expand = expand_pixbuf)
- column.add_attribute(render_pixbuf, "pixbuf", enum_value)
- column.set_fixed_width(32)
- if set_data_func:
- column.set_cell_data_func(render_pixbuf,
- self.cell_data_function, self)
- return column
-
- def __disconnect_models(self):
- if self.w_application_treeview:
- self.w_application_treeview.set_model(None)
- if self.w_categories_treeview:
- self.w_categories_treeview.set_model(None)
-
- def __disconnect_repository_model(self):
- self.w_repository_combobox.set_model(None)
-
- @staticmethod
- def __column_sort_func(treemodel, iter1, iter2, column):
- get_val = treemodel.get_value
- get_val = treemodel.get_value
- status1 = get_val(iter1, column)
- status2 = get_val(iter2, column)
- ret = cmp(status1, status2)
- if ret != 0:
- return ret
- name1 = get_val(iter1, enumerations.NAME_COLUMN)
- name2 = get_val(iter2, enumerations.NAME_COLUMN)
- return cmp(name1, name2)
-
- @staticmethod
- def __remove_treeview_columns(treeview):
- columns = treeview.get_columns()
- if columns:
- for column in columns:
- treeview.remove_column(column)
-
- @staticmethod
- def __init_sections(section_list):
- '''This function is for initializing the sections list'''
- enabled = True
- # Only enable the first section. Later other sections are enabled
- # in __add_category_to_section() if the section contains any categories
- # which in turn contain some packages.
- section_list.append([0, _('All Categories'), enabled ])
- enabled = False
- section_list.append([1, _('Meta Packages'), enabled ])
- section_list.append([2, _('Applications'), enabled ])
- section_list.append([3, _('Desktop (GNOME)'), enabled ])
- section_list.append([4, _('Development'), enabled ])
- section_list.append([5, _('Distributions'), enabled ])
- section_list.append([6, _('Drivers'), enabled ])
- section_list.append([7, _('System'), enabled ])
- section_list.append([8, _('Web Services'), enabled ])
-
- def __init_show_filter(self):
- max_length = 0
- for filter_id, pixbuf, label in self.filter_options:
- self.filter_list.append([filter_id, pixbuf, label, ])
- if filter_id == -1:
- continue
- max_length = gui_misc.get_max_text_length(
- max_length, label, self.w_filter_combobox)
- self.__setup_max_filter_length(max_length)
-
- if self.gconf.initial_show_filter >= enumerations.FILTER_ALL and \
- self.gconf.initial_show_filter < len(self.filter_list):
- row = self.filter_list[self.gconf.initial_show_filter]
- if row[enumerations.SECTION_ID] != \
- self.gconf.initial_show_filter:
- self.gconf.initial_show_filter = enumerations.FILTER_ALL
- else:
- self.gconf.initial_show_filter = enumerations.FILTER_ALL
-
- def __on_mainwindow_key_press_event(self, widget, event):
- if self.is_busy_cursor_set():
- if event.type == gtk.gdk.KEY_PRESS:
- keyname = gtk.gdk.keyval_name(event.keyval)
- if keyname == "Escape" and self.api_o.can_be_canceled():
- Thread(target = self.api_o.cancel,
- args = ()).start()
- return True
- else:
- return False
-
- def __on_mainwindow_delete_event(self, widget, event):
- ''' handler for delete event of the main window '''
- if self.__check_if_something_was_changed() == True:
- # XXX Change this to not quit and show dialog
- # XXX if some changes were applied:
- self.__main_application_quit()
- return True
- else:
- self.__main_application_quit()
-
- def __handle_resize(self, widget):
- if self.last_resize == widget.get_size():
- return
- last_resize = self.last_resize
- self.last_resize = widget.get_size()
-
- pub_rect = self.w_publisher_combobox_hbox.get_allocation()
- view_rect = self.w_view_combobox_hbox.get_allocation()
- min_width = pub_rect[2] + view_rect[2] + PUBLISHER_VIEW_MIN_PADDING
- main_win_width = self.w_main_window.get_size()[0]
- if main_win_width < min_width:
- self.w_main_window.set_size_request(min_width, -1)
- if self.w_main_view_notebook.get_current_page() == \
- NOTEBOOK_START_PAGE and not self.first_run:
- self.startpage.handle_resize()
- return
- elif last_resize == -1 and min_width < MIN_APP_WIDTH:
- self.w_main_window.set_size_request(MIN_APP_WIDTH, MIN_APP_HEIGHT)
-
- if self.w_main_view_notebook.get_current_page() == \
- NOTEBOOK_START_PAGE and not self.first_run:
- self.startpage.handle_resize()
-
- def __on_mainwindow_check_resize(self, widget):
- if not widget or not self.gdk_window:
- return
- if self.resize_id != 0:
- gobject.source_remove(self.resize_id)
- self.resize_id = 0
-
- self.resize_id = \
- gobject.timeout_add(RESIZE_DELAY,
- self.__handle_resize, widget)
-
- status_height = self.w_statusbar_hbox.get_allocation().height
- self.gdk_window.move_resize(0, 0, widget.get_size()[0],
- widget.get_size()[1]-status_height)
-
- def __on_file_quit_activate(self, widget):
- ''' handler for quit menu event '''
- self.__on_mainwindow_delete_event(None, None)
-
- def __on_file_manage_publishers(self, widget):
- ''' handler for manage publishers menu event '''
- repository.Repository(self, self.image_directory,
- action=enumerations.MANAGE_PUBLISHERS,
- main_window = self.w_main_window, gconf = self.gconf)
-
- def __on_file_add_publisher(self, widget):
- ''' handler for add publisher menu event '''
- repository.Repository(self, self.image_directory,
- action=enumerations.ADD_PUBLISHER,
- main_window = self.w_main_window, gconf = self.gconf)
-
- def __on_file_be_activate(self, widget):
- ''' handler for be menu event '''
- beadm.Beadmin(self)
-
- def __on_searchentry_changed(self, widget):
- ret = self.entrystyle.on_entry_changed(widget)
- self.w_clear_search_menuitem.set_sensitive(ret)
- self.__enable_disable_entry_selection(widget)
-
- def __update_statusbar_for_search(self):
- if self.is_all_publishers_search or self.is_all_publishers:
- self.update_statusbar_message(_("Search all publishers"))
- else:
- self.update_statusbar_message(_("Search current publisher"))
-
- def __remove_statusbar_message(self):
- if self.statusbar_message_id > 0:
- try:
- self.w_main_statusbar.remove_message(0,
- self.statusbar_message_id)
- except AttributeError:
- self.w_main_statusbar.remove(0,
- self.statusbar_message_id)
- self.statusbar_message_id = 0
-
- def update_statusbar_message(self, message):
- if self.exiting:
- return
- self.__remove_statusbar_message()
- self.statusbar_message_id = self.w_main_statusbar.push(0, message)
- if self.w_main_statusbar_label:
- self.w_main_statusbar_label.set_markup(message)
-
- def __setup_before_all_publishers_search_mode(self):
- self.is_all_publishers_installed = False
- self.is_all_publishers = False
- self.is_all_publishers_search = True
- if not self.first_run:
- self.w_logalert_frame.hide()
- if not self.w_searchentry.is_focus():
- self.__set_searchentry_to_prompt()
-
- self.__save_setup_before_search()
- first_run = self.first_run
- self.first_run = False
- self.__clear_before_search(False)
- show_search_all_page = not first_run or (first_run
- and not self.gconf.show_startpage) or (first_run
- and self.gconf.start_insearch)
- if show_search_all_page:
- gobject.idle_add(self.pm_setup_search_all_page)
- elif self.gconf.show_startpage:
- gobject.idle_add(self.w_main_view_notebook.set_current_page,
- NOTEBOOK_START_PAGE)
- self.__update_statusbar_for_search()
-
- def __set_searchentry_to_prompt(self):
- if not self.first_run:
- self.entrystyle.set_entry_to_prompt()
-
- def pm_setup_search_all_page(self):
- publisher_list = []
- model = self.w_repository_combobox.get_model()
- for pub in model:
- prefix = pub[enumerations.REPOSITORY_PREFIX]
- if (prefix and prefix not in self.publisher_options.values()):
- pub_alias = pub[enumerations.REPOSITORY_ALIAS]
- publisher_list.append((prefix, pub_alias))
- self.startpage.setup_search_all_page(publisher_list,
- self.publisher_options[PUBLISHER_ALL])
- self.__setup_notebook_page_view()
-
- def __setup_search_installed_page(self, text):
- self.startpage.setup_search_installed_page(text)
- self.__setup_notebook_page_view()
- self.__set_focus_on_searchentry()
-
- def __setup_recent_search_page(self):
- self.startpage.setup_recent_search_page(self.recent_searches_list)
- self.__setup_notebook_page_view()
-
- def __setup_zero_filtered_results_page(self):
- active_filter = self.w_filter_combobox.get_active()
- filter_desc = self.__get_filter_combobox_description(active_filter)
- self.startpage.setup_zero_filtered_results_page(self.length_visible_list,
- filter_desc)
- self.__setup_notebook_page_view()
-
- def __setup_search_zero_filtered_results_page(self, text, num):
- active_filter = self.w_filter_combobox.get_active()
- filter_desc = self.__get_filter_combobox_description(active_filter)
- self.startpage.setup_search_zero_filtered_results_page(text,
- num, filter_desc)
- self.__setup_notebook_page_view()
- self.__set_focus_on_searchentry()
-
- def __get_filter_combobox_description(self, index):
- description = None
- model = self.w_filter_combobox.get_model()
- for entry in model:
- if entry[enumerations.FILTER_ID] == index:
- description = entry[enumerations.FILTER_NAME]
- break
- return description
-
- def __setup_search_zero_results_page(self, pub, text, search_all):
- name = self.get_publisher_name_from_prefix(pub)
- self.startpage.setup_search_zero_results_page(name, text,
- search_all)
- self.__setup_notebook_page_view()
- self.__set_focus_on_searchentry()
-
- def __set_focus_on_searchentry(self):
- self.w_searchentry.grab_focus()
- if self.w_searchentry.get_text() > 0:
- start, end = self.w_searchentry.get_selection_bounds()
- self.w_searchentry.select_region(end, end)
- self.pylintstub = start
-
- def __setup_search_wildcard_page(self):
- self.startpage.setup_search_wildcard_page()
- self.__setup_notebook_page_view()
- self.__set_focus_on_searchentry()
-
- def __clear_before_search(self, show_list=True, in_setup=True, unselect_cat=True):
- self.in_setup = in_setup
- application_list = self.__get_new_application_liststore()
- self.__set_empty_details_panel()
- self.__set_main_view_package_list(show_list)
- self.__init_tree_views(application_list, None, None)
- if unselect_cat:
- self.__unselect_category()
-
- def __restore_setup_for_browse(self):
- self.in_search_mode = False
- self.in_recent_search = False
- self.is_all_publishers_search = False
- self.w_logalert_frame.hide()
- if self.last_visible_publisher == \
- self.publisher_options[PUBLISHER_INSTALLED]:
- self.is_all_publishers_installed = True
- else:
- self.is_all_publishers_installed = False
- if self.last_visible_publisher == \
- self.publisher_options[PUBLISHER_ALL]:
- self.is_all_publishers = True
- else:
- self.is_all_publishers = False
- self.set_busy_cursor()
- if (self.w_repository_combobox.get_active() !=
- self.saved_repository_combobox_active):
- self.w_repository_combobox.set_active(
- self.saved_repository_combobox_active)
- self.set_section = self.saved_section_active
- # Reset MARK_COLUMN
- for pkg in self.saved_application_list:
- pub = pkg[enumerations.PUBLISHER_PREFIX_COLUMN]
- stem = pkg[enumerations.STEM_COLUMN]
- marked = False
- pkgs = None
- if self.selected_pkgs != None:
- pkgs = self.selected_pkgs.get(pub)
- if pkgs != None:
- if stem in pkgs:
- marked = True
- # When switching after Manage Publisher dialog
- # this assignment can cause bogus refilter
- if pkg[enumerations.MARK_COLUMN] != marked:
- pkg[enumerations.MARK_COLUMN] = marked
- if self.saved_category_list == self.category_list:
- self.__restore_category_state()
- self.__init_tree_views(self.saved_application_list,
- None, None,
- self.saved_application_list_filter,
- self.saved_application_list_sort)
- else:
- self.__init_tree_views(self.saved_application_list,
- self.saved_category_list, self.saved_section_list,
- self.saved_application_list_filter,
- self.saved_application_list_sort)
-
- self.__set_main_view_package_list()
-
- def __save_application_list(self, app_list):
- self.saved_application_list = app_list
-
- def __save_setup_before_search(self, single_search=False):
- #Do not save search data models
- if self.in_search_mode:
- return
- self.__save_application_list(self.application_list)
- self.saved_application_list_sort = \
- self.application_list_sort
- self.saved_application_list_filter = \
- self.application_list_filter
- self.saved_category_list = self.category_list
- self.saved_section_list = self.section_list
-
- pub_index = self.w_repository_combobox.get_active()
- if pub_index != self.repo_combobox_all_pubs_search_index and \
- pub_index != self.repo_combobox_add_index:
- self.saved_repository_combobox_active = pub_index
-
- def __do_search(self, widget=None, ev=None):
- self.in_recent_search = False
- self.__reset_search_start()
- txt = self.entrystyle.get_text()
- if txt == None:
- return
- self.previous_search_text = txt
- if self.is_all_publishers_installed:
- gobject.idle_add(self.__setup_search_installed_page, txt)
- return
- contains_asterix = txt.count("*") > 0
- contains_asterix_only = False
- is_search_all = self.is_all_publishers_search or \
- self.__get_selected_publisher() == \
- self.publisher_options[PUBLISHER_ALL]
- if contains_asterix:
- contains_asterix_only = len(txt.replace("*", " ").strip()) == 0
- if contains_asterix_only:
- self.w_searchentry.set_text("*")
- self.__set_focus_on_searchentry()
- if is_search_all:
- gobject.idle_add(self.__setup_search_wildcard_page)
- else:
- if self.in_search_mode:
- self.__unset_search(True)
- if self.w_categories_treeview.get_model() != None:
- self.w_categories_treeview.set_cursor(0)
- return
- if not self.is_all_publishers_search:
- self.__save_setup_before_search(single_search=True)
- self.__clear_before_search()
- self.__set_focus_on_searchentry()
- self.set_busy_cursor()
- self.in_search_mode = True
-
- self.w_logalert_frame.hide()
- gobject.idle_add(self.__set_main_view_package_list)
- Thread(target = self.__do_api_search,
- args = (is_search_all, )).start()
-
- def __get_selection_and_category_path(self):
- selection = self.w_categories_treeview.get_selection()
- if not selection:
- return None, (0,)
- model, itr = selection.get_selected()
- if not model or not itr:
- return None, (0,)
- return selection, model.get_path(itr)
-
- def __unselect_category(self):
- selection, path = self.__get_selection_and_category_path()
- if selection:
- self.__save_active_category(path)
- selection.unselect_all()
-
- def __process_after_cancel(self):
- if self.is_all_publishers_search:
- self.__setup_before_all_publishers_search_mode()
- else:
- self.__unset_search(True)
-
- def __process_after_search_failure(self):
- self.__reset_search_start()
- self.search_time_sec = 0
- self.application_list = []
- gobject.idle_add(self.update_statusbar)
- gobject.idle_add(self.unset_busy_cursor)
- self.in_setup = False
-
- def __handle_inc_search_results(self, sort_col):
- self.search_results_id = 0
- if debug:
- print "handle_inc_search_results: ", \
- time.time() - self.search_start, len(self.search_results)
- application_list = self.__get_min_list_from_search(self.search_results)
- self.in_setup = True
- self.__init_tree_views(application_list, None, None, None, None, sort_col)
-
- def __do_api_search(self, search_all = True):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__do_api_search_without_lock(search_all)
- gui_misc.release_lock(self.api_lock)
-
- def __do_api_search_without_lock(self, search_all = True):
- self.__set_search_start()
- gobject.idle_add(self.update_statusbar)
- self.search_time_sec = 0
- self.search_results = []
- self.__clear_inc_search_results_task()
- text = self.w_searchentry.get_text()
- pub_prefix = None
- # Here we call the search API to get the results
- searches = []
- servers = []
- pargs = []
- search_str = SEARCH_STR_FORMAT % text
- pargs.append(search_str)
- if search_all:
- self.publisher_being_searched = _("All Publishers")
- servers = None
- else:
- pub_prefix = self.__get_selected_publisher()
- try:
- if pub_prefix != None:
- pub = self.api_o.get_publisher(prefix=pub_prefix)
- else:
- pub = self.api_o.get_highest_ranked_publisher()
- except api_errors.ApiException, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- gobject.idle_add(self.unset_busy_cursor)
- return
- origin_uri = gui_misc.get_origin_uri(pub.repository)
- servers.append({"origin": origin_uri})
- self.publisher_being_searched = \
- self.get_publisher_display_name_from_prefix(pub.prefix)
- if debug:
- print "Search: pargs %s servers: %s" % (pargs, servers)
-
- #TBD If we ever search just Installed pkgs should allow for a local search
- case_sensitive = False
- return_actions = True
-
- last_name = ""
- # Sorting results by Name gives best overall appearance and flow
- sort_col = enumerations.NAME_COLUMN
- # pylint: disable=C0321
- try:
- searches.append(self.api_o.remote_search(
- [api.Query(" ".join(pargs), case_sensitive, return_actions)],
- servers=servers))
- if debug:
- print "Search Args: %s : cs: %s : retact: %s" % \
- ("".join(pargs), case_sensitive, return_actions)
- for query_num, pub, (v, return_type, tmp) in \
- itertools.chain(*searches):
- if v < 1 or return_type != api.Query.RETURN_PACKAGES:
- self.__process_after_search_failure()
- return
-
- active_pub = None
- if pub is not None \
- and "prefix" in pub:
- active_pub = pub["prefix"]
- name = fmri.PkgFmri(str(tmp)).get_name()
- if last_name != name:
- if debug:
- print "Result Name: %s (%s)" \
- % (name, active_pub)
- a_res = name, active_pub
- self.search_results.append(a_res)
- if self.search_results_id == 0:
- self.search_results_id = (
- gobject.timeout_add(
- INC_RESULTS_DELAY,
- self.__handle_inc_search_results,
- sort_col))
- last_name = name
- self.pylintstub = query_num
- except api_errors.ProblematicSearchServers, ex:
- self.__process_api_search_error(ex)
- gobject.idle_add(self.__handle_api_search_error)
- if len(self.search_results) == 0:
- if search_all:
- self.__process_after_search_with_zero_results(
- _("All Publishers"), text,
- search_all)
- else:
- self.__process_after_search_with_zero_results(
- pub_prefix, text, search_all)
- return
- except api_errors.CanceledException:
- self.__reset_search_start()
- gobject.idle_add(self.unset_busy_cursor)
- gobject.idle_add(self.__process_after_cancel)
- return
- except api_errors.ImageLockedError, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- self.__process_after_search_failure()
- return
- except Exception, aex:
- err = str(aex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- self.__process_after_search_failure()
- return
- finally:
- self.__clear_inc_search_results_task()
- if debug:
- print "Number of search results:", len(self.search_results)
- if len(self.search_results) == 0:
- if debug:
- print "No search results"
- if search_all:
- self.__process_after_search_with_zero_results(
- _("All Publishers"), text, search_all)
- else:
- self.__process_after_search_with_zero_results(
- pub_prefix, text, search_all)
- return
- #Now fetch full result set with Status
- if self.exiting:
- return
- self.in_setup = True
- if debug_perf:
- print "Time for search:", time.time() - self.search_start
- application_list = self.__get_full_list_from_search(self.search_results)
- gobject.idle_add(self.__add_recent_search, text, pub_prefix,
- application_list, search_all)
- if self.search_start > 0:
- self.search_time_sec = int(time.time() - self.search_start)
- if debug:
- print "Search time: %d (sec)" % self.search_time_sec
- self.__reset_search_start()
- gobject.idle_add(self.__init_tree_views, application_list, None, None, \
- None, None, sort_col)
- if self.w_filter_combobox.get_active() == enumerations.FILTER_ALL:
- return
-
- gobject.idle_add(self.__check_zero_results_afterfilter, text,
- len(application_list))
-
- def __clear_inc_search_results_task(self):
- if self.search_results_id != 0:
- gobject.source_remove(self.search_results_id)
- self.search_results_id = 0
-
- def __check_zero_results_afterfilter(self, text, num):
- if self.length_visible_list != 0:
- return
- self.__setup_search_zero_filtered_results_page(text, num)
- self.update_statusbar()
-
- def __set_search_start(self):
- self.search_start = time.time()
-
- def __reset_search_start(self):
- self.search_start = 0
-
- def __process_after_search_with_zero_results(self, pub, text,
- search_all):
- if self.search_start > 0:
- self.search_time_sec = \
- int(time.time() - self.search_start)
- self.__reset_search_start()
- gobject.idle_add(self.__setup_search_zero_results_page, pub, text,
- search_all)
- self.in_setup = True
- application_list = self.__get_new_application_liststore()
- gobject.idle_add(self.__set_empty_details_panel)
- gobject.idle_add(self.__init_tree_views, application_list, None, None)
-
- def get_publisher_display_name_from_prefix(self, prefix):
- if self.pubs_display_name.has_key(prefix):
- return self.pubs_display_name[prefix]
- else:
- return prefix
-
- def get_publisher_name_from_prefix(self, prefix):
- if self.pubs_info.has_key(prefix):
- item = self.pubs_info[prefix]
- else:
- return prefix
- alias = item[1]
- if alias != None and len(alias) > 0:
- return alias
- else:
- return prefix
-
- def __get_min_list_from_search(self, search_result):
- application_list = self.__get_new_application_liststore()
- for name, pub in search_result:
- pub_name = self.get_publisher_name_from_prefix(pub)
- #Add to application_list
- application_list.append(
- [False, None, name, '...', api.PackageInfo.KNOWN,
- gui_misc.get_pkg_stem(name, pub), None, True, None,
- pub_name, pub, False])
- return application_list
-
- def __get_full_list_from_search(self, search_result):
- application_list = self.__get_new_application_liststore()
- self.__add_pkgs_to_list_from_search(search_result,
- application_list)
- return application_list
-
- def __add_pkgs_to_list_from_search(self, search_result,
- application_list):
- local_results = self.__get_info_for_search_results(search_result)
- remote_results = self.__get_info_for_search_results(search_result,
- local_results)
- self.__add_pkgs_to_lists_from_info(local_results,
- remote_results, application_list)
-
- def __get_info_for_search_results(self, search_result, local_results = None):
- pargs = []
- results = []
- local_info = local_results == None
- for name, pub in search_result:
- found = False
- if local_results:
- for result in local_results:
- if (name == result.pkg_stem and
- pub == result.publisher):
- found = True
- break
- if not found:
- pargs.append(gui_misc.get_pkg_stem(name, pub))
- else:
- pargs.append(gui_misc.get_pkg_stem(name, pub))
-
- try:
- try:
- if len(pargs) > 0:
- res = self.api_o.info(pargs,
- local_info, frozenset(
- [api.PackageInfo.IDENTITY,
- api.PackageInfo.STATE,
- api.PackageInfo.SUMMARY]))
- results = res.get(0)
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.InvalidDepotResponseException, idex:
- err = str(idex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.ImageLockedError, ex:
- err = str(ex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except Exception, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err)
- finally:
- return results
-
- def __application_refilter(self):
- ''' Disconnecting the model from the treeview improves
- performance when assistive technologies are enabled'''
- self.application_refilter_id = 0
- if self.in_setup:
- return
- model = self.w_application_treeview.get_model()
- self.w_application_treeview.set_model(None)
- app_id, order = self.application_list_sort.get_sort_column_id()
- self.application_list_sort.reset_default_sort_func()
- self.application_list_filter.refilter()
- if app_id != None:
- self.application_list_sort.set_sort_column_id(app_id, order)
- if model != None:
- self.w_application_treeview.set_model(model)
- self.application_treeview_initialized = True
- self.application_treeview_range = None
- if self.visible_status_id == 0:
- self.visible_status_id = gobject.idle_add(
- self.__set_visible_status)
- len_filtered_list = len(self.application_list_filter)
- if len_filtered_list > 0 and \
- self.length_visible_list != len_filtered_list:
- self.update_statusbar()
- self.__set_empty_details_panel()
- self.__enable_disable_selection_menus()
- self.__enable_disable_install_remove()
- self.__enable_disable_select_all()
- self.__enable_disable_deselect()
- if not self.in_search_mode and self.length_visible_list > 0 and \
- len_filtered_list == 0 and \
- self.w_filter_combobox.get_active() != \
- (enumerations.FILTER_SELECTED):
- self.__setup_zero_filtered_results_page()
- self.update_statusbar()
- return False
-
- def __on_edit_paste(self, widget):
- self.w_searchentry.paste_clipboard()
-
- def __on_delete(self, widget):
- bounds = self.w_searchentry.get_selection_bounds()
- self.w_searchentry.delete_text(bounds[0], bounds[1])
- return
-
- def __on_copy(self, widget):
- focus_widget = self.w_main_window.get_focus()
- if focus_widget == self.w_searchentry:
- self.w_searchentry.copy_clipboard()
- self.w_paste_menuitem.set_sensitive(True)
- elif gui_misc.is_a_textview(focus_widget):
- focus_widget.get_buffer().copy_clipboard(
- self.w_main_clipboard)
-
- def __on_cut(self, widget):
- self.w_searchentry.cut_clipboard()
- self.w_paste_menuitem.set_sensitive(True)
-
- def __on_goto_list_clicked(self, widget):
- if self.w_main_view_notebook.get_current_page() == NOTEBOOK_START_PAGE:
- if self.startpage.view:
- self.startpage.view.grab_focus()
- else:
- self.__set_main_view_package_list()
- self.w_application_treeview.grab_focus()
-
- def __on_edit_search_clicked(self, widget):
- self.w_searchentry.grab_focus()
-
- def __on_clear_search(self, widget, icon_pos=0, event=None):
- self.w_searchentry.set_text("")
- self.__clear_search_results()
-
- def __clear_search_results(self):
- # Only clear out search results
- if self.in_search_mode or self.is_all_publishers_search:
- self.__clear_before_search()
- self.update_statusbar_message(_("Search cleared"))
- if self.is_all_publishers_search:
- if self.w_main_view_notebook.get_current_page() \
- != NOTEBOOK_START_PAGE:
- gobject.idle_add(self.pm_setup_search_all_page)
- else:
- self.__unset_search(self.in_search_mode)
- return
-
- def __on_progress_cancel_clicked(self, widget):
- Thread(target = self.api_o.cancel, args = ()).start()
-
- def __on_startpage(self, widget):
- self.startpage.load_startpage()
- self.w_main_view_notebook.set_current_page(NOTEBOOK_START_PAGE)
-
- def __reset_info_tabs(self, pagenum = None, immediate = False):
- self.info_pkgstem = None
- self.dependencies_pkgstem = None
- self.license_pkgstem = None
- self.versions_pkgstem = None
- self.__process_package_selection(pagenum, immediate)
-
- def __process_package_selection(self, pagenum = None, immediate = False):
- if pagenum == None:
- pagenum = self.w_info_notebook.get_current_page()
- model, itr = self.package_selection.get_selected()
- if itr:
- self.selected_pkgstem = \
- model.get_value(itr, enumerations.STEM_COLUMN)
- self.selected_pkg_name = \
- model.get_value(itr, enumerations.ACTUAL_NAME_COLUMN)
- self.selected_pkg_pub = \
- model.get_value(itr, enumerations.PUBLISHER_PREFIX_COLUMN)
- self.__do_notebook_change(pagenum, model, model.get_path(itr),
- immediate)
- self.w_version_info_menuitem.set_sensitive(True)
- else:
- self.selected_model = None
- self.selected_path = None
- self.selected_pkgstem = None
- self.selected_pkg_name = None
- self.selected_pkg_pub = None
- self.w_version_info_menuitem.set_sensitive(False)
- self.__do_notebook_change(pagenum, None, None, immediate)
-
- def __on_package_selection_changed(self, selection, widget):
- '''This function is for handling package selection changes'''
- if self.in_setup:
- return
- self.__process_package_selection()
-
- def __on_notebook_change(self, widget, event, pagenum):
- self.__process_package_selection(pagenum, True)
-
- def __do_notebook_change(self, pagenum, model = None, path = None,
- immediate = False):
- self.detailspanel.clear_details(self.info_pkgstem,
- self.dependencies_pkgstem, self.license_pkgstem,
- self.versions_pkgstem, self.selected_pkgstem)
- if (pagenum == INFO_NOTEBOOK_DEPENDENCIES_PAGE):
- if self.selected_pkgstem == self.dependencies_pkgstem:
- return
- self.detailspanel.set_fetching_dependencies()
- if self.show_dependencies_id != 0:
- gobject.source_remove(self.show_dependencies_id)
- self.show_dependencies_id = 0
- if immediate:
- source_id = gobject.idle_add(self.__show_dependencies)
- else:
- source_id = gobject.timeout_add(SHOW_DEPENDENCIES_DELAY,
- self.__show_dependencies)
- self.last_show_dependencies_id = self.show_dependencies_id = \
- source_id
- elif (pagenum == INFO_NOTEBOOK_LICENSE_PAGE):
- if self.selected_pkgstem == self.license_pkgstem:
- return
- self.detailspanel.set_fetching_license()
- if self.show_licenses_id != 0:
- gobject.source_remove(self.show_licenses_id)
- self.show_licenses_id = 0
- if immediate:
- source_id = gobject.idle_add(self.__show_licenses)
- else:
- source_id = gobject.timeout_add(SHOW_LICENSE_DELAY,
- self.__show_licenses)
- self.last_show_licenses_id = self.show_licenses_id = source_id
- elif (pagenum == INFO_NOTEBOOK_VERSIONS_PAGE):
- if self.selected_pkgstem == self.versions_pkgstem:
- return
- gobject.idle_add(self.detailspanel.set_fetching_versions)
- if self.show_versions_id != 0:
- gobject.source_remove(self.show_versions_id)
- self.show_versions_id = 0
- if immediate:
- source_id = gobject.idle_add(self.__show_versions)
- else:
- source_id = gobject.timeout_add(SHOW_VERSIONS_DELAY,
- self.__show_versions)
- self.last_show_versions_id = self.show_versions_id = source_id
- else:
- if self.selected_pkgstem == self.info_pkgstem:
- return
- self.detailspanel.set_fetching_info()
- if self.show_info_id != 0:
- gobject.source_remove(self.show_info_id)
- self.show_info_id = 0
- if immediate:
- source_id = gobject.idle_add(self.__show_info,
- model, path)
- else:
- source_id = gobject.timeout_add(SHOW_INFO_DELAY,
- self.__show_info, model, path)
- self.last_show_info_id = self.show_info_id = source_id
-
- def __toggle_select_all(self, select_all=True):
- focus_widget = self.w_main_window.get_focus()
- if gui_misc.is_a_textview(focus_widget):
- focus_widget.emit('select-all', select_all)
- self.w_selectall_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(True)
- self.unset_busy_cursor()
- return
- elif focus_widget == self.w_searchentry:
- if select_all:
- focus_widget.select_region(0, -1)
- else:
- focus_widget.select_region(0, 0)
- self.w_selectall_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(True)
- self.unset_busy_cursor()
- return
-
- sort_filt_model = \
- self.w_application_treeview.get_model() #gtk.TreeModelSort
- filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
- model = filt_model.get_model() #gtk.ListStore
- iter_next = sort_filt_model.get_iter_first()
- list_of_paths = []
- while iter_next != None:
- sorted_path = sort_filt_model.get_path(iter_next)
- filtered_path = \
- sort_filt_model.convert_path_to_child_path(sorted_path)
- path = filt_model.convert_path_to_child_path(filtered_path)
- if select_all:
- list_of_paths.append(path)
- else:
- filtered_iter = \
- sort_filt_model.convert_iter_to_child_iter(None,
- iter_next)
- app_iter = filt_model.convert_iter_to_child_iter(
- filtered_iter)
- if model.get_value(app_iter, enumerations.MARK_COLUMN):
- list_of_paths.append(path)
- iter_next = sort_filt_model.iter_next(iter_next)
- for path in list_of_paths:
- itr = model.get_iter(path)
- mark_value = model.get_value(itr, enumerations.MARK_COLUMN)
- if select_all and not mark_value:
- model.set_value(itr, enumerations.MARK_COLUMN, True)
- pkg_stem = model.get_value(itr,
- enumerations.STEM_COLUMN)
- pkg_status = model.get_value(itr,
- enumerations.STATUS_COLUMN)
- pkg_publisher = model.get_value(itr,
- enumerations.PUBLISHER_PREFIX_COLUMN)
- pkg_description = model.get_value(itr,
- enumerations.DESCRIPTION_COLUMN)
- pkg_name = model.get_value(itr,
- enumerations.NAME_COLUMN)
- self.__add_pkg_stem_to_list(pkg_stem, pkg_name,
- pkg_status, pkg_publisher, pkg_description)
- elif not select_all and mark_value:
- model.set_value(itr, enumerations.MARK_COLUMN, False)
- pkg_stem = model.get_value(itr,
- enumerations.STEM_COLUMN)
- self.__remove_pkg_stem_from_list(pkg_stem)
-
- self.w_selectall_menuitem.set_sensitive(not select_all)
- self.w_deselect_menuitem.set_sensitive(select_all)
- self.__enable_disable_selection_menus()
- self.update_statusbar()
- self.__enable_disable_install_remove()
- self.unset_busy_cursor()
-
- def __on_select_all(self, widget):
- self.set_busy_cursor()
- gobject.idle_add(self.__toggle_select_all, True)
- return
-
- def __on_select_updates(self, widget):
- sort_filt_model = \
- self.w_application_treeview.get_model() #gtk.TreeModelSort
- filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
- model = filt_model.get_model() #gtk.ListStore
- iter_next = sort_filt_model.get_iter_first()
- list_of_paths = []
- while iter_next != None:
- sorted_path = sort_filt_model.get_path(iter_next)
- filtered_iter = sort_filt_model.convert_iter_to_child_iter(None, \
- iter_next)
- app_iter = filt_model.convert_iter_to_child_iter(filtered_iter)
-
- filtered_path = \
- sort_filt_model.convert_path_to_child_path(sorted_path)
- path = filt_model.convert_path_to_child_path(filtered_path)
- if model.get_value(app_iter, \
- enumerations.STATUS_COLUMN) == api.PackageInfo.UPGRADABLE:
- list_of_paths.append(path)
- iter_next = sort_filt_model.iter_next(iter_next)
- for path in list_of_paths:
- itr = model.get_iter(path)
- model.set_value(itr, enumerations.MARK_COLUMN, True)
- pkg_stem = model.get_value(itr, enumerations.STEM_COLUMN)
- pkg_status = model.get_value(itr, enumerations.STATUS_COLUMN)
- pkg_publisher = model.get_value(itr,
- enumerations.PUBLISHER_PREFIX_COLUMN)
- pkg_description = model.get_value(itr,
- enumerations.DESCRIPTION_COLUMN)
- pkg_name = model.get_value(itr,
- enumerations.NAME_COLUMN)
- self.__add_pkg_stem_to_list(pkg_stem, pkg_name, pkg_status,
- pkg_publisher, pkg_description)
- self.__enable_disable_selection_menus()
- self.update_statusbar()
- self.__enable_disable_install_remove()
-
- def __on_deselect(self, widget):
- self.set_busy_cursor()
- gobject.idle_add(self.__toggle_select_all, False)
- return
-
- def __on_preferences(self, widget):
- self.preferences.activate()
-
- def __on_searchentry_focus_in(self, widget, event):
- self.__set_search_text_mode(enumerations.SEARCH_STYLE_NORMAL)
- if self.w_main_clipboard.wait_is_text_available():
- self.w_paste_menuitem.set_sensitive(True)
- char_count = widget.get_text_length()
- if char_count > 0:
- self.w_selectall_menuitem.set_sensitive(True)
- else:
- self.w_selectall_menuitem.set_sensitive(False)
- bounds = widget.get_selection_bounds()
- if bounds:
- offset1 = bounds[0]
- offset2 = bounds[1]
- if abs(offset2 - offset1) == char_count:
- self.w_selectall_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(True)
- self.w_copy_menuitem.set_sensitive(True)
- else:
- self.w_deselect_menuitem.set_sensitive(False)
-
- def __on_searchentry_focus_out(self, widget, event):
- if self.w_searchentry.get_text_length() == 0:
- self.__set_search_text_mode(enumerations.SEARCH_STYLE_PROMPT)
- self.w_paste_menuitem.set_sensitive(False)
- self.__enable_disable_select_all()
- self.__enable_disable_deselect()
- self.w_cut_menuitem.set_sensitive(False)
- self.w_copy_menuitem.set_sensitive(False)
- self.w_delete_menuitem.set_sensitive(False)
- return False
-
- def __on_searchentry_selection(self, widget, pspec):
- self.__enable_disable_entry_selection(widget)
-
- def __enable_disable_entry_selection(self, widget):
- char_count = widget.get_text_length()
- bounds = widget.get_selection_bounds()
- if bounds:
- #enable selection functions
- self.w_cut_menuitem.set_sensitive(True)
- self.w_copy_menuitem.set_sensitive(True)
- self.w_delete_menuitem.set_sensitive(True)
- if char_count == abs(bounds[1] - bounds[0]):
- self.w_selectall_menuitem.set_sensitive(False)
- else:
- self.w_selectall_menuitem.set_sensitive(True)
- self.w_deselect_menuitem.set_sensitive(True)
- else:
- self.w_cut_menuitem.set_sensitive(False)
- self.w_copy_menuitem.set_sensitive(False)
- self.w_delete_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(False)
- if char_count == 0:
- self.w_selectall_menuitem.set_sensitive(False)
- else:
- self.w_selectall_menuitem.set_sensitive(True)
-
- def __refilter_on_idle(self):
- if self.application_refilter_id != 0:
- gobject.source_remove(self.application_refilter_id)
- self.application_refilter_id = 0
- if self.application_refilter_id == 0:
- self.application_refilter_id = gobject.idle_add(
- self.__application_refilter)
-
- def __on_category_focus_in(self, widget, event, user):
- self.__on_category_row_activated(None, None, None, user)
-
- def __on_category_row_activated(self, view, path, col, user):
- '''This function is for handling category double click activations'''
- # Activated sub node in Recent Searches category
- if self.in_recent_search:
- return
- # User activated Recent Searches Top Level category
- model = self.w_categories_treeview.get_model()
- if model != None and self.recent_searches_cat_iter:
- rs_path = model.get_path(self.recent_searches_cat_iter)
- selection, curr_path = self.__get_selection_and_category_path()
- self.pylintstub = selection
- if curr_path == rs_path:
- self.__setup_recent_search_page()
- return
- if self.category_list == None:
- self.__set_main_view_package_list()
- return
- if self.w_filter_combobox.get_model():
- self.w_filter_combobox.set_active(
- self.saved_filter_combobox_active)
- if self.in_search_mode or self.is_all_publishers_search:
- self.__unset_search(True)
- return
- self.__set_main_view_package_list()
- self.set_busy_cursor()
- self.__refilter_on_idle()
-
- def __set_main_view_package_list(self, show_list=True):
- # Only switch from Start Page View to List view if we are not in startup
- if self.in_startpage_startup:
- return
- if show_list:
- self.w_main_view_notebook.set_current_page(
- NOTEBOOK_PACKAGE_LIST_PAGE)
- else:
- self.w_main_view_notebook.set_current_page(
- NOTEBOOK_START_PAGE)
-
- def __on_categoriestreeview_row_collapsed(self, treeview, itr, path, data):
- self.w_categories_treeview.set_cursor(path)
- self.__save_expanded_path(path, False)
- self.__save_active_category(path)
-
- def __on_categoriestreeview_row_expanded(self, treeview, itr, path, data):
- if self.in_setup and not self.first_run:
- return
- self.w_categories_treeview.set_cursor(path)
- self.__save_expanded_path(path, True)
- self.__save_active_category(path)
-
- def __on_categoriestreeview_button_press_event(self, treeview, event, data):
- if event.type != gtk.gdk.BUTTON_PRESS:
- return 1
- x = int(event.x)
- y = int(event.y)
- pthinfo = treeview.get_path_at_pos(x, y)
- if pthinfo is not None:
- path = pthinfo[0]
- cellx = pthinfo[2]
- #Clicking on row toggle icon just select the path
- if cellx <= CATEGORY_TOGGLE_ICON_WIDTH:
- self.w_categories_treeview.set_cursor(path)
- self.w_categories_treeview.scroll_to_cell(path)
- return
- #Collapse expand Top level Sections only
- tree_view = self.w_categories_treeview
- if path != 0 and len(path) == 1:
- if tree_view.row_expanded(path) and \
- self.w_main_view_notebook.get_current_page() == \
- NOTEBOOK_START_PAGE:
- self.__on_category_selection_changed(
- tree_view.get_selection(), None)
- elif tree_view.row_expanded(path):
- selection, sel_path = \
- self.__get_selection_and_category_path()
- if selection and sel_path == path:
- tree_view.collapse_row(path)
- else:
- tree_view.expand_row(path, False)
- self.__save_active_category(path)
-
- @staticmethod
- def __categoriestreeview_compare_func(model, column, key, itr):
- value = model.get_value(itr, column)
- if not value:
- return True
-
- try:
- value = re.sub(REGEX_STRIP_MARKUP, "", value)
- value = re.sub(REGEX_STRIP_RESULT, "", value)
- match = re.match(re.escape(key), re.escape(value), re.IGNORECASE)
- except (TypeError, re.error):
- return True
-
- return match is None
-
- def __in_recent_searches(self, path):
- if not path or len(path) == 0:
- return False
- model = self.w_categories_treeview.get_model()
- if model == None:
- return False
- rs_path = model.get_path(self.recent_searches_cat_iter)
- if rs_path and len(rs_path) > 0 and path[0] == rs_path[0]:
- return True
- return False
-
- def __save_expanded_path(self, path, expanded):
- if not path or len(path) == 0:
- return
- self.category_expanded_paths[(self.last_visible_publisher, path)] = \
- expanded
-
- def __save_active_category(self, path):
- if self.first_run or not path or len(path) == 0 or \
- self.__in_recent_searches(path):
- return
- self.category_active_paths[self.last_visible_publisher] = path
- self.saved_section_active = path[0]
-
- def __on_category_selection_changed(self, selection, widget):
- '''This function is for handling category selection changes'''
- if self.in_setup:
- return
- model, itr = selection.get_selected()
- if not itr:
- return
-
- path = model.get_path(itr)
- sel_category = model[path]
- if sel_category[enumerations.CATEGORY_ID] == RECENT_SEARCH_ID:
- if not self.adding_recent_search:
- self.__setup_recent_search_page()
- if not self.is_all_publishers_search:
- self.__save_setup_before_search(
- single_search=True)
- self.in_search_mode = True
- self.in_recent_search = True
- else:
- self.__set_main_view_package_list()
- return
- elif sel_category[enumerations.CATEGORY_ID] > RECENT_SEARCH_ID:
- self.__restore_recent_search(sel_category)
- return
- self.__save_active_category(path)
- if self.in_search_mode or self.is_all_publishers_search:
- #Required for A11Y support because focus event not triggered
- #when A11Y enabled and user clicks on Category after Search
- self.__unset_search(True)
- self.__set_main_view_package_list()
- return
- if self.saved_filter_combobox_active != None:
- self.w_filter_combobox.set_active(
- self.saved_filter_combobox_active)
- self.__set_main_view_package_list()
-
- self.set_busy_cursor()
- self.__refilter_on_idle()
-
- def __on_applicationtreeview_query_tooltip(self, treeview, x, y,
- keyboard_mode, tooltip):
- treex, treey = treeview.convert_widget_to_bin_window_coords(x, y)
- info = treeview.get_path_at_pos(treex, treey)
- if not info:
- return False
- return self.__show_app_column_tooltip(treeview, _("Status"),
- info[0], info[1], tooltip)
-
- @staticmethod
- def __show_app_column_tooltip(treeview, col_title, path, col, tooltip):
- tip = ""
- if path and col:
- title = col.get_title()
- if title != col_title:
- return False
- row = list(treeview.get_model()[path])
- if row:
- status = row[enumerations.STATUS_COLUMN]
- if status == api.PackageInfo.INSTALLED:
- tip = _("Installed")
- elif status == api.PackageInfo.KNOWN:
- tip = _("Not installed")
- elif status == api.PackageInfo.UPGRADABLE:
- tip = _("Updates Available")
-
- if tip != "":
- treeview.set_tooltip_cell(tooltip, path, col, None)
- tooltip.set_text(tip)
- return True
- else:
- return False
-
- def __on_applicationtreeview_button_and_key_events(self, treeview, event):
- if event.type == gtk.gdk.KEY_PRESS:
- keyname = gtk.gdk.keyval_name(event.keyval)
- if event.state == gtk.gdk.CONTROL_MASK and keyname == "F1":
- return True #Disable Tooltip popup using Ctrl-F1
-
- if not(event.state == gtk.gdk.SHIFT_MASK and keyname == "F10"):
- return
-
- selection = self.w_application_treeview.get_selection()
- if not selection:
- return
- model, itr = selection.get_selected()
- if not model or not itr:
- return
- curr_time = event.time
- path = model.get_path(itr)
- col = treeview.get_column(1) # NAME_COLUMN
- treeview.set_cursor(path, col, 0)
-
- #Calculate popup coordinates
- treecell_rect = treeview.get_cell_area(path, col)
- rx, ry = treeview.tree_to_widget_coords(treecell_rect[0],
- treecell_rect[1])
- winx, winy = treeview.get_bin_window().get_origin()
- winx += rx
- winy += ry
- popup_position = (winx, winy)
- self.w_package_menu.popup( None, None,
- self.__position_package_popup, gtk.gdk.KEY_PRESS,
- curr_time, popup_position)
- return True
-
- if event.type != gtk.gdk.BUTTON_PRESS and event.type != 5:
- return
- x = int(event.x)
- y = int(event.y)
- pthinfo = treeview.get_path_at_pos(x, y)
- if pthinfo == None:
- return
- path = pthinfo[0]
- col = pthinfo[1]
-
- #Double click
- if event.type == GDK_2BUTTON_PRESS:
- self.__active_pane_toggle(None, path, treeview.get_model())
- return
- if event.button == GDK_RIGHT_BUTTON: #Right Click
- curr_time = event.time
- treeview.grab_focus()
- treeview.set_cursor( path, col, 0)
- self.w_package_menu.popup( None, None, None, event.button,
- curr_time)
- return
-
- @staticmethod
- def __applicationtreeview_compare_func(model, column, key, itr):
- value = model.get_value(itr, enumerations.NAME_COLUMN)
- if not value:
- return True
-
- value = value.lower()
- return not value.startswith(key.lower())
-
- @staticmethod
- def __position_package_popup(menu, position):
- #Positions popup relative to the top left corner of the currently
- #selected row's Name cell
- x, y = position
-
- #Offset x by 10 and y by 15 so underlying name is visible
- return (x+10, y+15, True)
-
- def __on_filtercombobox_changed(self, widget):
- '''On filter combobox changed'''
- if self.first_run or self.in_setup:
- return
- active = self.w_filter_combobox.get_active()
- if active != enumerations.FILTER_SELECTED:
- self.saved_filter_combobox_active = active
- self.__set_main_view_package_list()
- self.set_busy_cursor()
- self.__refilter_on_idle()
-
- def __unset_search(self, same_repo):
- self.w_logalert_frame.hide()
- self.__update_tooltips()
- self.in_search_mode = False
- self.in_recent_search = False
- self.is_all_publishers_search = False
- if same_repo:
- self.__restore_setup_for_browse()
-
- def __on_repositorycombobox_changed(self, widget):
- '''On repository combobox changed'''
- if debug_perf:
- print "Start change publisher", time.time()
- if self.same_publisher_on_setup:
- if self.is_all_publishers_search:
- self.__clear_search_results()
- self.same_publisher_on_setup = False
- self.unset_busy_cursor()
- if self.in_setup:
- self.in_setup = False
- return
- selected_publisher = self.__get_selected_publisher()
- index = self.w_repository_combobox.get_active()
- if self.is_all_publishers_search:
- if index == self.repo_combobox_all_pubs_search_index:
- return
- if index == self.repo_combobox_add_index:
- self.w_repository_combobox.set_active(
- self.repo_combobox_all_pubs_search_index)
- self.__on_file_add_publisher(None)
- return
- same_repo = self.saved_repository_combobox_active == index
- self.__unset_search(same_repo)
- if same_repo:
- self.__set_searchentry_to_prompt()
- return
- self.w_repository_combobox.set_active(index)
- selected_publisher = self.__get_selected_publisher()
- if selected_publisher == self.last_visible_publisher:
- return
- if index == self.repo_combobox_all_pubs_search_index:
- self.__set_all_publishers_search_mode()
- return
-
- if index == self.repo_combobox_add_index:
- index = self.__get_publisher_combobox_index(
- self.last_visible_publisher)
- self.w_repository_combobox.set_active(index)
- self.__on_file_add_publisher(None)
- return
- self.is_all_publishers = False
- if index == self.repo_combobox_all_pubs_installed_index:
- self.w_filter_combobox.set_active(enumerations.FILTER_ALL)
- self.is_all_publishers_installed = True
- else:
- self.is_all_publishers_installed = False
- if index == self.repo_combobox_all_pubs_index:
- self.is_all_publishers = True
-
- self.__do_set_publisher()
-
- def __do_set_publisher(self):
- self.cancelled = True
- self.in_setup = True
- self.set_busy_cursor()
- self.__set_empty_details_panel()
- if self.in_search_mode:
- self.__unset_search(False)
-
- pub = [self.__get_selected_publisher(), ]
- self.set_section = self.gconf.initial_section
- self.__set_searchentry_to_prompt()
- self.__disconnect_models()
- Thread(target = self.__setup_publisher, args = [pub]).start()
- self.__set_main_view_package_list()
-
- def __get_selected_publisher(self):
- pub_iter = self.w_repository_combobox.get_active_iter()
- if pub_iter == None:
- return None
- return self.repositories_list.get_value(pub_iter, \
- enumerations.REPOSITORY_PREFIX)
-
- def __setup_publisher(self, publishers):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__setup_publisher_without_lock(publishers)
- gui_misc.release_lock(self.api_lock)
-
- def __setup_publisher_without_lock(self, publishers):
- self.saved_filter_combobox_active = self.gconf.initial_show_filter
- application_list, category_list , section_list = \
- self.__get_application_categories_lists(publishers)
- self.__unset_saved()
- self.publisher_changed = True
- self.last_visible_publisher = self.__get_selected_publisher()
- self.saved_repository_combobox_active = \
- self.w_repository_combobox.get_active()
- gobject.idle_add(self.__init_tree_views, application_list,
- category_list, section_list)
-
- def __unset_saved(self):
- self.__save_application_list(None)
- self.saved_application_list_filter = None
- self.saved_application_list_sort = None
- self.saved_category_list = None
- self.saved_section_list = None
-
- def __refresh_for_publisher(self, pub):
- status_str = _("Refreshing package catalog information")
- gobject.idle_add(self.update_statusbar_message,
- status_str)
- if self.is_all_publishers_installed or self.is_all_publishers:
- self.__do_refresh()
- else:
- self.__do_refresh(pubs=[pub])
-
- def __do_refresh(self, pubs=None, immediate=False):
- success = False
- try:
- if debug_perf:
- print "Time before reset",time.time()
- if immediate:
- self.api_o.reset()
- if debug_perf:
- print "Time after reset", time.time()
- self.api_o.refresh(pubs=pubs, immediate=immediate)
- if debug_perf:
- print "after refresh", time.time()
- success = True
- except api_errors.CatalogRefreshException, cre:
- res = gui_misc.get_catalogrefresh_exception_msg(cre)
- logger.error(res[0])
- gui_misc.notify_log_error(self)
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.InvalidDepotResponseException, idex:
- err = str(idex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.PermissionsException, ex:
- if self.first_run:
- self.user_rights = False
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- except api_errors.ApiException, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- except Exception, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- return success
-
- def __get_application_categories_lists(self, publishers):
- application_list = self.__get_new_application_liststore()
- category_list = self.__get_new_category_liststore()
- section_list = self.__get_new_section_liststore()
- for pub in publishers:
- if debug_perf:
- a = time.time()
- self.__refresh_for_publisher(pub)
- if debug_perf:
- print "Time to refresh", time.time() - a
- a = time.time()
- self.__add_pkgs_to_lists_from_api(pub,
- application_list, category_list, section_list)
- if debug_perf:
- b = time.time()
- print "Time to add", b - a, b
- category_list.prepend(None, [0, _('All'), _('All'), None,
- None, True])
-
- return application_list, category_list, section_list
-
- def __add_install_update_pkgs_for_publishers(self, install_update,
- confirmation_list):
- for pub_name in self.selected_pkgs:
- pub_display_name = self.get_publisher_display_name_from_prefix(
- pub_name)
- pkgs = self.selected_pkgs.get(pub_name)
- if not pkgs:
- break
- for pkg_stem in pkgs:
- status = pkgs.get(pkg_stem)[0]
- if status == api.PackageInfo.KNOWN or \
- status == api.PackageInfo.UPGRADABLE:
- install_update.append(pkg_stem)
- if self.gconf.show_install:
- desc = pkgs.get(pkg_stem)[1]
- pkg_name = pkgs.get(pkg_stem)[2]
- confirmation_list.append(
- [pkg_name, pub_display_name,
- desc, status, pkg_stem])
-
- def __on_log_activate(self, widget):
- if self.error_logged:
- self.error_logged = False
- self.w_logalert_frame.hide()
- self.logging.log_activate()
-
- def __on_version_info(self, widget):
- model, itr = self.package_selection.get_selected()
- if itr:
- pkg_stem = model.get_value(itr, enumerations.STEM_COLUMN)
- name = model.get_value(itr, enumerations.ACTUAL_NAME_COLUMN)
- self.set_busy_cursor()
- Thread(target = self.__get_info, args = (pkg_stem, name)).start()
-
- def check_exiting(self):
- return self.exiting
-
- def __get_info(self, pkg_stem, name):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__get_info_without_lock(pkg_stem, name)
- gui_misc.release_lock(self.api_lock)
-
- def __get_info_without_lock(self, pkg_stem, name):
- if not self.do_api_reset():
- return
- try:
- if self.versioninfo.get_info(pkg_stem, name):
- gobject.idle_add(self.unset_busy_cursor)
- except api_errors.ApiException, ex:
- err = str(ex)
- logger.error(err)
- gobject.idle_add(gui_misc.notify_log_error, self)
- gobject.idle_add(self.unset_busy_cursor)
- return
-
- def do_api_reset(self):
- if self.api_o == None:
- return False
- try:
- self.api_o.reset()
- except api_errors.ApiException, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- return False
- return True
-
- def __on_install_update(self, widget):
- if not self.do_api_reset():
- return
- install_update = []
- install_confirmation_list = []
- if self.all_selected > 0:
- self.__add_install_update_pkgs_for_publishers(
- install_update, install_confirmation_list)
-
- if self.img_timestamp != self.cache_o.get_index_timestamp():
- self.img_timestamp = None
-
- self.installupdate = installupdate.InstallUpdate(install_update, self, \
- self.image_directory, action = enumerations.INSTALL_UPDATE,
- main_window = self.w_main_window,
- confirmation_list = install_confirmation_list,
- show_confirmation = self.gconf.show_install,
- api_lock = self.api_lock,
- gconf = self.gconf)
-
- def __on_update_all(self, widget):
- if not self.do_api_reset():
- return
- self.installupdate = installupdate.InstallUpdate([], self,
- self.image_directory, action = enumerations.IMAGE_UPDATE,
- parent_name = self.program_title,
- pkg_list = [gui_misc.package_name["SUNWipkg"],
- gui_misc.package_name["SUNWipkg-gui"]],
- main_window = self.w_main_window,
- icon_confirm_dialog = self.window_icon,
- show_confirmation = self.gconf.show_image_update,
- api_lock = self.api_lock,
- gconf = self.gconf)
- return
-
- def __on_help_about(self, widget):
- aboutdialog = self.builder.get_object("aboutdialog")
- aboutdialog.set_icon(self.window_icon)
- aboutdialog.connect("response", lambda x = None, \
- y = None: aboutdialog.hide())
- aboutdialog.set_version(gui_misc.get_os_version_and_build())
- aboutdialog.run()
-
- @staticmethod
- def __on_help_help(widget):
- gui_misc.display_help()
-
- def __add_remove_pkgs_for_publishers(self, remove_list, confirmation_list):
- for pub_name in self.selected_pkgs:
- pub_display_name = self.get_publisher_display_name_from_prefix(
- pub_name)
- pkgs = self.selected_pkgs.get(pub_name)
- if not pkgs:
- break
- for pkg_stem in pkgs:
- status = pkgs.get(pkg_stem)[0]
- if status == api.PackageInfo.INSTALLED or \
- status == api.PackageInfo.UPGRADABLE:
- remove_list.append(pkg_stem)
- if self.gconf.show_remove:
- desc = pkgs.get(pkg_stem)[1]
- pkg_name = pkgs.get(pkg_stem)[2]
- confirmation_list.append(
- [pkg_name, pub_display_name,
- desc, status, pkg_stem])
-
- def __on_remove(self, widget):
- if not self.do_api_reset():
- return
- remove_list = []
- remove_confirmation_list = []
- if self.all_selected > 0:
- self.__add_remove_pkgs_for_publishers(remove_list,
- remove_confirmation_list)
-
- if self.img_timestamp != self.cache_o.get_index_timestamp():
- self.img_timestamp = None
-
- self.installupdate = installupdate.InstallUpdate(remove_list, self,
- self.image_directory, action = enumerations.REMOVE,
- main_window = self.w_main_window,
- confirmation_list = remove_confirmation_list,
- show_confirmation = self.gconf.show_remove,
- api_lock = self.api_lock,
- gconf = self.gconf)
-
- def __on_reload(self, widget):
- self.force_reload_packages = True
- self.__do_reload(widget, True)
-
- def __do_reload(self, widget, immediate):
- self.w_repository_combobox.grab_focus()
- if self.force_reload_packages and (self.in_search_mode
- or self.is_all_publishers_search):
- self.__unset_search(False)
- if self.force_reload_packages:
- self.__set_empty_details_panel()
- self.in_setup = True
- self.last_visible_publisher = None
- self.set_busy_cursor()
- status_str = _("Refreshing package catalog information")
- self.update_statusbar_message(status_str)
- Thread(target = self.__catalog_refresh, args = (immediate,)).start()
-
- def __catalog_refresh(self, immediate):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__catalog_refresh_without_lock(immediate)
- gui_misc.release_lock(self.api_lock)
-
- def __catalog_refresh_without_lock(self, immediate):
- """Update image's catalogs."""
- success = self.__do_refresh(immediate=immediate)
- if not success:
- gobject.idle_add(self.unset_busy_cursor)
- gobject.idle_add(self.update_statusbar)
- return -1
- gobject.idle_add(self.__clear_recent_searches)
- self.__catalog_refresh_done()
- return 0
-
- def __catalog_refresh_done(self):
- if not self.exiting:
- gobject.idle_add(self.process_package_list_start)
-
- def __get_publisher_name_from_index(self, index):
- name = None
- if index != -1:
- itr = self.repositories_list.iter_nth_child(None,
- index)
- name = self.repositories_list.get_value(itr,
- enumerations.REPOSITORY_PREFIX)
- return name
-
- def __shutdown_part1(self):
- self.cancelled = True
- self.exiting = True
- self.__progress_pulse_stop()
-
- self.w_main_window.hide()
- gui_misc.shutdown_logging()
-
- def __shutdown_part2(self):
- if self.api_o and self.api_o.can_be_canceled():
- Thread(target = self.api_o.cancel, args = ()).start()
- gui_misc.exit_if_no_threads()
- gobject.timeout_add(1000, gui_misc.exit_if_no_threads)
-
- def __main_application_quit(self, restart = False):
- '''quits the main gtk loop'''
- save_width, save_height = self.w_main_window.get_size()
- save_hpos = self.w_main_hpaned.get_position()
- save_vpos = self.w_main_vpaned.get_position()
-
- self.__shutdown_part1()
- pub = ""
- start_insearch = False
- width = height = hpos = vpos = -1
- if self.gconf.save_state:
- if self.is_all_publishers_search:
- start_insearch = True
- sel_pub = self.publisher_options[PUBLISHER_INSTALLED]
- elif (self.is_all_publishers_installed or
- self.is_all_publishers):
- sel_pub = self.__get_publisher_name_from_index(
- self.saved_repository_combobox_active)
- else:
- sel_pub = self.__get_selected_publisher()
- if sel_pub != None:
- pub = sel_pub
- width = save_width
- height = save_height
- hpos = save_hpos
- vpos = save_vpos
- else:
- # Reset to start in search mode having loaded installed pkgs
- pub = self.publisher_options[PUBLISHER_INSTALLED]
- start_insearch = True
- self.gconf.save_values(pub, start_insearch, width, height,
- hpos, vpos)
-
- if restart:
- gobject.spawn_async([self.application_path, "-R",
- self.image_directory, "-U"])
-
- if len(self.search_completion) > 0:
- self.cache_o.dump_search_completion_info(
- self.search_completion)
- if self.gconf.save_state:
- if len(self.category_active_paths) > 0:
- self.cache_o.dump_categories_active_dict(
- self.category_active_paths)
- if len(self.category_expanded_paths) > 0:
- self.cache_o.dump_categories_expanded_dict(
- self.category_expanded_paths)
- else:
- self.cache_o.dump_categories_active_dict({})
- self.cache_o.dump_categories_expanded_dict({})
-
- self.__shutdown_part2()
- return True
-
- def __check_if_something_was_changed(self):
- ''' Returns True if any of the check boxes for package was changed, false
- if not'''
- if self.application_list:
- for pkg in self.application_list:
- if pkg[enumerations.MARK_COLUMN] == True:
- return True
- return False
-
- def __setup_repositories_combobox(self, api_o):
- previous_publisher = None
- previous_saved_name = None
- if not self.first_run:
- previous_publisher = self.__get_selected_publisher()
- if self.saved_repository_combobox_active != -1:
- itr = self.repositories_list.iter_nth_child(None,
- self.saved_repository_combobox_active)
- previous_saved_name = \
- self.repositories_list.get_value(itr,
- enumerations.REPOSITORY_PREFIX)
- self.__disconnect_repository_model()
- self.repositories_list = self.__get_new_repositories_liststore()
- highest_ranked_pub = api_o.get_highest_ranked_publisher()
- default_pub = None
- if highest_ranked_pub != None and \
- isinstance(highest_ranked_pub, publisher.Publisher):
- default_pub = highest_ranked_pub.prefix
- if self.default_publisher != default_pub:
- self.__clear_pkg_selections()
- self.default_publisher = default_pub
- selected_repos = []
- enabled_repos = []
- for repo in self.selected_pkgs:
- selected_repos.append(repo)
- i = 0
- active = 0
- self.pubs_info = {}
- self.pubs_display_name = {}
- pubs = api_o.get_publishers()
- for pub in pubs:
- self.pubs_info[pub.prefix] = (pub.disabled, pub.alias)
- if pub.disabled:
- continue
- alias = pub.alias
- prefix = pub.prefix
- if gui_misc.alias_clash(pubs, prefix, alias):
- display_name = "%s (%s)" % (alias, prefix)
- elif alias == None or len(alias) == 0:
- display_name = prefix
- else:
- display_name = alias
- self.pubs_display_name[pub.prefix] = display_name
- if cmp(prefix, self.default_publisher) == 0:
- active = i
- self.repositories_list.append([i, display_name, prefix, alias ])
- enabled_repos.append(prefix)
- i = i + 1
- self.repo_combobox_all_pubs_index = i
- self.repositories_list.append([self.repo_combobox_all_pubs_index,
- self.publisher_options[PUBLISHER_ALL],
- self.publisher_options[PUBLISHER_ALL], None, ])
- i = i + 1
- self.repositories_list.append([-1, "", None, None, ])
- i = i + 1
- self.repo_combobox_all_pubs_installed_index = i
- #Workaround to display Publisher All Search during startup
- #If stating in Search mode
- if self.first_run and self.gconf.start_insearch:
- self.repositories_list.append(
- [self.repo_combobox_all_pubs_installed_index,
- self.publisher_options[PUBLISHER_ALL_SEARCH],
- self.publisher_options[PUBLISHER_INSTALLED],
- None, ])
- else:
- self.repositories_list.append(
- [self.repo_combobox_all_pubs_installed_index,
- self.publisher_options[PUBLISHER_INSTALLED],
- self.publisher_options[PUBLISHER_INSTALLED],
- None, ])
- i = i + 1
- self.repositories_list.append([-1, "", None, None, ])
- i = i + 1
- self.repo_combobox_all_pubs_search_index = i
- self.repositories_list.append([self.repo_combobox_all_pubs_search_index,
- self.publisher_options[PUBLISHER_ALL_SEARCH],
- self.publisher_options[PUBLISHER_ALL_SEARCH], None, ])
- i = i + 1
- self.repositories_list.append([-1, "", None, None, ])
- i = i + 1
- self.repo_combobox_add_index = i
- self.repositories_list.append([-1,
- self.publisher_options[PUBLISHER_ADD],
- self.publisher_options[PUBLISHER_ADD], None, ])
- pkgs_to_remove = []
- for repo_name in selected_repos:
- if repo_name not in enabled_repos:
- pkg_stems = self.selected_pkgs.get(repo_name)
- for pkg_stem in pkg_stems:
- pkgs_to_remove.append(pkg_stem)
- for pkg_stem in pkgs_to_remove:
- self.__remove_pkg_stem_from_list(pkg_stem)
- self.w_repository_combobox.set_model(self.repositories_list)
- selected_id = -1
- self.same_publisher_on_setup = False
- if self.gconf.lastsource == None or self.gconf.lastsource == "":
- # Start in search mode having loaded installed pkgs
- self.gconf.set_lastsource(
- self.publisher_options[PUBLISHER_INSTALLED])
- self.gconf.set_start_insearch(True)
-
- if self.first_run:
- for repo in self.repositories_list:
- if (repo[enumerations.REPOSITORY_PREFIX] == \
- self.gconf.lastsource and
- repo[enumerations.REPOSITORY_ID] != -1):
- selected_id = \
- repo[enumerations.REPOSITORY_ID]
- break
- else:
- for repo in self.repositories_list:
- if (repo[enumerations.REPOSITORY_PREFIX] ==
- previous_publisher and
- repo[enumerations.REPOSITORY_ID] != -1):
- selected_id = \
- repo[enumerations.REPOSITORY_ID]
- if (previous_publisher != \
- self.publisher_options[PUBLISHER_ALL] and
- not self.force_reload_packages):
- self.same_publisher_on_setup = True
- break
- if self.saved_repository_combobox_active != -1:
- self.saved_repository_combobox_active = -1
- for repo in self.repositories_list:
- if (repo[enumerations.REPOSITORY_PREFIX] ==
- previous_saved_name):
- self.saved_repository_combobox_active = \
- repo[enumerations.REPOSITORY_ID]
- break
- # Previous publisher no longer enabled
- if self.saved_repository_combobox_active == -1:
- selected_id = -1
- self.same_publisher_on_setup = False
- if selected_id != -1:
- self.w_repository_combobox.set_active(selected_id)
- elif self.default_publisher:
- self.w_repository_combobox.set_active(active)
- else:
- self.w_repository_combobox.set_active(0)
-
- def __active_pane_toggle(self, cell, path, model_sort):
- '''Toggle function for column enumerations.MARK_COLUMN'''
- applicationModel = model_sort.get_model()
- applicationPath = model_sort.convert_path_to_child_path(path)
- filterModel = applicationModel.get_model()
- child_path = applicationModel.convert_path_to_child_path(applicationPath)
- itr = filterModel.get_iter(child_path)
- if itr:
- modified = filterModel.get_value(itr, enumerations.MARK_COLUMN)
- filterModel.set_value(itr, enumerations.MARK_COLUMN,
- not modified)
- pkg_status = filterModel.get_value(itr,
- enumerations.STATUS_COLUMN)
- pkg_stem = filterModel.get_value(itr, enumerations.STEM_COLUMN)
- if modified:
- self.__remove_pkg_stem_from_list(pkg_stem)
- else:
- pkg_publisher = filterModel.get_value(itr,
- enumerations.PUBLISHER_PREFIX_COLUMN)
- pkg_description = filterModel.get_value(itr,
- enumerations.DESCRIPTION_COLUMN)
- pkg_name = filterModel.get_value(itr,
- enumerations.NAME_COLUMN)
- self.__add_pkg_stem_to_list(pkg_stem, pkg_name,
- pkg_status, pkg_publisher, pkg_description)
- self.update_statusbar()
- self.__enable_disable_selection_menus()
- self.__enable_disable_install_remove()
-
- def __update_menu_items(self):
- if self.user_rights:
- self.w_reload_menuitem.set_sensitive(True)
- self.w_reload_button.set_sensitive(True)
- self.w_updateall_button.set_sensitive(True)
- self.w_updateall_menuitem.set_sensitive(True)
- else:
- self.w_reload_menuitem.set_sensitive(False)
- self.w_reload_button.set_sensitive(False)
- self.w_updateall_button.set_sensitive(False)
- self.w_updateall_menuitem.set_sensitive(False)
- if self.is_admin:
- self.w_be_menuitem.set_sensitive(True)
- else:
- self.w_be_menuitem.set_sensitive(False)
-
- def __add_pkg_stem_to_list(self, stem, name, status, pub, description="test"):
- if self.selected_pkgs.get(pub) == None:
- self.selected_pkgs[pub] = {}
- self.selected_pkgs.get(pub)[stem] = [status, description, name]
- if status == api.PackageInfo.KNOWN or \
- status == api.PackageInfo.UPGRADABLE:
- if self.to_install_update.get(pub) == None:
- self.to_install_update[pub] = 1
- else:
- self.to_install_update[pub] += 1
- if status == api.PackageInfo.UPGRADABLE or \
- status == api.PackageInfo.INSTALLED:
- if self.to_remove.get(pub) == None:
- self.to_remove[pub] = 1
- else:
- self.to_remove[pub] += 1
- self.__update_tooltips()
-
- def __update_tooltips(self):
- to_remove = None
- to_install = None
- no_iter = 0
- for pub in self.to_remove:
- packages = self.to_remove.get(pub)
- if packages > 0:
- if no_iter == 0:
- to_remove = _("Selected for Removal:")
- to_remove += "\n %s: %d" % (pub, packages)
- no_iter += 1
- no_iter = 0
- for pub in self.to_install_update:
- packages = self.to_install_update.get(pub)
- if packages > 0:
- if no_iter == 0:
- to_install = _("Selected for Install/Update:")
- to_install += "\n %s: %d" % (pub, packages)
- no_iter += 1
- if not to_install:
- to_install = _("Select packages by marking the checkbox "
- "and click to Install/Update.")
- self.w_installupdate_button.set_tooltip_text(to_install)
- if not to_remove:
- to_remove = _("Select packages by marking the checkbox "
- "and click to Remove selected.")
- self.w_remove_button.set_tooltip_text(to_remove)
-
- def __remove_pkg_stem_from_list(self, stem):
- remove_pub = []
- for pub in self.selected_pkgs:
- pkgs = self.selected_pkgs.get(pub)
- status = None
- if stem in pkgs:
- status = pkgs.pop(stem)[0]
- if status == api.PackageInfo.KNOWN or \
- status == api.PackageInfo.UPGRADABLE:
- if self.to_install_update.get(pub) == None:
- self.to_install_update[pub] = 0
- else:
- self.to_install_update[pub] -= 1
- if status == api.PackageInfo.UPGRADABLE or \
- status == api.PackageInfo.INSTALLED:
- if self.to_remove.get(pub) == None:
- self.to_remove[pub] = 0
- else:
- self.to_remove[pub] -= 1
- if len(pkgs) == 0:
- remove_pub.append(pub)
- for pub in remove_pub:
- self.selected_pkgs.pop(pub)
- self.__update_tooltips()
-
- def __clear_pkg_selections(self):
- # We clear the selections as the preferred repository was changed
- # and pkg stems are not valid.
- remove_pub = []
- for pub in self.selected_pkgs:
- stems = self.selected_pkgs.get(pub)
- for pkg_stem in stems:
- remove_pub.append(pkg_stem)
- for pkg_stem in remove_pub:
- self.__remove_pkg_stem_from_list(pkg_stem)
-
- def __set_empty_details_panel(self):
- if self.show_info_id != 0:
- gobject.source_remove(self.show_info_id)
- self.show_info_id = 0
- if self.show_dependencies_id != 0:
- gobject.source_remove(self.show_dependencies_id)
- self.show_dependencies_id = 0
- if self.show_licenses_id != 0:
- gobject.source_remove(self.show_licenses_id)
- self.show_licenses_id = 0
- if self.show_versions_id != 0:
- gobject.source_remove(self.show_versions_id)
- self.show_versions_id = 0
- self.info_pkgstem = None
- self.dependencies_pkgstem = None
- self.license_pkgstem = None
- self.versions_pkgstem = None
- self.detailspanel.set_empty_details()
-
- def __update_package_versions(self, versions, versions_id, pkgstem):
- if (versions_id != self.last_show_versions_id):
- return
- self.versions_pkgstem = pkgstem
- self.detailspanel.update_package_versions(versions)
-
- def __show_versions(self):
- self.show_versions_id = 0
- if self.selected_pkg_name == None:
- return
- gobject.idle_add(self.set_busy_cursor)
- Thread(target = self.__show_package_versions,
- args = (self.selected_pkg_name, self.selected_pkg_pub,
- self.selected_pkgstem, self.last_show_versions_id,)).start()
-
- def __show_package_versions(self, selected_pkg_name, selected_pkg_pub,
- selected_pkgstem, versions_id):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__show_package_versions_without_lock(selected_pkg_name,
- selected_pkg_pub, selected_pkgstem, versions_id)
- gui_misc.release_lock(self.api_lock)
-
- def __show_package_versions_without_lock(self, selected_pkg_name,
- selected_pkg_pub, selected_pkgstem, versions_id):
- if debug:
- a = time.time()
- # Get versions for package
- try:
- if selected_pkg_name == None:
- return
- try:
- versions_list = self.api_o.get_pkg_list(
- pkg_list = api.ImageInterface.LIST_ALL,
- pubs = [selected_pkg_pub],
- patterns = [selected_pkg_name])
- except api_errors.ApiException, apiex:
- err = str(apiex)
- gobject.idle_add(self.error_occurred, err,
- _('Unexpected Error'))
- return
- try:
- versions = []
- for entry in versions_list:
- states = entry[3]
- ver = entry[0][2]
- versions.append((ver, states))
- if debug:
- print "Time to get versions:", time.time() - a
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.ApiException, apiex:
- err = str(apiex)
- gobject.idle_add(self.error_occurred, err,
- _('Unexpected Error'))
- gobject.idle_add(self.__update_package_versions, versions,
- versions_id, selected_pkgstem)
- finally:
- gobject.idle_add(self.unset_busy_cursor)
-
- def __update_package_license(self, licenses, license_id, pkgstem):
- if (license_id != self.last_show_licenses_id):
- return
- self.license_pkgstem = pkgstem
- self.detailspanel.update_package_license(licenses)
-
- def __show_licenses(self):
- self.show_licenses_id = 0
- if self.selected_pkgstem == None:
- gobject.idle_add(self.__update_package_license, None,
- self.last_show_licenses_id, self.selected_pkgstem)
- return
- gobject.idle_add(self.set_busy_cursor)
- Thread(target = self.__show_package_licenses,
- args = (self.selected_pkgstem, self.last_show_licenses_id,)).start()
-
- def __show_package_licenses(self, selected_pkgstem, license_id):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__show_package_licenses_without_lock(selected_pkgstem, license_id)
- gui_misc.release_lock(self.api_lock)
-
- def __show_package_licenses_without_lock(self, selected_pkgstem, license_id):
- try:
- if selected_pkgstem == None:
- return
- info = None
- try:
- info = self.api_o.info([selected_pkgstem],
- True, frozenset([api.PackageInfo.LICENSES]))
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.InvalidDepotResponseException, idex:
- err = str(idex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.ImageLockedError, ex:
- err = str(ex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except Exception, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err)
- if self.detailspanel.showing_empty_details or (license_id !=
- self.last_show_licenses_id):
- return
- if not info or (info and len(info.get(0)) == 0):
- try:
- # Get license from remote
- info = self.api_o.info([selected_pkgstem],
- False, frozenset([api.PackageInfo.LICENSES]))
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.InvalidDepotResponseException, idex:
- err = str(idex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.ImageLockedError, ex:
- err = str(ex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except Exception, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err)
- if self.detailspanel.showing_empty_details or (license_id !=
- self.last_show_licenses_id):
- return
- pkgs_info = None
- package_info = None
- no_licenses = 0
- if info:
- pkgs_info = info[0]
- if pkgs_info:
- package_info = pkgs_info[0]
- if package_info:
- no_licenses = len(package_info.licenses)
- if no_licenses == 0:
- gobject.idle_add(self.__update_package_license, None,
- license_id, selected_pkgstem)
- return
- else:
- gobject.idle_add(self.__update_package_license,
- package_info.licenses, license_id, selected_pkgstem)
- finally:
- gobject.idle_add(self.unset_busy_cursor)
-
- def __update_package_dependencies(self, info, dep_info,
- installed_dep_info, dependencies_id, pkg_stem):
- if self.detailspanel.showing_empty_details or (dependencies_id !=
- self.last_show_dependencies_id):
- return
- self.dependencies_pkgstem = pkg_stem
- self.detailspanel.update_package_dependencies(info, dep_info,
- installed_dep_info, self.installed_icon, self.not_installed_icon)
-
- def __show_dependencies(self):
- self.show_dependencies_id = 0
- self.dependencies_pkgstem = None
- model, itr = self.package_selection.get_selected()
- if model == None or itr == None:
- return
-
- pkg_stem = model.get_value(itr, enumerations.STEM_COLUMN)
- pkg_status = model.get_value(itr, enumerations.STATUS_COLUMN)
- self.set_busy_cursor()
- Thread(target = self.__show_package_dependencies,
- args = (pkg_stem, pkg_status, self.last_show_dependencies_id)).start()
-
- def __show_package_dependencies(self, pkg_stem, pkg_status, dependencies_id):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__show_package_dependencies_without_lock(pkg_stem, pkg_status,
- dependencies_id)
- gui_misc.release_lock(self.api_lock)
-
- def __show_package_dependencies_without_lock(self, pkg_stem, pkg_status,
- dependencies_id):
- if self.detailspanel.showing_empty_details or (dependencies_id !=
- self.last_show_dependencies_id):
- return
- local_info, remote_info = self.__fetch_info(dependencies_id,
- self.last_show_dependencies_id, pkg_stem, pkg_status)
- if not local_info and not remote_info:
- gobject.idle_add(self.detailspanel.no_dependencies_available)
- gobject.idle_add(self.unset_busy_cursor)
- return
-
- if local_info:
- info = local_info
- else:
- info = remote_info
- if info == None or info.dependencies == None:
- gobject.idle_add(self.detailspanel.no_dependencies_available)
- gobject.idle_add(self.unset_busy_cursor)
- return
-
- dep_info = None
- installed_dep_info = None
- try:
- try:
- dep_info = self.api_o.info(
- info.dependencies,
- False,
- frozenset([api.PackageInfo.STATE,
- api.PackageInfo.IDENTITY]))
- temp_info = []
- for depend in info.dependencies:
- name = fmri.extract_pkg_name(
- depend)
- temp_info.append(name)
- installed_dep_info = self.api_o.info(
- temp_info,
- True,
- frozenset([api.PackageInfo.STATE,
- api.PackageInfo.IDENTITY]))
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.InvalidDepotResponseException, \
- idex:
- err = str(idex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.ImageLockedError, ex:
- err = str(ex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except Exception, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err)
-
- gobject.idle_add(self.__update_package_dependencies,
- info, dep_info, installed_dep_info, dependencies_id, pkg_stem)
- finally:
- gobject.idle_add(self.unset_busy_cursor)
-
- return
-
- def __fetch_info(self, info_id, last_show_info_id, pkg_stem, pkg_status):
- local_info = None
- remote_info = None
- if not self.detailspanel.showing_empty_details and (info_id ==
- last_show_info_id) and (pkg_status ==
- api.PackageInfo.INSTALLED or pkg_status ==
- api.PackageInfo.UPGRADABLE):
- local_info = gui_misc.get_pkg_info(self, self.api_o, pkg_stem,
- True)
- if not self.detailspanel.showing_empty_details and (info_id ==
- last_show_info_id) and (pkg_status ==
- api.PackageInfo.KNOWN or pkg_status ==
- api.PackageInfo.UPGRADABLE):
- remote_info = gui_misc.get_pkg_info(self, self.api_o, pkg_stem,
- False)
- return (local_info, remote_info)
-
- def __update_package_info(self, pkg_name, pkg_stem, local_info, remote_info,
- info_id, renamed_info = None, pkg_renamed = False):
- if self.detailspanel.showing_empty_details or (info_id !=
- self.last_show_info_id):
- self.unset_busy_cursor()
- return
- self.info_pkgstem = pkg_stem
- self.detailspanel.update_package_info(pkg_name, local_info,
- remote_info, self.api_o.root,
- self.installed_icon, self.not_installed_icon,
- self.update_available_icon,
- self.is_all_publishers_installed, self.pubs_info,
- renamed_info, pkg_renamed)
- self.unset_busy_cursor()
-
- def __show_info(self, model, path):
- self.show_info_id = 0
- self.info_pkgstem = None
-
- if not (model and path):
- return
-
- itr = model.get_iter(path)
- pkg_name = model.get_value(itr, enumerations.ACTUAL_NAME_COLUMN)
- pkg_stem = model.get_value(itr, enumerations.STEM_COLUMN)
- pkg_status = model.get_value(itr, enumerations.STATUS_COLUMN)
- pkg_renamed = model.get_value(itr, enumerations.RENAMED_COLUMN)
- self.set_busy_cursor()
- Thread(target = self.__show_package_info,
- args = (pkg_name, pkg_stem, pkg_status, self.last_show_info_id,
- pkg_renamed)).start()
-
- def __show_package_info(self, pkg_name, pkg_stem, pkg_status, info_id,
- pkg_renamed):
- self.api_lock.acquire()
- gobject.idle_add(self.set_busy_cursor)
- self.__show_package_info_without_lock(pkg_name, pkg_stem, pkg_status,
- info_id, pkg_renamed)
- gui_misc.release_lock(self.api_lock)
-
- def __show_package_info_without_lock(self, pkg_name, pkg_stem, pkg_status,
- info_id, pkg_renamed):
- if self.detailspanel.showing_empty_details or \
- info_id != self.last_show_info_id:
- self.unset_busy_cursor()
- return
- local_info, remote_info = self.__fetch_info(info_id,
- self.last_show_info_id, pkg_stem, pkg_status)
-
- renamed_info = None
- if pkg_renamed:
- if local_info != None and \
- len(local_info.dependencies) > 0:
- renamed_info = local_info
- elif remote_info != None and \
- len(remote_info.dependencies) > 0:
- renamed_info = remote_info
- else:
- if remote_info != None and \
- len(remote_info.dependencies) > 0:
- if api.PackageInfo.RENAMED in remote_info.states:
- renamed_info = remote_info
- gobject.idle_add(self.__update_package_info, pkg_name, pkg_stem,
- local_info, remote_info, info_id, renamed_info, pkg_renamed)
-
- return
-
- def __get_active_section_and_category(self):
- selection = self.w_categories_treeview.get_selection()
- selected_section = 0
- selected_category = 0
-
- if not selection:
- return 0, 0
- category_model, category_itr = selection.get_selected()
- if not category_model or not category_itr:
- return 0, 0
-
- selected_category = category_model.get_value(category_itr,
- enumerations.CATEGORY_ID)
- cat_path = list(category_model.get_path(category_itr))
-
- # Top level Section has been selected
- if len(cat_path) == 1 and selected_category > RECENT_SEARCH_ID_OFFSET:
- selected_section = selected_category
- return selected_section, 0
- elif len(cat_path) == 1 and selected_category > SECTION_ID_OFFSET:
- selected_section = selected_category - SECTION_ID_OFFSET
- return selected_section, 0
- else:
- # Subcategory selected need to get categories parent Section
- parent_iter = category_model.iter_parent(category_itr)
- if not parent_iter:
- return selected_section, selected_category
- selected_section = category_model.get_value(
- parent_iter, enumerations.CATEGORY_ID) - SECTION_ID_OFFSET
- return selected_section, selected_category
-
- def __application_filter(self, model, itr):
- '''This function is used to filter content in the main
- application view'''
- selected_category = 0
- selected_section = 0
- category = False
-
- if self.in_setup or self.cancelled:
- return category
- filter_id = self.w_filter_combobox.get_active()
- if filter_id == enumerations.FILTER_SELECTED:
- return model.get_value(itr, enumerations.MARK_COLUMN)
-
- category_list = model.get_value(itr, enumerations.CATEGORY_LIST_COLUMN)
- selected_section, selected_category = \
- self.__get_active_section_and_category()
-
- in_recent_search = False
- if selected_section == 0 and selected_category == 0:
- #Clicked on All Categories
- category = True
- elif selected_category != 0:
- #Clicked on subcategory
- if category_list and selected_category in category_list:
- category = True
- elif category_list:
- #Clicked on Top Level section
- if selected_section < RECENT_SEARCH_ID_OFFSET:
- categories_in_section = \
- self.section_categories_list[selected_section]
- for cat_id in category_list:
- if cat_id in categories_in_section:
- category = True
- break
- else:
- in_recent_search = True
- if (model.get_value(itr, enumerations.IS_VISIBLE_COLUMN) == False):
- return False
- if self.in_search_mode or in_recent_search:
- return self.__is_package_filtered(model, itr, filter_id)
- return (category &
- self.__is_package_filtered(model, itr, filter_id))
-
- @staticmethod
- def __is_package_filtered(model, itr, filter_id):
- '''Function for filtercombobox'''
- if filter_id == enumerations.FILTER_ALL:
- return True
- status = model.get_value(itr, enumerations.STATUS_COLUMN)
- if filter_id == enumerations.FILTER_INSTALLED:
- return (status == api.PackageInfo.INSTALLED or status == \
- api.PackageInfo.UPGRADABLE)
- elif filter_id == enumerations.FILTER_UPDATES:
- return status == api.PackageInfo.UPGRADABLE
- elif filter_id == enumerations.FILTER_NOT_INSTALLED:
- return status == api.PackageInfo.KNOWN
-
- def __enable_disable_selection_menus(self):
- if self.in_setup:
- return
- self.__enable_disable_select_updates()
- if not self.__doing_search():
- self.unset_busy_cursor()
-
- def __enable_disable_select_all(self):
- if self.in_setup:
- return
- if self.w_main_view_notebook.get_current_page() == NOTEBOOK_START_PAGE:
- self.w_selectall_menuitem.set_sensitive(False)
- self.w_deselect_menuitem.set_sensitive(False)
- return
-
- model = self.w_application_treeview.get_model()
- if model != None and len(model) > 0:
- for row in model:
- if not row[enumerations.MARK_COLUMN]:
- self.w_selectall_menuitem.set_sensitive(True)
- return
- self.w_selectall_menuitem.set_sensitive(False)
- else:
- self.w_selectall_menuitem.set_sensitive(False)
-
- def __enable_disable_install_remove(self):
- self.__enable_disable_export_selections()
- if not self.user_rights:
- self.w_installupdate_button.set_sensitive(False)
- self.w_installupdate_menuitem.set_sensitive(False)
- self.w_remove_button.set_sensitive(False)
- self.w_remove_menuitem.set_sensitive(False)
- return
- self.__enable_if_selected_for_removal()
- self.__enable_if_selected_for_install_update()
-
- def __enable_if_selected_for_removal(self):
- sensitive = False
- selected = 0
- for pub in self.to_remove:
- selected = self.to_remove.get(pub)
- if selected > 0:
- break
- if selected > 0:
- sensitive = True
- self.w_remove_button.set_sensitive(sensitive)
- self.w_remove_menuitem.set_sensitive(sensitive)
- return sensitive
-
- def __enable_if_selected_for_install_update(self):
- sensitive = False
- selected = 0
- for pub in self.to_install_update:
- selected = self.to_install_update.get(pub)
- if selected > 0:
- break
- if selected > 0:
- sensitive = True
- self.w_installupdate_button.set_sensitive(sensitive)
- self.w_installupdate_menuitem.set_sensitive(sensitive)
- return sensitive
-
- def __enable_disable_select_updates(self):
- model = self.w_application_treeview.get_model()
- if model == None:
- return
- for row in model:
- if row[enumerations.STATUS_COLUMN] == api.PackageInfo.UPGRADABLE:
- if not row[enumerations.MARK_COLUMN]:
- self.w_selectupdates_menuitem. \
- set_sensitive(True)
- return
- self.w_selectupdates_menuitem.set_sensitive(False)
- return
-
- def __enable_disable_export_selections(self):
- if self.selected_pkgs == None or len(self.selected_pkgs) == 0:
- self.w_export_selections_menuitem.set_sensitive(False)
- else:
- self.w_export_selections_menuitem.set_sensitive(True)
- return
-
- def __enable_disable_deselect(self):
- if self.w_application_treeview.get_model():
- for row in self.w_application_treeview.get_model():
- if row[enumerations.MARK_COLUMN]:
- self.w_deselect_menuitem.set_sensitive(True)
- return
- self.w_deselect_menuitem.set_sensitive(False)
- return
-
- def __add_pkgs_to_lists_from_api(self, pub, application_list,
- category_list, section_list):
- pubs = []
- pkgs_from_api = []
- status_str = _("Loading package list")
- gobject.idle_add(self.update_statusbar_message, status_str)
- try:
- if self.is_all_publishers_installed:
- pkgs_from_api = self.api_o.get_pkg_list(pubs = pubs,
- pkg_list = api.ImageInterface.LIST_INSTALLED)
- elif self.is_all_publishers:
- pkgs_from_api = self.api_o.get_pkg_list(pubs = pubs,
- pkg_list = api.ImageInterface.LIST_INSTALLED_NEWEST)
- else:
- pubs.append(pub)
- pkgs_from_api = self.api_o.get_pkg_list(pubs = pubs,
- pkg_list = api.ImageInterface.LIST_INSTALLED_NEWEST)
- except api_errors.InventoryException:
- # This can happen if the repository does not
- # contain any packages
- err = _("Selected publisher does not contain any packages.")
- gobject.idle_add(self.error_occurred, err, None,
- gtk.MESSAGE_INFO)
- gobject.idle_add(self.unset_busy_cursor)
- except api_errors.ApiException, apiex:
- err = str(apiex)
- gobject.idle_add(self.error_occurred, err, _('Unexpected Error'))
- gobject.idle_add(self.unset_busy_cursor)
- try:
- self.__add_pkgs_to_lists(pkgs_from_api, pubs, application_list,
- category_list, section_list)
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.CanceledException:
- gobject.idle_add(self.unset_busy_cursor)
- except api_errors.ApiException, apiex:
- err = str(apiex)
- gobject.idle_add(self.error_occurred, err, _('Unexpected Error'))
- gobject.idle_add(self.unset_busy_cursor)
-
- def __get_categories_for_pubs(self, pubs):
- sections = {}
- #ImageInfo for categories
- sectioninfo = imageinfo.ImageInfo()
- share_path = os.path.join(self.application_dir,
- "usr/share/lib/pkg")
- if len(pubs) == 0:
- section = sectioninfo.read(os.path.join(share_path,
- "opensolaris.org.sections"))
- sections["opensolaris.org"] = section
- return sections
-
- for pub in pubs:
- if debug_perf:
- a = time.time()
- section = sectioninfo.read(os.path.join(share_path,
- pub + ".sections"))
- if len(section) == 0:
- section = sectioninfo.read(os.path.join(share_path,
- "opensolaris.org.sections"))
- sections[pub] = section
- if debug_perf:
- print "Time for get_pkg_categories", time.time() - a
-
- return sections
-
- def __add_pkgs_to_lists_from_info(self, local_results, remote_results,
- application_list):
- status_str = _("Loading package list")
- gobject.idle_add(self.update_statusbar_message, status_str)
-
- pkg_add = self.__add_pkgs_to_lists_from_results(local_results,
- 0, application_list)
- self.__add_pkgs_to_lists_from_results(remote_results,
- pkg_add, application_list)
-
- def __get_icon_for_state(self, state):
- if state == api.PackageInfo.UPGRADABLE:
- status_icon = self.update_available_icon
- elif state == api.PackageInfo.INSTALLED:
- status_icon = self.installed_icon
- else:
- status_icon = self.not_installed_icon
- return status_icon
-
- def __add_pkgs_to_lists_from_results(self, results, pkg_add,
- application_list):
- for result in results:
- pkg_pub = result.publisher
- pkg_name = result.pkg_stem
- pkg_stem = "pkg://" + pkg_pub + "/" + pkg_name
- summ = result.summary
- pkg_renamed = (api.PackageInfo.RENAMED in result.states)
- pkg_state = gui_misc.get_state_from_states(result.states)
- status_icon = self.__get_icon_for_state(pkg_state)
- if not self.is_all_publishers_search and \
- not self.is_all_publishers_installed:
- pkg_name = gui_misc.get_minimal_unique_name(
- self.package_names, pkg_name,
- self.special_package_names)
- if len(pkg_name) == 0:
- pkg_name = result.pkg_stem
- marked = False
- pkgs = self.selected_pkgs.get(pkg_pub)
- if pkgs != None:
- if pkg_stem in pkgs:
- marked = True
- pub_name = self.get_publisher_name_from_prefix(pkg_pub)
- #Add to application_list
- next_app = \
- [
- marked, status_icon, pkg_name, summ, pkg_state,
- pkg_stem, result.pkg_stem, True, None, pub_name,
- pkg_pub, pkg_renamed
- ]
- application_list.insert(pkg_add, next_app)
- pkg_add += 1
- return pkg_add
-
- def __add_pkgs_to_lists(self, pkgs_from_api, pubs, application_list,
- category_list, section_list):
- if section_list != None:
- self.__init_sections(section_list)
- sections = self.__get_categories_for_pubs(pubs)
- pkg_add = 0
- if debug_perf:
- a = time.time()
- self.package_names = {}
- self.special_package_names = []
- pub_names = {}
- for entry in pkgs_from_api:
- (pkg_pub, pkg_name, ver), summ, cats, states, attrs = entry
- if debug:
- print entry, ver
- pkg_stem = "pkg://" + pkg_pub + "/" + pkg_name
- gui_misc.add_pkgname_to_dic(self.package_names,
- pkg_name, self.special_package_names)
- pkg_renamed = (api.PackageInfo.RENAMED in states)
- pkg_state = gui_misc.get_state_from_states(states)
- status_icon = self.__get_icon_for_state(pkg_state)
- marked = False
- pkgs = self.selected_pkgs.get(pkg_pub)
- if pkgs != None:
- if pkg_stem in pkgs:
- marked = True
- if not pub_names.has_key(pkg_pub):
- pub_names[pkg_pub] = \
- self.get_publisher_name_from_prefix(
- pkg_pub)
- pub_name = pub_names[pkg_pub]
- #Add to application_list
- next_app = \
- [
- marked, status_icon, pkg_name, summ, pkg_state,
- pkg_stem, pkg_name, True, None, pub_name,
- pkg_pub, pkg_renamed
- ]
- self.__add_package_to_list(next_app,
- application_list,
- pkg_add, pkg_name,
- cats, category_list, pkg_pub)
- pkg_add += 1
- for pkg in application_list:
- pkg_name = pkg[enumerations.NAME_COLUMN]
- name = gui_misc.get_minimal_unique_name(self.package_names,
- pkg_name, self.special_package_names)
- if pkg_name != name:
- pkg[enumerations.NAME_COLUMN] = name
-
- if debug_perf:
- print "Time to add packages:", time.time() - a
- if category_list != None:
- self.__add_categories_to_sections(sections,
- category_list, section_list)
- return
-
- def __add_categories_to_sections(self, sections, category_list, section_list):
- for pub in sections:
- for section in sections[pub]:
- self.__add_category_to_section(sections[pub][section],
- _(section), category_list, section_list)
- return
-
- def __add_package_to_list(self, app, application_list, pkg_add,
- pkg_name, cats, category_list, pub):
- row_iter = application_list.insert(pkg_add, app)
- if category_list == None:
- return
- for cat in cats:
- if len(cat[1]) > 1:
- self.__add_package_to_category(cat[1],
- row_iter, application_list,
- category_list, pkg_name)
-
- @staticmethod
- def __add_package_to_category(category_name, package,
- application_list, category_list, pkg_name):
- category_names = category_name.split('/', 2)
- if len(category_names) != 2:
- print _("Invalid category name [%(cat)s] for package %(pack)s") \
- % {"cat": category_name,
- "pack": pkg_name}
- return
- category_visible_name = category_names[1]
- if not package or category_visible_name == 'All':
- return
- if not category_visible_name:
- return
- category_id = None
- for category in category_list:
- if category[enumerations.CATEGORY_NAME] == category_name:
- category_id = category[enumerations.CATEGORY_ID]
- break
- if not category_id: # Category not exists
- category_id = len(category_list) + 1
- category_list.append(None, [category_id, category_name,
- category_visible_name, None, None, True])
- if application_list.get_value(package,
- enumerations.CATEGORY_LIST_COLUMN):
- a = application_list.get_value(package,
- enumerations.CATEGORY_LIST_COLUMN)
- a.append(category_id)
- else:
- category_list = []
- category_list.append(category_id)
- application_list.set(package,
- enumerations.CATEGORY_LIST_COLUMN, category_list)
-
- def __add_categories_to_tree(self, category_list, section_list):
- category_tree = self.__get_new_category_liststore()
- cat_iter = category_tree.append(None, [ 0, _("All Categories"),
- _("All Categories"), None, None, True])
-
- self.section_categories_list = {}
- #Build dic of section ids and categories they contain
- #section_category_list[<sec_id>] -> cat_ids[cat_id] -> category
- #Each category row contains a list of sections it belongs to stored in
- #category[enumerations.SECTION_LIST_OBJECT]
- for category in category_list:
- category_section_ids = \
- category[enumerations.SECTION_LIST_OBJECT]
- if category_section_ids == None:
- continue
- for sec_id in category_section_ids:
- if sec_id in self.section_categories_list:
- category_ids = \
- self.section_categories_list[sec_id]
- category_ids[category[enumerations.CATEGORY_ID]] \
- = category
- else:
- self.section_categories_list[sec_id] = \
- {category[enumerations.CATEGORY_ID]:\
- category}
-
- #Build up the Category Tree
- count = 1
- visible_default_section_path = None
- for section in section_list:
- sec_id = section[enumerations.SECTION_ID]
- #Map self.set_section section_list index to visible section index
- if sec_id <= 0 or not section[enumerations.SECTION_ENABLED]:
- continue
- if self.set_section == sec_id:
- visible_default_section_path = (count,)
- count += count
- section_name = "<b>" + section[enumerations.SECTION_NAME] + "</b>"
- cat_iter = category_tree.append(None,
- [ SECTION_ID_OFFSET + section[enumerations.SECTION_ID],
- section_name, section_name, None, None, True])
-
- if not sec_id in self.section_categories_list:
- continue
-
- category_ids = self.section_categories_list[sec_id]
- category_list = self.__get_new_category_liststore()
- for cat_id in category_ids.keys():
- if category_ids[cat_id][
- enumerations.CATEGORY_IS_VISIBLE]:
- category_list.append(None, category_ids[cat_id])
- # Sort the Categories into alphabetical order
- if len(category_list) > 0:
- rows = [tuple(r) + (i,) for i,
- r in enumerate(category_list)]
- rows.sort(self.__sort)
- r = []
- category_list.reorder(None, [r[-1] for r in rows])
- for category in category_list:
- category_tree.append(cat_iter, category)
-
- recent_search_name = "<span foreground='#757575'><b>" + \
- _("Recent Searches") + "</b></span>"
- self.recent_searches_cat_iter = category_tree.append(None,
- [RECENT_SEARCH_ID, recent_search_name, recent_search_name,
- None, None, True])
- if self.recent_searches and len(self.recent_searches) > 0:
- for recent_search in self.recent_searches_list:
- category_tree.append(self.recent_searches_cat_iter,
- self.recent_searches[recent_search])
-
- self.w_categories_treeview.set_model(category_tree)
-
- #Initial startup expand default Section if available
- if visible_default_section_path and self.first_run and \
- len(self.category_active_paths) == 0 and \
- len(self.category_expanded_paths) == 0:
- self.w_categories_treeview.expand_row(
- visible_default_section_path, False)
- return
- self.__restore_category_state()
-
- def __add_recent_search(self, text, pub_prefix, application_list,
- search_all):
- self.adding_recent_search = True
- category_tree = self.w_categories_treeview.get_model()
- if category_tree == None:
- return
- if search_all:
- pub_name = _("All Publishers")
- else:
- pub_name = self.get_publisher_display_name_from_prefix(
- pub_prefix)
- recent_search = "(%d) <b>%s</b> %s" % \
- (len(application_list), text, pub_name)
- if not (recent_search in self.recent_searches):
- cat_iter = category_tree.append(self.recent_searches_cat_iter,
- [RECENT_SEARCH_ID + 1, recent_search, recent_search,
- text, application_list, True])
- self.recent_searches[recent_search] = \
- [RECENT_SEARCH_ID + 1, recent_search, recent_search,
- text, application_list, True]
- self.recent_searches_list.append(recent_search)
- else:
- rs_iter = category_tree.iter_children(
- self.recent_searches_cat_iter)
- while rs_iter:
- rs_value = category_tree.get_value(rs_iter,
- enumerations.CATEGORY_VISIBLE_NAME)
- if rs_value == recent_search:
- category_tree.remove(rs_iter)
- break
- rs_iter = category_tree.iter_next(rs_iter)
- cat_iter = category_tree.append(self.recent_searches_cat_iter,
- [RECENT_SEARCH_ID + 1, recent_search, recent_search,
- text, application_list, True])
- self.recent_searches_list.remove(recent_search)
- self.recent_searches_list.append(recent_search)
- path = category_tree.get_path(cat_iter)
- self.w_categories_treeview.expand_to_path(path)
- self.__unselect_category()
- self.w_categories_treeview.scroll_to_cell(path)
- self.adding_recent_search = False
-
- def __clear_recent_searches(self):
- self.after_install_remove = False
- category_tree = self.w_categories_treeview.get_model()
- if category_tree == None:
- return
- if self.recent_searches == None or len(self.recent_searches) == 0:
- return
- self.__set_searchentry_to_prompt()
- selection, sel_path = self.__get_selection_and_category_path()
- rs_iter = category_tree.iter_children(self.recent_searches_cat_iter)
- while rs_iter:
- category_tree.remove(rs_iter)
- if category_tree.iter_is_valid(rs_iter):
- rs_iter = category_tree.iter_next(rs_iter)
- else:
- break
- del(self.recent_searches_list[:])
- self.recent_searches.clear()
-
- rs_path = category_tree.get_path(self.recent_searches_cat_iter)
- if selection and sel_path and rs_path and len(sel_path) > 0 and \
- len(rs_path) > 0 and sel_path[0] == rs_path[0]:
- self.__restore_setup_for_browse()
-
- def __update_recent_search_states(self, application_list):
- pkg_stems = []
- pkg_stem_states = {}
- for row in application_list:
- pkg_stems.append(row[enumerations.STEM_COLUMN])
- #Check for changes in package installation status
- try:
- info = self.api_o.info(pkg_stems, True, frozenset(
- [api.PackageInfo.STATE, api.PackageInfo.IDENTITY]))
- for info_s in info.get(0):
- pkg_stem = info_s.fmri.get_pkg_stem()
- if api.PackageInfo.INSTALLED in info_s.states:
- pkg_stem_states[pkg_stem] = \
- api.PackageInfo.INSTALLED
- else:
- pkg_stem_states[pkg_stem] = \
- api.PackageInfo.KNOWN
- except api_errors.TransportError, tpex:
- err = str(tpex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.InvalidDepotResponseException, idex:
- err = str(idex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except api_errors.ImageLockedError, ex:
- err = str(ex)
- logger.error(err)
- gui_misc.notify_log_error(self)
- except Exception, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err)
-
- #Create a new result list updated with current installation status
- tmp_app_list = self.__get_new_application_liststore()
-
- for row in application_list:
- pkg_stem = row[enumerations.STEM_COLUMN]
- pub = row[enumerations.PUBLISHER_COLUMN]
- marked = False
- pkgs = None
- if self.selected_pkgs != None:
- pkgs = self.selected_pkgs.get(pub)
- if pkgs != None:
- if pkg_stem in pkgs:
- marked = True
- if row[enumerations.MARK_COLUMN] != marked:
- row[enumerations.MARK_COLUMN] = marked
-
- if pkg_stem_states.has_key(pkg_stem):
- row[enumerations.STATUS_COLUMN] = \
- pkg_stem_states[pkg_stem]
- if pkg_stem_states[pkg_stem] == \
- api.PackageInfo.KNOWN:
- row[enumerations.STATUS_ICON_COLUMN] = \
- self.not_installed_icon
- else:
- row[enumerations.STATUS_ICON_COLUMN] = \
- self.installed_icon
- else:
- row[enumerations.STATUS_COLUMN] = \
- api.PackageInfo.KNOWN
- row[enumerations.STATUS_ICON_COLUMN] = \
- self.not_installed_icon
- tmp_app_list.append(row)
- return tmp_app_list
-
- def __restore_recent_search(self, sel_category):
- if not sel_category:
- return
- if not self.is_all_publishers_search:
- self.__save_setup_before_search(single_search=True)
-
- application_list = sel_category[enumerations.SECTION_LIST_OBJECT]
- text = sel_category[enumerations.CATEGORY_DESCRIPTION]
- if self.after_install_remove:
- application_list = self.__update_recent_search_states(
- application_list)
- # Theme: saved search application list is cached with old theme icons
- self.__reset_application_list_status_icons(application_list)
- self.__clear_before_search(show_list=True, in_setup=False,
- unselect_cat=False)
- self.in_search_mode = True
- self.in_recent_search = True
- self.__set_search_text_mode(enumerations.SEARCH_STYLE_NORMAL)
- self.w_searchentry.set_text(text)
- self.__set_main_view_package_list()
- self.__init_tree_views(application_list, None, None, None, None,
- enumerations.NAME_COLUMN)
-
- def __setup_category_state(self):
- self.cache_o.load_categories_active_dict(self.category_active_paths)
- self.cache_o.load_categories_expanded_dict(self.category_expanded_paths)
-
- def __restore_category_state(self):
- #Restore expanded Category state
- if self.w_categories_treeview == None:
- return
- model = self.w_categories_treeview.get_model()
- if model == None:
- return
- if len(self.category_expanded_paths) > 0:
- paths = self.category_expanded_paths.items()
- for key, val in paths:
- source, path = key
- if self.last_visible_publisher == source and val:
- self.w_categories_treeview.expand_row(path, False)
- #Restore selected category path
- if self.last_visible_publisher in self.category_active_paths and \
- self.category_active_paths[self.last_visible_publisher]:
- self.w_categories_treeview.set_cursor(
- self.category_active_paths[self.last_visible_publisher])
- else:
- self.w_categories_treeview.set_cursor(0)
- return
-
- @staticmethod
- def __add_category_to_section(categories_list, section_name, category_list,
- section_list):
- '''Adds the section to section list in category. If there is no such
- section, than it is not added. If there was already section than it
- is skipped. Sections must be case sensitive'''
- if not categories_list:
- return
- for section in section_list:
- if section[enumerations.SECTION_NAME] == section_name:
- section_id = section[enumerations.SECTION_ID]
- for category in category_list:
- localized_top_cat = _(category[
- enumerations.CATEGORY_NAME].split("/")[0])
- if localized_top_cat == \
- section[enumerations.SECTION_NAME]:
-
- vis = \
- enumerations.CATEGORY_VISIBLE_NAME
- category[vis] = _(category[
- enumerations.CATEGORY_VISIBLE_NAME])
- section_lst = category[ \
- enumerations.SECTION_LIST_OBJECT]
- section[enumerations.SECTION_ENABLED] = \
- True
- if not section_lst:
- category[ \
- enumerations.SECTION_LIST_OBJECT] = \
- [section_id, ]
- else:
- if not section_name in \
- section_lst:
- section_lst.append(
- section_id)
- break
-
-
- def __progress_pulse_start(self):
- if self.progress_stop_thread == True:
- self.progress_stop_thread = False
- if self.progress_thread_stopped:
- self.progress_thread_stopped = False
- Thread(target = self.__progress_pulse).start()
-
- def __progress_pulse_stop(self):
- self.progress_stop_thread = True
-
- def __progress_pulse(self):
- gobject.idle_add(self.w_progress_frame.show)
- while not self.progress_stop_thread:
- if self.api_o and self.api_o.can_be_canceled():
- gobject.idle_add(self.progress_cancel.set_sensitive, True)
- else:
- gobject.idle_add(self.progress_cancel.set_sensitive,
- False)
- gobject.idle_add(self.w_status_progressbar.pulse)
- time.sleep(0.1)
- gobject.idle_add(self.w_progress_frame.hide)
- self.progress_thread_stopped = True
-
- def error_occurred(self, error_msg, msg_title=None, msg_type=gtk.MESSAGE_ERROR):
- if msg_title:
- title = msg_title
- else:
- title = self.program_title
- gui_misc.error_occurred(self.w_main_window, error_msg,
- title, msg_type, use_markup=True)
-
-#-----------------------------------------------------------------------------#
-# Static Methods
-#-----------------------------------------------------------------------------#
-
- @staticmethod
- def __sort(a, b):
- return cmp(a[2], b[2])
-
- @staticmethod
- def filter_cell_data_function(column, renderer, model, itr, data):
- '''Function which sets icon size'''
- pm, entry = data
- if entry == enumerations.FILTER_NAME:
- renderer.set_property("xalign", 0)
- renderer.set_property("width", pm.max_filter_length + 10)
- elif entry == enumerations.FILTER_ICON:
- renderer.set_property("xalign", 0)
- renderer.set_property("width", 24)
- return
-
- @staticmethod
- def cell_data_function(column, renderer, model, itr, data):
- '''Function which sets the background colour if package is
- selected'''
- if itr:
- # Theme: do not set background for Inverse Themes
- if data and data.is_inverse_theme:
- renderer.set_property("cell-background-set", False)
- elif model.get_value(itr, enumerations.MARK_COLUMN):
- renderer.set_property("cell-background", "#ffe5cc")
- renderer.set_property("cell-background-set", True)
- else:
- renderer.set_property("cell-background-set", False)
-
- @staticmethod
- def combobox_id_separator(model, itr):
- return model.get_value(itr, 0) == -1 and \
- model.get_value(itr, 1) == ""
-
- @staticmethod
- def combobox_filter_id_separator(model, itr):
- return model.get_value(itr, 0) == -1 and \
- model.get_value(itr, 2) == ""
-
- @staticmethod
- def get_datetime(version):
- dt = None
- try:
- dt = version.get_datetime()
- except AttributeError:
- dt = version.get_timestamp()
- return dt
-
- def __get_version(self, api_o, local, pkg):
- version = None
- try:
- info = api_o.info([pkg], local, frozenset(
- [api.PackageInfo.STATE, api.PackageInfo.IDENTITY]))
- found = info[api.ImageInterface.INFO_FOUND]
- version = found[0]
- except IndexError:
- pass
- except api_errors.ApiException, ex:
- err = str(ex)
- logger.error(err)
- gobject.idle_add(gui_misc.notify_log_error, self)
- except Exception, ex:
- pass
- return version
-
-#-----------------------------------------------------------------------------#
-# Public Methods
-#-----------------------------------------------------------------------------#
- def init_show_filter(self):
- """ Sets up the Filter Combobox size."""
- self.__init_show_filter()
-
- def reload_packages(self):
- self.api_o = gui_misc.get_api_object(self.image_directory,
- self.pr, self.w_main_window)
- self.cache_o = self.__get_cache_obj(self.api_o)
- self.force_reload_packages = False
- self.__do_reload(None, False)
-
- def update_facets(self, facets_to_set):
- if facets_to_set == None or \
- len(facets_to_set.keys()) == 0:
- return
- gobject.idle_add(self.__update_facets, facets_to_set)
-
- def __update_facets(self, facets_to_set):
- installupdate.InstallUpdate([], self,
- self.image_directory,
- action = enumerations.UPDATE_FACETS,
- main_window = self.w_main_window,
- api_lock = self.api_lock,
- facets = facets_to_set)
-
- def is_busy_cursor_set(self):
- return self.gdk_window.is_visible()
-
- def set_busy_cursor(self):
- if self.gdk_window.get_state() & gtk.gdk.WINDOW_STATE_WITHDRAWN:
- self.gdk_window.show()
- self.w_main_window.get_accessible().emit('state-change',
- 'busy', True)
- if not self.exiting:
- self.__progress_pulse_start()
-
- def unset_busy_cursor(self):
- self.__progress_pulse_stop()
- if not (self.gdk_window.get_state() & gtk.gdk.WINDOW_STATE_WITHDRAWN):
- self.gdk_window.hide()
- self.w_main_window.get_accessible().emit('state-change',
- 'busy', False)
-
- def process_package_list_start(self):
- if self.first_run:
- self.__setup_filter_combobox()
- self.__setup_repositories_combobox(self.api_o)
- if self.first_run:
- self.__update_menu_items()
- self.w_repository_combobox.grab_focus()
-
- @staticmethod
- def __get_cache_obj(api_o):
- cache_o = cache.CacheListStores(api_o)
- return cache_o
-
- def __setup_search_completion(self):
- completion = gtk.EntryCompletion()
- self.cache_o.load_search_completion_info(self.search_completion)
- completion.set_model(self.search_completion)
- self.w_searchentry.set_completion(completion)
- completion.set_text_column(0)
- self.w_searchentry.connect('activate', self.__search_completion_cb)
-
- def process_package_list_end(self):
- self.in_startpage_startup = False
- if self.update_all_proceed:
- self.__on_update_all(None)
- self.update_all_proceed = False
- self.__enable_disable_install_remove()
- self.update_statusbar()
- self.in_setup = False
- self.cancelled = False
- active_filter = self.w_filter_combobox.get_active()
- ret = self.__get_selection_and_category_path()
- need_refilter = True
- if ret[0] and ret[1][0] == 0:
- need_refilter = False
- if need_refilter or active_filter != enumerations.FILTER_ALL:
- self.__application_refilter()
- else:
- self.__enable_disable_select_all()
- self.__enable_disable_deselect()
- if not self.__doing_search():
- self.unset_busy_cursor()
- if debug_perf:
- print "End process_package_list_end", time.time()
- if self.first_run:
- if self.gconf.start_insearch:
- self.w_repository_combobox.set_active(
- self.repo_combobox_all_pubs_search_index)
- self.repositories_list[ \
- self.repo_combobox_all_pubs_installed_index] = \
- ([self.repo_combobox_all_pubs_installed_index,
- self.publisher_options[PUBLISHER_INSTALLED],
- self.publisher_options[PUBLISHER_INSTALLED],
- None, ])
-
- self.first_run = False
-
- def __count_selected_packages(self):
- self.all_selected = 0
- for pub_name in self.selected_pkgs:
- pkgs = self.selected_pkgs.get(pub_name)
- if not pkgs:
- break
- self.all_selected += len(pkgs)
-
- def update_statusbar(self):
- '''Function which updates statusbar'''
- self.__remove_statusbar_message()
- search_text = self.w_searchentry.get_text()
-
- self.__count_selected_packages()
- if self.application_list == None:
- return
- self.length_visible_list = len(self.application_list_filter)
- if not self.in_search_mode:
- selected_in_list = 0
- for pkg_row in self.application_list_filter:
- if pkg_row[enumerations.MARK_COLUMN]:
- selected_in_list = selected_in_list + 1
- status_str = _("Total: %(total)s Selected: %(selected)s") % \
- {"total": self.length_visible_list,
- "selected": selected_in_list}
- self.update_statusbar_message(status_str)
- return
-
- # In Search Mode
- if self.w_main_statusbar_label:
- search_text = saxutils.escape(search_text)
- s1, e1 = self.get_start_end_strings()
-
- if self.__doing_search():
- active_pub = self.publisher_being_searched
- status_str = ""
- if active_pub != None and active_pub != "":
- status_str = \
- _("Searching %(s1)s%(active_pub)s%(e1)s"
- " for %(s1)s%(search_text)s%(e1)s ...") % \
- {"s1": s1, "active_pub": active_pub, "e1": e1,
- "search_text": search_text}
- else:
- status_str = \
- _("Searching for %(s1)s%(search_text)s%(e1)s "
- "...") % \
- {"s1": s1, "search_text": search_text, "e1": e1}
- else:
- status_str = ngettext(
- "%(number)d package found matching %(s1)s"
- "%(search_text)s%(e1)s",
- "%(number)d packages found matching %(s1)s"
- "%(search_text)s%(e1)s", len(self.application_list)) % \
- {"number": len(self.application_list),
- "s1": s1, "search_text": search_text, "e1": e1, }
- self.update_statusbar_message(status_str)
-
- def __reset_row_status(self, row):
- pkg_stem = row[enumerations.STEM_COLUMN]
- self.__remove_pkg_stem_from_list(pkg_stem)
- package_info = self.__get_version(self.api_o,
- local = True, pkg = pkg_stem)
- package_installed = False
- if package_info:
- package_installed = \
- (api.PackageInfo.INSTALLED in package_info.states)
- if package_installed:
- package_info = self.__get_version(self.api_o,
- local = False, pkg = pkg_stem)
- if (package_info and
- api.PackageInfo.INSTALLED in package_info.states):
- row[enumerations.STATUS_COLUMN] = \
- api.PackageInfo.INSTALLED
- row[enumerations.STATUS_ICON_COLUMN] = \
- self.installed_icon
- else:
- row[enumerations.STATUS_COLUMN] = \
- api.PackageInfo.UPGRADABLE
- row[enumerations.STATUS_ICON_COLUMN] = \
- self.update_available_icon
- else:
- row[enumerations.STATUS_COLUMN] = \
- api.PackageInfo.KNOWN
- row[enumerations.STATUS_ICON_COLUMN] = \
- self.not_installed_icon
- row[enumerations.MARK_COLUMN] = False
-
- def __update_publisher_list(self, pub, full_list, package_list):
- for row in full_list:
- if row[enumerations.ACTUAL_NAME_COLUMN] in package_list:
- self.__reset_row_status(row)
-
- def update_package_list(self, update_list):
- ''' update_package_list is called with update_list set to None
- when InstallUpdate object can be discarded when installing or
- removing packages.
-
- update_package_list is called with update_list set to not None
- to indicate what packages have been updated so Package Manager
- can update its data.'''
- if update_list == None:
- self.installupdate = None
- if self.img_timestamp:
- return
- self.after_install_remove = True
- visible_publisher = self.__get_selected_publisher()
- default_publisher = self.default_publisher
- self.__do_refresh(immediate=True)
- if update_list == None and not self.img_timestamp:
- self.img_timestamp = self.cache_o.get_index_timestamp()
- self.__on_reload(None)
- return
- visible_list = update_list.get(visible_publisher)
- if self.is_all_publishers_search or self.is_all_publishers_installed \
- or self.is_all_publishers or self.in_recent_search:
- try:
- pubs = self.api_o.get_publishers()
- except api_errors.ApiException, ex:
- err = str(ex)
- gobject.idle_add(self.error_occurred, err,
- None, gtk.MESSAGE_INFO)
- return
- for pub in pubs:
- if pub.disabled:
- continue
- prefix = pub.prefix
- package_list = update_list.get(prefix)
- if package_list != None:
- self.__update_publisher_list(prefix,
- self.application_list,
- package_list)
- if self.last_visible_publisher == prefix:
- self.__update_publisher_list(prefix,
- self.saved_application_list,
- package_list)
- if self.is_all_publishers_installed or self.is_all_publishers:
- self.__do_set_publisher()
- elif visible_list:
- self.__update_publisher_list(visible_publisher,
- self.application_list, visible_list)
- if self.in_search_mode:
- self.__update_publisher_list(visible_publisher,
- self.saved_application_list,
- visible_list)
-
- for pub in update_list:
- if pub != visible_publisher:
- pkg_list = update_list.get(pub)
- for pkg in pkg_list:
- pkg_stem = None
- if pub != default_publisher:
- pkg_stem = gui_misc.get_pkg_stem(
- pkg, pub)
- else:
- pkg_stem = gui_misc.get_pkg_stem(
- pkg)
- if pkg_stem:
- self.__remove_pkg_stem_from_list(pkg_stem)
- if not self.img_timestamp:
- self.img_timestamp = self.cache_o.get_index_timestamp()
- self.__on_reload(None)
- return
- self.img_timestamp = self.cache_o.get_index_timestamp()
- if self.is_all_publishers_installed or self.is_all_publishers:
- return
- # We need to reset status descriptions if a11y is enabled
- self.__set_visible_status(False)
- self.__reset_info_tabs()
- self.__enable_disable_selection_menus()
- self.__enable_disable_install_remove()
- self.update_statusbar()
-
- def install_version(self, version):
- ''' Installed specified version of selected package'''
- if not self.do_api_reset():
- return
- to_install = "%s@%s" % (self.selected_pkgstem, version)
- install_update = [to_install]
-
- if self.img_timestamp != self.cache_o.get_index_timestamp():
- self.img_timestamp = None
-
- installupdate.InstallUpdate(install_update, self, \
- self.image_directory, action = enumerations.INSTALL_UPDATE,
- main_window = self.w_main_window, api_lock = self.api_lock)
-
- def get_current_repos_with_search_errors(self):
- return self.current_repos_with_search_errors
-
- def __reset_home_dir(self):
- # We reset the HOME directory in case the user called us
- # with gksu and had NFS mounted home directory in which
- # case dbus called from gconf cannot write to the directory.
- if self.is_admin:
- root_home_dir = self.__find_root_home_dir()
- os.putenv('HOME', root_home_dir)
-
- @staticmethod
- def __find_root_home_dir():
- return_str = '/var/tmp'
-
- try:
- lines = pwd.getpwnam('root')
- except KeyError:
- if debug:
- print "Error getting passwd database entry for root"
- return return_str
- try:
- return_str = lines[5]
- except IndexError:
- if debug:
- print "Error getting home directory for root"
- return return_str
-
- def restart_after_ips_update(self):
- self.__main_application_quit(restart = True)
-
- def shutdown_after_image_update(self, exit_pm = False):
- if exit_pm == True:
- self.__on_mainwindow_delete_event(None, None)
-
- def __get_api_object(self):
- self.api_o = gui_misc.get_api_object(self.image_directory,
- self.pr, self.w_main_window)
- self.cache_o = self.__get_cache_obj(self.api_o)
- self.img_timestamp = self.cache_o.get_index_timestamp()
- self.__setup_search_completion()
- self.__setup_category_state()
- gobject.idle_add(self.__got_api_object)
-
- def __got_api_object(self):
- self.process_package_list_start()
-
- def get_api_object(self):
- return self.api_o
-
- def start(self):
- if not self.gconf.show_startpage:
- self.__setup_startpage(self.gconf.show_startpage)
- self.set_busy_cursor()
- Thread(target = self.__get_api_object).start()
-
- def unhandled_exception_shutdown(self):
- self.__shutdown_part1()
- self.__shutdown_part2()
-
-###############################################################################
-#-----------------------------------------------------------------------------#
-# Main
-#-----------------------------------------------------------------------------#
-
-def main():
- gtk.main()
- return 0
-
-if __name__ == '__main__':
- program_title = _("Package Manager")
- gblexcepthandler = globalexceptionhandler.GlobalExceptionHandler()
- allow_links = False
- debug = False
- debug_perf = False
- update_all_proceed = False
- app_path = None
- image_dir = None
- info_install_arg = None
-
- try:
- opts, args = getopt.getopt(sys.argv[1:], "hR:Ui:", \
- ["help", "allow-links", "image-dir=", "update-all",
- "info-install="])
- except getopt.error, msg:
- print "%s, for help use --help" % msg
- sys.exit(2)
-
- if os.path.isabs(sys.argv[0]):
- app_path = sys.argv[0]
- else:
- cmd = os.path.join(os.getcwd(), sys.argv[0])
- app_path = os.path.realpath(cmd)
-
- for option, argument in opts:
- if option in ("-h", "--help"):
- print """\
-Use -R (--image-dir) to specify image directory.
-Use -U (--update-all) to proceed with Updates"""
- sys.exit(0)
- elif option == "--allow-links":
- allow_links = True
- elif option in ("-R", "--image-dir"):
- image_dir = argument
- elif option in ("-U", "--update-all"):
- update_all_proceed = True
- elif option in ("-i", "--info-install"):
- info_install_arg = argument
-
- provided_image_dir = True
- if image_dir == None:
- image_dir, provided_image_dir = api.get_default_image_root()
-
- if not provided_image_dir:
- print _("Unable to get the image directory")
- sys.exit(1)
-
- try:
- gtk.init_check()
- except RuntimeError, e:
- print _("Unable to initialize gtk")
- print str(e)
- sys.exit(1)
-
- # Setup webinstall
- if info_install_arg or (args and not update_all_proceed):
- webinstall = webinstall.Webinstall(image_dir)
- if args:
- info_install_arg = args[0]
- webinstall.process_param(info_install_arg)
- main()
- sys.exit(0)
-
- # Setup packagemanager
- packagemanager = PackageManager(program_title)
- gblexcepthandler.set_parent(packagemanager)
-
- while gtk.events_pending():
- gtk.main_iteration(False)
- packagemanager.application_path = app_path
- packagemanager.image_directory = image_dir
- packagemanager.allow_links = allow_links
- packagemanager.update_all_proceed = update_all_proceed
- packagemanager.init_show_filter()
-
- gobject.idle_add(packagemanager.start)
-
- main()