28 # - Start phase:
29 # The start phase should be fairly constant at around a few seconds and so is given 5%
30 # of the total progress bar.
31 # - Package entry loading phase:
32 # The package entry loading phase is given the remaining 95% of the bar for progress.
33
34 INITIAL_PROGRESS_TIME_INTERVAL = 0.5 # Time to update progress during start phase
35 INITIAL_PROGRESS_TIME_PERCENTAGE = 0.005 # Amount to update progress during start phase
36 INITIAL_PROGRESS_TOTAL_PERCENTAGE = 0.05 # Total progress for start phase
37 PACKAGE_PROGRESS_TOTAL_INCREMENTS = 95 # Total increments for loading phase
38 PACKAGE_PROGRESS_PERCENT_INCREMENT = 0.01 # Amount to update progress during loading phase
39 PACKAGE_PROGRESS_PERCENT_TOTAL = 1.0 # Total progress for loading phase
40 MAX_DESC_LEN = 60 # Max length of the description
41 MAX_INFO_CACHE_LIMIT = 100 # Max number of package descriptions to cache
42 NOTEBOOK_PACKAGE_LIST_PAGE = 0 # Main Package List page index
43 NOTEBOOK_START_PAGE = 1 # Main View Start page index
44 INFO_NOTEBOOK_LICENSE_PAGE = 3 # License Tab index
45 SHOW_INFO_DELAY = 600 # Delay before showing selected pacakge information
46 SHOW_LICENSE_DELAY = 600 # Delay before showing license information
47 SEARCH_STR_FORMAT = "<%s>"
48 SEARCH_LIMIT = 100 # Maximum number of results shown for
49 # api search
50 MIN_APP_WIDTH = 750 # Minimum application width
51 MIN_APP_HEIGHT = 500 # Minimum application height
52 INITIAL_APP_WIDTH_PREFERENCES = "/apps/packagemanager/preferences/initial_app_width"
53 INITIAL_APP_HEIGHT_PREFERENCES = "/apps/packagemanager/preferences/initial_app_height"
54 INITIAL_APP_HPOS_PREFERENCES = "/apps/packagemanager/preferences/initial_app_hposition"
55 INITIAL_APP_VPOS_PREFERENCES = "/apps/packagemanager/preferences/initial_app_vposition"
56 INITIAL_SHOW_FILTER_PREFERENCES = "/apps/packagemanager/preferences/initial_show_filter"
57 INITIAL_SECTION_PREFERENCES = "/apps/packagemanager/preferences/initial_section"
58 SHOW_STARTPAGE_PREFERENCES = "/apps/packagemanager/preferences/show_startpage"
59 API_SEARCH_ERROR_PREFERENCES = "/apps/packagemanager/preferences/api_search_error"
60 CATEGORIES_STATUS_COLUMN_INDEX = 0 # Index of Status Column in Categories TreeView
61
62 STATUS_COLUMN_INDEX = 2 # Index of Status Column in Application TreeView
63
64 PKG_CLIENT_NAME = "packagemanager"
65
66 # Location for themable icons
67 ICON_LOCATION = "usr/share/package-manager/icons"
68 # Load Start Page from lang dir if available
69 START_PAGE_CACHE_LANG_BASE = "var/pkg/gui_cache/startpagebase/%s/%s"
253 self.categories_status_id = 0
254 self.icon_theme = gtk.IconTheme()
255 icon_location = os.path.join(self.application_dir, ICON_LOCATION)
256 self.icon_theme.append_search_path(icon_location)
257 self.search_options = [
258 ('ips-search',
259 gui_misc.get_icon(self.icon_theme, 'search', 20),
260 _("_Current Repository"),
261 _("Search Current Repository")),
262 ('ips-search-all',
263 gui_misc.get_icon(self.icon_theme, 'search_all', 20),
264 _("_All Repositories"),
265 _("Search All Repositories"))
266 ]
267 self.__register_iconsets(self.search_options)
268 self.visible_repository = None
269 self.visible_repository_uptodate = False
270 self.last_active_publisher = None
271 self.search_start = 0
272 self.search_time_sec = 0
273 self.section_list = None
274 self.filter_list = self.__get_new_filter_liststore()
275 self.application_list = None
276 self.a11y_application_treeview = None
277 self.a11y_categories_treeview = None
278 self.application_treeview_range = None
279 self.application_treeview_initialized = False
280 self.categories_treeview_range = None
281 self.categories_treeview_initialized = False
282 self.category_list = None
283 self.repositories_list = None
284 self.pr = progress.NullProgressTracker()
285 self.pylintstub = None
286 self.release_notes_url = "http://www.opensolaris.org"
287 self.__image_activity_lock = Lock()
288
289 # Create Widgets and show gui
290 self.gladefile = os.path.join(self.application_dir,
291 "usr/share/package-manager/packagemanager.glade")
292 w_tree_main = gtk.glade.XML(self.gladefile, "mainwindow")
745 start_page_lang_base % (self.lang_root, START_PAGE_HOME))
746 if self.__load_uri(self.document, start_page_url):
747 return True
748
749 start_page_url = os.path.join(self.application_dir,
750 start_page_lang_base % ("C", START_PAGE_HOME))
751 if self.__load_uri(self.document, start_page_url):
752 return True
753 return False
754
755 def __handle_startpage_load_error(self, start_page_url):
756 self.document.open_stream('text/html')
757 self.document.write_stream(_(
758 "<html><head></head><body><H2>Welcome to"
759 "PackageManager!</H2><br>"
760 "<font color='#0000FF'>Warning: Unable to "
761 "load Start Page:<br>%s</font></body></html>"
762 % (start_page_url)))
763 self.document.close_stream()
764
765 def __parse_api_search_error(self, error):
766 self.current_repos_with_search_errors = []
767 if "failed_servers" in error.__dict__ and len(error.failed_servers) > 0:
768 #TBD we should not have to parse the error output
769 rem_str = " doesn't speak a known version of search operation"
770 timeout_str = "urlopen error timed out"
771 repos = []
772 for err in error.failed_servers:
773 err_str = str(err[1])
774 if rem_str in err_str:
775 repo = err_str.replace(rem_str,"")
776 self.current_repos_with_search_errors.append(repo)
777 elif timeout_str in err_str:
778 repo = err[0].repositories[0].origins[0].uri
779 self.current_repos_with_search_errors.append(repo)
780
781 def __on_infosearch_button_clicked(self, widget):
782 self.__handle_api_search_error(True)
783
784 def __handle_api_search_error(self, show_all=False):
785 if len(self.current_repos_with_search_errors) == 0:
786 self.w_infosearch_frame.hide()
787 return
788 else:
789 self.w_infosearch_button.set_size_request(26, 22)
790 self.w_infosearch_frame.show()
791
792 repo_pubs = self.__get_repo_publishers()
793 repo_count = 0
794 for url in self.current_repos_with_search_errors:
795 if show_all or (url not in self.gconf_not_show_repos):
796 repo_count += 1
797 if repo_count == 0:
798 return
799
800 infobuffer = self.api_search_error_textview.get_buffer()
801 infobuffer.set_text("")
802 textiter = infobuffer.get_end_iter()
803 for url in self.current_repos_with_search_errors:
804 if show_all or (url not in self.gconf_not_show_repos):
805 infobuffer.insert_with_tags_by_name(textiter,
806 "%s" % repo_pubs[url], "bold")
807 infobuffer.insert(textiter, " (%s)\n" % url)
808 self.api_search_checkbox.set_active(False)
809 self.api_search_error_dialog.show()
810 self.api_search_button.grab_focus()
811
812 def __get_repo_publishers(self):
813 repo_pub_dict = {}
814 pubs = self.api_o.get_publishers()
815 for pub in pubs:
816 repo = pub.selected_repository
817 origin = repo.origins[0]
818 repo_pub_dict[origin.uri] = pub.prefix
819 return repo_pub_dict
820
821 def __on_url(self, view, link):
822 # Handle mouse over events on links and reset when not on link
823 if link == None or link == "":
824 self.update_statusbar()
825 else:
826 display_link = self.__handle_link(None, link, DISPLAY_LINK)
827 if display_link != None:
1023 application_list_sort = \
1024 gtk.TreeModelSort(application_list_filter)
1025 application_list_sort.set_sort_column_id(
1026 enumerations.NAME_COLUMN, gtk.SORT_ASCENDING)
1027 application_list_sort.set_sort_func(
1028 enumerations.STATUS_ICON_COLUMN, self.__status_sort_func)
1029 toggle_renderer = gtk.CellRendererToggle()
1030
1031 column = gtk.TreeViewColumn("", toggle_renderer, \
1032 active = enumerations.MARK_COLUMN)
1033 column.set_sort_column_id(enumerations.MARK_COLUMN)
1034 column.set_sort_indicator(True)
1035 column.set_cell_data_func(toggle_renderer, self.cell_data_function, None)
1036 column.connect_after('clicked',
1037 self.__application_treeview_column_sorted, None)
1038 self.w_application_treeview.append_column(column)
1039 name_renderer = gtk.CellRendererText()
1040 column = gtk.TreeViewColumn(_("Name"), name_renderer,
1041 text = enumerations.NAME_COLUMN)
1042 column.set_resizable(True)
1043 column.set_sort_column_id(enumerations.NAME_COLUMN)
1044 column.set_sort_indicator(True)
1045 column.set_cell_data_func(name_renderer, self.cell_data_function, None)
1046 column.connect_after('clicked',
1047 self.__application_treeview_column_sorted, None)
1048 self.w_application_treeview.append_column(column)
1049 column = self.__create_icon_column(_("Status"), True,
1050 enumerations.STATUS_ICON_COLUMN, True)
1051 column.set_sort_column_id(enumerations.STATUS_ICON_COLUMN)
1052 column.set_sort_indicator(True)
1053 column.connect_after('clicked',
1054 self.__application_treeview_column_sorted, None)
1055 self.w_application_treeview.append_column(column)
1056 if self.is_search_all:
1057 repository_renderer = gtk.CellRendererText()
1058 column = gtk.TreeViewColumn(_('Repository'),
1059 repository_renderer,
1060 text = enumerations.AUTHORITY_COLUMN)
1061 column.set_sort_column_id(enumerations.AUTHORITY_COLUMN)
1062 column.set_resizable(True)
1299 status = model.get_value(itr, enumerations.STATUS_COLUMN)
1300 if status == enumerations.INSTALLED:
1301 desc = _("Installed")
1302 elif status == enumerations.NOT_INSTALLED:
1303 desc = _("Not Installed")
1304 elif status == enumerations.UPDATABLE:
1305 desc = _("Updates Available")
1306 else:
1307 desc = None
1308 if desc != None:
1309 obj = self.a11y_application_treeview.ref_at(
1310 int(model.get_string_from_iter(itr)),
1311 STATUS_COLUMN_INDEX)
1312 obj.set_image_description(desc)
1313
1314 def __set_visible_status(self, check_range = True):
1315 self.visible_status_id = 0
1316 if self.w_main_view_notebook.get_current_page() != \
1317 NOTEBOOK_PACKAGE_LIST_PAGE:
1318 return
1319 a11y_enabled = False
1320 if self.a11y_application_treeview.get_n_accessible_children() != 0:
1321 a11y_enabled = True
1322
1323 visible_range = self.w_application_treeview.get_visible_range()
1324 if visible_range == None:
1325 return
1326 start = visible_range[0][0]
1327 end = visible_range[1][0]
1328 if debug_descriptions:
1329 print "Range Start: %d End: %d" % (start, end)
1330
1331 # Switching Publishers need to use default range
1332 active_pub = self.__get_active_publisher()
1333 if self.last_active_publisher != active_pub:
1334 check_range = False
1335 self.last_active_publisher = active_pub
1336 if self.in_search_mode:
1337 check_range = False
1338
1355 self.application_treeview_range = visible_range
1356
1357 sort_filt_model = \
1358 self.w_application_treeview.get_model() #gtk.TreeModelSort
1359 filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
1360 model = filt_model.get_model() #gtk.ListStore
1361 sf_itr = sort_filt_model.get_iter_from_string(str(start))
1362 pkg_stems_and_itr_to_fetch = {}
1363 while start <= end:
1364 filtered_itr = sort_filt_model.convert_iter_to_child_iter(None,
1365 sf_itr)
1366 app_itr = filt_model.convert_iter_to_child_iter(filtered_itr)
1367
1368 desc = sort_filt_model.get_value(sf_itr,
1369 enumerations.DESCRIPTION_COLUMN)
1370 # Only Fetch description for packages without a
1371 # description
1372 if desc == '...':
1373 fmri = sort_filt_model.get_value(sf_itr,
1374 enumerations.FMRI_COLUMN)
1375 pkg_stem = fmri.get_pkg_stem(
1376 include_scheme = True)
1377 pkg_stems_and_itr_to_fetch[pkg_stem] = \
1378 model.get_string_from_iter(app_itr)
1379 if a11y_enabled:
1380 self.__set_accessible_status(sort_filt_model, sf_itr)
1381 start += 1
1382 sf_itr = sort_filt_model.iter_next(sf_itr)
1383
1384 if debug_descriptions:
1385 print "PKGS to FETCH: \n%s" % pkg_stems_and_itr_to_fetch
1386 if len(pkg_stems_and_itr_to_fetch) > 0:
1387 Thread(target = self.__get_pkg_descriptions,
1388 args = [pkg_stems_and_itr_to_fetch, model]).start()
1389
1390 def __doing_search(self):
1391 return self.search_start > 0
1392
1393 def __get_pkg_descriptions(self, pkg_stems_and_itr_to_fetch, orig_model):
1394 # Note: no need to aquire lock even though this can be called from
1405 except api_errors.TransportError:
1406 self.update_statusbar()
1407 return
1408 if info and len(info.get(0)) == 0:
1409 self.update_statusbar()
1410 return
1411 pkg_infos = info.get(0)
1412 pkg_descriptions_for_update = []
1413 for pkg_info in pkg_infos:
1414 short_fmri = fmri.PkgFmri(pkg_info.fmri).get_pkg_stem(
1415 include_scheme = True)
1416 pkg_descriptions_for_update.append((short_fmri,
1417 pkg_stems_and_itr_to_fetch[short_fmri],
1418 pkg_info.summary))
1419 if debug_descriptions:
1420 print "FETCHED PKGS: \n%s" % pkg_descriptions_for_update
1421 gobject.idle_add(self.__update_description_from_iter,
1422 pkg_descriptions_for_update, orig_model)
1423
1424 def __update_description_from_iter(self, pkg_descriptions_for_update, orig_model):
1425 sort_filt_model = \
1426 self.w_application_treeview.get_model() #gtk.TreeModelSort
1427 filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
1428 model = filt_model.get_model() #gtk.ListStore
1429
1430 #If model has changed abandon description updates
1431 if orig_model != model:
1432 return
1433
1434 if debug_descriptions:
1435 print "UPDATE DESCRIPTIONS: \n%s" % pkg_descriptions_for_update
1436 for pkg_stem, path, summary in pkg_descriptions_for_update:
1437 itr = model.get_iter_from_string(path)
1438 stored_pkg_fmri = model.get_value(itr, enumerations.FMRI_COLUMN)
1439 stored_pkg_stem = stored_pkg_fmri.get_pkg_stem(
1440 include_scheme = True)
1441
1442 if pkg_stem != stored_pkg_stem:
1443 if debug:
1444 print ("__update_description_from_iter(): "
1445 "model not consistent so abandoning "
1446 "these description updates.")
1447 self.update_statusbar()
1448 return
1449 model.set_value(itr, enumerations.DESCRIPTION_COLUMN, summary)
1450 if not self.__doing_search():
1717 self.search_time_sec = 0
1718 text = self.w_searchentry.get_text()
1719 # Here we call the search API to get the results
1720 searches = []
1721 servers = []
1722 result = []
1723 pargs = []
1724 search_str = SEARCH_STR_FORMAT % text
1725 pargs.append(search_str)
1726 if search_all:
1727 servers = None
1728 else:
1729 pub_prefix = self.__get_active_publisher()
1730 if pub_prefix != None:
1731 pub = self.api_o.get_publisher(prefix=pub_prefix)
1732 else:
1733 pub = self.api_o.get_preferred_publisher()
1734 origin_uri = self.__get_origin_uri(pub.selected_repository)
1735 servers.append({"origin": origin_uri})
1736 if debug:
1737 print "pargs:", pargs
1738 print "servers:", servers
1739
1740 case_sensitive = False
1741 searches.append(self.api_o.remote_search(
1742 [api.Query(" ".join(pargs), case_sensitive, True, None, None)],
1743 servers=servers))
1744 result_tuple = {}
1745 try:
1746 for query_num, publisher, (v, return_type, tmp) in \
1747 itertools.chain(*searches):
1748 if v == 1 and \
1749 return_type == api.Query.RETURN_PACKAGES:
1750 repo = None
1751 if publisher is not None \
1752 and "prefix" in publisher:
1753 repo = publisher["prefix"]
1754 name = fmri.PkgFmri(str(tmp)).get_name()
1755 result_tuple[(name, repo)] = -1
1756 if len(result_tuple) == SEARCH_LIMIT:
1757 break
1758 else:
1759 # We are not interested in this error
1760 gobject.idle_add(self.w_progress_dialog.hide)
1761 self.__process_after_search_failure()
1762 return
1763 self.pylintstub = query_num
1764 except api_errors.ProblematicSearchServers, ex:
1765 self.__parse_api_search_error(ex)
1766 gobject.idle_add(self.w_progress_dialog.hide)
1767 gobject.idle_add(self.__handle_api_search_error)
1768 if len(result_tuple) == 0:
1769 self.__process_after_search_with_zero_results()
1770 return
1771 except Exception, ex:
1772 # We are not interested in this error
1773 gobject.idle_add(self.w_progress_dialog.hide)
1774 self.__process_after_search_failure()
1775 return
1776 if debug:
1777 print "Number of search results:", len(result_tuple)
1778 for name, repo in result_tuple:
1779 a_res = name, repo
1780 result.append(a_res)
1781 if len(result) == 0:
1782 if debug:
1783 print "No search results"
1784 self.__process_after_search_with_zero_results()
1785 return
1786 # We cannot get status of the packages if catalogs have not
1787 # been loaded so we pause for up to 5 seconds here to
1788 # allow catalogs to be loaded
1789 times = 5
1790 while self.catalog_loaded == False:
1791 if times == 0:
1792 break
1793 time.sleep(1)
1794 times -= 1
1795 self.in_setup = True
1796 application_list = self.__get_list_from_search(result)
1797 if self.search_start > 0:
1798 self.search_time_sec = int(time.time() - self.search_start)
1799 self.search_start = 0
1800 gobject.idle_add(self.__set_empty_details_panel)
1801 gobject.idle_add(self.__set_main_view_package_list)
1802 gobject.idle_add(self.__init_tree_views, application_list,
1803 None, None)
1804
1805 def __process_after_search_with_zero_results(self):
1806 if self.search_start > 0:
1807 self.search_time_sec = int(time.time() - self.search_start)
1808 self.search_start = 0
1809 self.in_setup = True
1810 application_list = self.__get_new_application_liststore()
1811 gobject.idle_add(self.__set_empty_details_panel)
1812 gobject.idle_add(self.__set_main_view_package_list)
1813 gobject.idle_add(self.__init_tree_views, application_list, None, None)
1814
1815 def __get_list_from_search(self, search_result):
1816 application_list = self.__get_new_application_liststore()
1817 self.__add_pkgs_to_list_from_search(search_result,
1818 application_list)
1819 return application_list
1820
1821 def __add_pkgs_to_list_from_search(self, search_result,
1822 application_list):
1823 pargs = []
1824 default_pub = self.api_o.get_preferred_publisher().prefix
1825 for name, publisher in search_result:
1826 pargs.append("pkg://" + publisher + "/" + name)
1827 # We now need to get the status for each package
1828 if debug_descriptions:
1829 print "pargs:", pargs
1830 try:
1831 pkgs_known = self.__get_inventory_list(pargs,
1832 True, True)
1833 except api_errors.InventoryException:
1834 # This can happen if load_catalogs has not been run
1835 err = _("Unable to get status for search results.\n"
1836 "The catalogs have not been loaded.\n"
2063 self.w_preferencesdialog.show()
2064
2065 def __on_preferencesclose_clicked(self, widget):
2066 self.w_preferencesdialog.hide()
2067
2068 def __on_preferenceshelp_clicked(self, widget):
2069 gui_misc.display_help(self.application_dir, "pm_win")
2070
2071 def __on_startpage_checkbutton_toggled(self, widget):
2072 self.show_startpage = self.w_startpage_checkbutton.get_active()
2073 try:
2074 self.client.set_bool(SHOW_STARTPAGE_PREFERENCES,
2075 self.show_startpage)
2076 except GError:
2077 pass
2078
2079 def __on_api_search_checkbox_toggled(self, widget):
2080 active = self.api_search_checkbox.get_active()
2081 if len(self.current_repos_with_search_errors) > 0:
2082 if active:
2083 for url in self.current_repos_with_search_errors:
2084 if url not in self.gconf_not_show_repos:
2085 self.gconf_not_show_repos += url + ","
2086 else:
2087 for url in self.current_repos_with_search_errors:
2088 self.gconf_not_show_repos = \
2089 self.gconf_not_show_repos.replace(
2090 url + ",", "")
2091 try:
2092 self.client.set_string(API_SEARCH_ERROR_PREFERENCES,
2093 self.gconf_not_show_repos)
2094 except GError:
2095 pass
2096
2097 def __on_searchentry_focus_in(self, widget, event):
2098 if self.w_main_clipboard.wait_is_text_available():
2099 self.w_paste_menuitem.set_sensitive(True)
2100 char_count = widget.get_text_length()
2101 if char_count > 0:
2102 self.w_selectall_menuitem.set_sensitive(True)
2103 else:
2104 self.w_selectall_menuitem.set_sensitive(False)
2105 bounds = widget.get_selection_bounds()
2106 if bounds:
2107 offset1 = bounds[0]
2108 offset2 = bounds[1]
2109 if abs(offset2 - offset1) == char_count:
2110 self.w_selectall_menuitem.set_sensitive(False)
2411 start, end = self.w_searchentry.get_selection_bounds()
2412 self.w_searchentry.select_region(end, end)
2413
2414 pub = [active_publisher, ]
2415 self.set_show_filter = self.initial_show_filter
2416 self.set_section = self.initial_section
2417 Thread(target = self.__setup_publisher, args = [pub]).start()
2418 self.__set_main_view_package_list()
2419
2420 def __get_active_publisher(self):
2421 pub_iter = self.w_repository_combobox.get_active_iter()
2422 if pub_iter == None:
2423 return None
2424 return self.repositories_list.get_value(pub_iter, \
2425 enumerations.REPOSITORY_NAME)
2426
2427 def __setup_publisher(self, publishers=[]):
2428 self.saved_filter_combobox_active = self.initial_show_filter
2429 application_list, category_list , section_list = \
2430 self.__get_application_categories_lists(publishers)
2431 gobject.idle_add(self.__init_tree_views, application_list,
2432 category_list, section_list)
2433
2434 def __get_application_categories_lists(self, publishers=[]):
2435 if not self.visible_repository:
2436 self.visible_repository = self.__get_active_publisher()
2437 application_list = self.__get_new_application_liststore()
2438 category_list = self.__get_new_category_liststore()
2439 section_list = self.__get_new_section_liststore()
2440 first_loop = True
2441 for publisher in publishers:
2442 uptodate = False
2443 try:
2444 uptodate = self.__check_if_cache_uptodate(publisher)
2445 if uptodate:
2446 self.__add_pkgs_to_lists_from_cache(publisher,
2447 application_list, category_list,
2448 section_list)
2449 except (UnpicklingError, EOFError, IOError):
2450 #Most likely cache is corrupted, silently load list
2451 #from api.
2452 application_list = self.__get_new_application_liststore()
2453 category_list = self.__get_new_category_liststore()
2454 uptodate = False
2455 if not uptodate:
2456 if first_loop == True:
2457 first_loop = False
2458 gobject.idle_add(self.setup_progressdialog_show)
2459 self.api_o.refresh(pubs=[publisher])
2460 self.__add_pkgs_to_lists_from_api(publisher,
2461 application_list, category_list, section_list)
2462 category_list.prepend([0, _('All'), None, None, False,
2463 True, None])
2464 if self.application_list and self.category_list and \
2465 not self.visible_repository_uptodate:
2466 if self.visible_repository:
2467 self.__dump_datamodels(self.visible_repository,
2468 self.application_list, self.category_list,
2469 self.section_list)
2470 self.visible_repository = self.__get_active_publisher()
2471 self.visible_repository_uptodate = uptodate
2472 return application_list, category_list, section_list
2473
2474 def __check_if_cache_uptodate(self, publisher):
2475 if self.cache_o:
2476 return self.cache_o.check_if_cache_uptodate(publisher)
2477 return False
2478
2479 def __dump_datamodels(self, publisher, application_list, category_list,
2480 section_list):
2481 if self.cache_o:
2482 if self.img_timestamp == \
2483 self.cache_o.get_index_timestamp():
2484 Thread(target = self.cache_o.dump_datamodels,
2485 args = (publisher, application_list, category_list,
2486 section_list)).start()
2487 else:
2488 self.__remove_cache()
2489
2490 def __remove_cache(self):
2491 model = self.w_repository_combobox.get_model()
2492 for publisher in model:
2493 pub_name = publisher[1]
2494 if pub_name and pub_name != _("Add..."):
2495 Thread(target = self.cache_o.remove_datamodel,
2496 args = [publisher[1]]).start()
2497
2498 def __on_install_update(self, widget):
2499 self.api_o.reset()
2500 install_update = []
3793 self.set_show_filter != enumerations.FILTER_ALL:
3794 self.__application_refilter()
3795 else:
3796 self.unset_busy_cursor()
3797
3798 if self.first_run or self.in_reload:
3799 Thread(target = self.__enable_disable_update_all).start()
3800 self.first_run = False
3801 self.in_reload = False
3802
3803 def get_icon_pixbuf_from_glade_dir(self, icon_name):
3804 return gui_misc.get_pixbuf_from_path(self.application_dir +
3805 "/usr/share/package-manager/", icon_name)
3806
3807 def update_statusbar(self):
3808 '''Function which updates statusbar'''
3809 if self.statusbar_message_id > 0:
3810 self.w_main_statusbar.remove(0, self.statusbar_message_id)
3811 self.statusbar_message_id = 0
3812 search_text = self.w_searchentry.get_text()
3813 if self.in_search_mode:
3814 if self.is_search_all:
3815 opt_str = _('Searched All for "%s"') % (search_text)
3816 else:
3817 opt_str = \
3818 _('Searched %(last_active)s '
3819 'for "%(search_text)s"') \
3820 % {"last_active" : self.last_active_publisher,
3821 "search_text" : search_text}
3822 if len(self.application_list) == SEARCH_LIMIT:
3823 fmt_str = _("%(option_str)s: first %(number)d "
3824 "found %(time)s")
3825 else:
3826 fmt_str = _("%(option_str)s: %(number)d found %(time)s")
3827 time_str = ""
3828 if self.search_time_sec > 0:
3829 time_str = _("in %d seconds") % self.search_time_sec
3830 status_str = fmt_str % {"option_str" : opt_str,
3831 "number" : len(self.application_list), "time" : time_str}
3832 self.w_main_statusbar.push(0, status_str)
3833 return
3834 installed = 0
3835 self.selected = 0
3836 sel = 0
3837 if self.application_list == None:
3838 return
3839 visible_repository = self.__get_visible_repository_name()
3840 pkgs = self.selected_pkgs.get(visible_repository)
3841 if pkgs:
3842 self.selected = len(pkgs)
3843 for pkg_row in self.application_list:
3844 if pkg_row[enumerations.STATUS_COLUMN] == enumerations.INSTALLED \
3845 or pkg_row[enumerations.STATUS_COLUMN] == \
3846 enumerations.UPDATABLE:
3847 installed = installed + 1
3848 if pkg_row[enumerations.MARK_COLUMN]:
3849 sel = sel + 1
3850 listed_str = _('%d listed') % len(self.application_list)
3851 sel_str = _('%d selected') % sel
3852 inst_str = _('%d installed') % installed
3853 status_str = _("%s: %s , %s, %s.") % (visible_repository, listed_str,
3854 inst_str, sel_str)
3855 self.w_main_statusbar.push(0, status_str)
3856
3857 def update_package_list(self, update_list):
3858 if update_list == None and self.img_timestamp:
3859 return
3860 visible_repository = self.__get_visible_repository_name()
3861 default_publisher = self.default_publisher
3862 self.api_o.refresh()
3863 if not self.img_timestamp:
3864 self.img_timestamp = self.cache_o.get_index_timestamp()
3865 self.__on_reload(None)
3866 return
3867 self.img_timestamp = self.cache_o.get_index_timestamp()
3868 installed_icon = gui_misc.get_icon(self.icon_theme,
3869 "status_installed")
3870 visible_list = update_list.get(visible_repository)
3871 if visible_list:
3872 i = 0
3873 while i < len(visible_list):
3874 visible_list[i] = gui_misc.get_pkg_name(
3875 visible_list[i])
3876 i += 1
|
28 # - Start phase:
29 # The start phase should be fairly constant at around a few seconds and so is given 5%
30 # of the total progress bar.
31 # - Package entry loading phase:
32 # The package entry loading phase is given the remaining 95% of the bar for progress.
33
34 INITIAL_PROGRESS_TIME_INTERVAL = 0.5 # Time to update progress during start phase
35 INITIAL_PROGRESS_TIME_PERCENTAGE = 0.005 # Amount to update progress during start phase
36 INITIAL_PROGRESS_TOTAL_PERCENTAGE = 0.05 # Total progress for start phase
37 PACKAGE_PROGRESS_TOTAL_INCREMENTS = 95 # Total increments for loading phase
38 PACKAGE_PROGRESS_PERCENT_INCREMENT = 0.01 # Amount to update progress during loading phase
39 PACKAGE_PROGRESS_PERCENT_TOTAL = 1.0 # Total progress for loading phase
40 MAX_DESC_LEN = 60 # Max length of the description
41 MAX_INFO_CACHE_LIMIT = 100 # Max number of package descriptions to cache
42 NOTEBOOK_PACKAGE_LIST_PAGE = 0 # Main Package List page index
43 NOTEBOOK_START_PAGE = 1 # Main View Start page index
44 INFO_NOTEBOOK_LICENSE_PAGE = 3 # License Tab index
45 SHOW_INFO_DELAY = 600 # Delay before showing selected pacakge information
46 SHOW_LICENSE_DELAY = 600 # Delay before showing license information
47 SEARCH_STR_FORMAT = "<%s>"
48 MIN_APP_WIDTH = 750 # Minimum application width
49 MIN_APP_HEIGHT = 500 # Minimum application height
50 INITIAL_APP_WIDTH_PREFERENCES = "/apps/packagemanager/preferences/initial_app_width"
51 INITIAL_APP_HEIGHT_PREFERENCES = "/apps/packagemanager/preferences/initial_app_height"
52 INITIAL_APP_HPOS_PREFERENCES = "/apps/packagemanager/preferences/initial_app_hposition"
53 INITIAL_APP_VPOS_PREFERENCES = "/apps/packagemanager/preferences/initial_app_vposition"
54 INITIAL_SHOW_FILTER_PREFERENCES = "/apps/packagemanager/preferences/initial_show_filter"
55 INITIAL_SECTION_PREFERENCES = "/apps/packagemanager/preferences/initial_section"
56 SHOW_STARTPAGE_PREFERENCES = "/apps/packagemanager/preferences/show_startpage"
57 API_SEARCH_ERROR_PREFERENCES = "/apps/packagemanager/preferences/api_search_error"
58 CATEGORIES_STATUS_COLUMN_INDEX = 0 # Index of Status Column in Categories TreeView
59
60 STATUS_COLUMN_INDEX = 2 # Index of Status Column in Application TreeView
61
62 PKG_CLIENT_NAME = "packagemanager"
63
64 # Location for themable icons
65 ICON_LOCATION = "usr/share/package-manager/icons"
66 # Load Start Page from lang dir if available
67 START_PAGE_CACHE_LANG_BASE = "var/pkg/gui_cache/startpagebase/%s/%s"
251 self.categories_status_id = 0
252 self.icon_theme = gtk.IconTheme()
253 icon_location = os.path.join(self.application_dir, ICON_LOCATION)
254 self.icon_theme.append_search_path(icon_location)
255 self.search_options = [
256 ('ips-search',
257 gui_misc.get_icon(self.icon_theme, 'search', 20),
258 _("_Current Repository"),
259 _("Search Current Repository")),
260 ('ips-search-all',
261 gui_misc.get_icon(self.icon_theme, 'search_all', 20),
262 _("_All Repositories"),
263 _("Search All Repositories"))
264 ]
265 self.__register_iconsets(self.search_options)
266 self.visible_repository = None
267 self.visible_repository_uptodate = False
268 self.last_active_publisher = None
269 self.search_start = 0
270 self.search_time_sec = 0
271 self.current_search_publisher = None
272 self.section_list = None
273 self.filter_list = self.__get_new_filter_liststore()
274 self.application_list = None
275 self.a11y_application_treeview = None
276 self.a11y_categories_treeview = None
277 self.application_treeview_range = None
278 self.application_treeview_initialized = False
279 self.categories_treeview_range = None
280 self.categories_treeview_initialized = False
281 self.category_list = None
282 self.repositories_list = None
283 self.pr = progress.NullProgressTracker()
284 self.pylintstub = None
285 self.release_notes_url = "http://www.opensolaris.org"
286 self.__image_activity_lock = Lock()
287
288 # Create Widgets and show gui
289 self.gladefile = os.path.join(self.application_dir,
290 "usr/share/package-manager/packagemanager.glade")
291 w_tree_main = gtk.glade.XML(self.gladefile, "mainwindow")
744 start_page_lang_base % (self.lang_root, START_PAGE_HOME))
745 if self.__load_uri(self.document, start_page_url):
746 return True
747
748 start_page_url = os.path.join(self.application_dir,
749 start_page_lang_base % ("C", START_PAGE_HOME))
750 if self.__load_uri(self.document, start_page_url):
751 return True
752 return False
753
754 def __handle_startpage_load_error(self, start_page_url):
755 self.document.open_stream('text/html')
756 self.document.write_stream(_(
757 "<html><head></head><body><H2>Welcome to"
758 "PackageManager!</H2><br>"
759 "<font color='#0000FF'>Warning: Unable to "
760 "load Start Page:<br>%s</font></body></html>"
761 % (start_page_url)))
762 self.document.close_stream()
763
764 def __process_api_search_error(self, error):
765 self.current_repos_with_search_errors = []
766
767 for pub, err in error.failed_servers:
768 self.current_repos_with_search_errors.append(
769 (pub, _("failed to respond"), err))
770 for pub in error.invalid_servers:
771 self.current_repos_with_search_errors.append(
772 (pub, _("invalid response"),
773 _("A valid response was not returned.")))
774 for pub, err in error.unsupported_servers:
775 self.current_repos_with_search_errors.append(
776 (pub, _("unsupported search"), err))
777
778 def __on_infosearch_button_clicked(self, widget):
779 self.__handle_api_search_error(True)
780
781 def __handle_api_search_error(self, show_all=False):
782 if len(self.current_repos_with_search_errors) == 0:
783 self.w_infosearch_frame.hide()
784 return
785
786 repo_count = 0
787 for pub, err_type, err_str in self.current_repos_with_search_errors:
788 if show_all or (pub not in self.gconf_not_show_repos):
789 repo_count += 1
790 if repo_count == 0:
791 self.w_infosearch_frame.hide()
792 return
793
794 self.w_infosearch_button.set_size_request(26, 22)
795 self.w_infosearch_frame.show()
796 infobuffer = self.api_search_error_textview.get_buffer()
797 infobuffer.set_text("")
798 textiter = infobuffer.get_end_iter()
799 for pub, err_type, err_str in self.current_repos_with_search_errors:
800
801 if show_all or (pub not in self.gconf_not_show_repos):
802 infobuffer.insert_with_tags_by_name(textiter,
803 "%(pub)s (%(err_type)s)\n" % {"pub": pub,
804 "err_type": err_type}, "bold")
805 infobuffer.insert(textiter, "%s\n" % (err_str))
806
807 self.api_search_checkbox.set_active(False)
808 self.api_search_error_dialog.show()
809 self.api_search_button.grab_focus()
810
811 def __get_repo_publishers(self):
812 repo_pub_dict = {}
813 pubs = self.api_o.get_publishers()
814 for pub in pubs:
815 repo = pub.selected_repository
816 origin = repo.origins[0]
817 repo_pub_dict[origin.uri] = pub.prefix
818 return repo_pub_dict
819
820 def __on_url(self, view, link):
821 # Handle mouse over events on links and reset when not on link
822 if link == None or link == "":
823 self.update_statusbar()
824 else:
825 display_link = self.__handle_link(None, link, DISPLAY_LINK)
826 if display_link != None:
1022 application_list_sort = \
1023 gtk.TreeModelSort(application_list_filter)
1024 application_list_sort.set_sort_column_id(
1025 enumerations.NAME_COLUMN, gtk.SORT_ASCENDING)
1026 application_list_sort.set_sort_func(
1027 enumerations.STATUS_ICON_COLUMN, self.__status_sort_func)
1028 toggle_renderer = gtk.CellRendererToggle()
1029
1030 column = gtk.TreeViewColumn("", toggle_renderer, \
1031 active = enumerations.MARK_COLUMN)
1032 column.set_sort_column_id(enumerations.MARK_COLUMN)
1033 column.set_sort_indicator(True)
1034 column.set_cell_data_func(toggle_renderer, self.cell_data_function, None)
1035 column.connect_after('clicked',
1036 self.__application_treeview_column_sorted, None)
1037 self.w_application_treeview.append_column(column)
1038 name_renderer = gtk.CellRendererText()
1039 column = gtk.TreeViewColumn(_("Name"), name_renderer,
1040 text = enumerations.NAME_COLUMN)
1041 column.set_resizable(True)
1042 column.set_min_width(150)
1043 column.set_sort_column_id(enumerations.NAME_COLUMN)
1044 column.set_sort_indicator(True)
1045 column.set_cell_data_func(name_renderer, self.cell_data_function, None)
1046 column.connect_after('clicked',
1047 self.__application_treeview_column_sorted, None)
1048 self.w_application_treeview.append_column(column)
1049 column = self.__create_icon_column(_("Status"), True,
1050 enumerations.STATUS_ICON_COLUMN, True)
1051 column.set_sort_column_id(enumerations.STATUS_ICON_COLUMN)
1052 column.set_sort_indicator(True)
1053 column.connect_after('clicked',
1054 self.__application_treeview_column_sorted, None)
1055 self.w_application_treeview.append_column(column)
1056 if self.is_search_all:
1057 repository_renderer = gtk.CellRendererText()
1058 column = gtk.TreeViewColumn(_('Repository'),
1059 repository_renderer,
1060 text = enumerations.AUTHORITY_COLUMN)
1061 column.set_sort_column_id(enumerations.AUTHORITY_COLUMN)
1062 column.set_resizable(True)
1299 status = model.get_value(itr, enumerations.STATUS_COLUMN)
1300 if status == enumerations.INSTALLED:
1301 desc = _("Installed")
1302 elif status == enumerations.NOT_INSTALLED:
1303 desc = _("Not Installed")
1304 elif status == enumerations.UPDATABLE:
1305 desc = _("Updates Available")
1306 else:
1307 desc = None
1308 if desc != None:
1309 obj = self.a11y_application_treeview.ref_at(
1310 int(model.get_string_from_iter(itr)),
1311 STATUS_COLUMN_INDEX)
1312 obj.set_image_description(desc)
1313
1314 def __set_visible_status(self, check_range = True):
1315 self.visible_status_id = 0
1316 if self.w_main_view_notebook.get_current_page() != \
1317 NOTEBOOK_PACKAGE_LIST_PAGE:
1318 return
1319 if self.__doing_search():
1320 return
1321
1322 a11y_enabled = False
1323 if self.a11y_application_treeview.get_n_accessible_children() != 0:
1324 a11y_enabled = True
1325
1326 visible_range = self.w_application_treeview.get_visible_range()
1327 if visible_range == None:
1328 return
1329 start = visible_range[0][0]
1330 end = visible_range[1][0]
1331 if debug_descriptions:
1332 print "Range Start: %d End: %d" % (start, end)
1333
1334 # Switching Publishers need to use default range
1335 active_pub = self.__get_active_publisher()
1336 if self.last_active_publisher != active_pub:
1337 check_range = False
1338 self.last_active_publisher = active_pub
1339 if self.in_search_mode:
1340 check_range = False
1341
1358 self.application_treeview_range = visible_range
1359
1360 sort_filt_model = \
1361 self.w_application_treeview.get_model() #gtk.TreeModelSort
1362 filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
1363 model = filt_model.get_model() #gtk.ListStore
1364 sf_itr = sort_filt_model.get_iter_from_string(str(start))
1365 pkg_stems_and_itr_to_fetch = {}
1366 while start <= end:
1367 filtered_itr = sort_filt_model.convert_iter_to_child_iter(None,
1368 sf_itr)
1369 app_itr = filt_model.convert_iter_to_child_iter(filtered_itr)
1370
1371 desc = sort_filt_model.get_value(sf_itr,
1372 enumerations.DESCRIPTION_COLUMN)
1373 # Only Fetch description for packages without a
1374 # description
1375 if desc == '...':
1376 fmri = sort_filt_model.get_value(sf_itr,
1377 enumerations.FMRI_COLUMN)
1378 if fmri != None:
1379 pkg_stem = fmri.get_pkg_stem(
1380 include_scheme = True)
1381 pkg_stems_and_itr_to_fetch[pkg_stem] = \
1382 model.get_string_from_iter(app_itr)
1383 if a11y_enabled:
1384 self.__set_accessible_status(sort_filt_model, sf_itr)
1385 start += 1
1386 sf_itr = sort_filt_model.iter_next(sf_itr)
1387
1388 if debug_descriptions:
1389 print "PKGS to FETCH: \n%s" % pkg_stems_and_itr_to_fetch
1390 if len(pkg_stems_and_itr_to_fetch) > 0:
1391 Thread(target = self.__get_pkg_descriptions,
1392 args = [pkg_stems_and_itr_to_fetch, model]).start()
1393
1394 def __doing_search(self):
1395 return self.search_start > 0
1396
1397 def __get_pkg_descriptions(self, pkg_stems_and_itr_to_fetch, orig_model):
1398 # Note: no need to aquire lock even though this can be called from
1409 except api_errors.TransportError:
1410 self.update_statusbar()
1411 return
1412 if info and len(info.get(0)) == 0:
1413 self.update_statusbar()
1414 return
1415 pkg_infos = info.get(0)
1416 pkg_descriptions_for_update = []
1417 for pkg_info in pkg_infos:
1418 short_fmri = fmri.PkgFmri(pkg_info.fmri).get_pkg_stem(
1419 include_scheme = True)
1420 pkg_descriptions_for_update.append((short_fmri,
1421 pkg_stems_and_itr_to_fetch[short_fmri],
1422 pkg_info.summary))
1423 if debug_descriptions:
1424 print "FETCHED PKGS: \n%s" % pkg_descriptions_for_update
1425 gobject.idle_add(self.__update_description_from_iter,
1426 pkg_descriptions_for_update, orig_model)
1427
1428 def __update_description_from_iter(self, pkg_descriptions_for_update, orig_model):
1429 #If doing a search abandon description updates
1430 if self.__doing_search():
1431 return
1432
1433 sort_filt_model = \
1434 self.w_application_treeview.get_model() #gtk.TreeModelSort
1435 filt_model = sort_filt_model.get_model() #gtk.TreeModelFilter
1436 model = filt_model.get_model() #gtk.ListStore
1437
1438 #If model has changed
1439 if orig_model != model:
1440 return
1441
1442 if debug_descriptions:
1443 print "UPDATE DESCRIPTIONS: \n%s" % pkg_descriptions_for_update
1444 for pkg_stem, path, summary in pkg_descriptions_for_update:
1445 itr = model.get_iter_from_string(path)
1446 stored_pkg_fmri = model.get_value(itr, enumerations.FMRI_COLUMN)
1447 stored_pkg_stem = stored_pkg_fmri.get_pkg_stem(
1448 include_scheme = True)
1449
1450 if pkg_stem != stored_pkg_stem:
1451 if debug:
1452 print ("__update_description_from_iter(): "
1453 "model not consistent so abandoning "
1454 "these description updates.")
1455 self.update_statusbar()
1456 return
1457 model.set_value(itr, enumerations.DESCRIPTION_COLUMN, summary)
1458 if not self.__doing_search():
1725 self.search_time_sec = 0
1726 text = self.w_searchentry.get_text()
1727 # Here we call the search API to get the results
1728 searches = []
1729 servers = []
1730 result = []
1731 pargs = []
1732 search_str = SEARCH_STR_FORMAT % text
1733 pargs.append(search_str)
1734 if search_all:
1735 servers = None
1736 else:
1737 pub_prefix = self.__get_active_publisher()
1738 if pub_prefix != None:
1739 pub = self.api_o.get_publisher(prefix=pub_prefix)
1740 else:
1741 pub = self.api_o.get_preferred_publisher()
1742 origin_uri = self.__get_origin_uri(pub.selected_repository)
1743 servers.append({"origin": origin_uri})
1744 if debug:
1745 print "Search: pargs %s servers: %s" % (pargs, servers)
1746
1747 #TBD If we ever search just Installed pkgs should allow for a local search
1748 case_sensitive = False
1749 return_actions = True
1750 searches.append(self.api_o.remote_search(
1751 [api.Query(" ".join(pargs), case_sensitive, return_actions)],
1752 servers=servers))
1753 if debug:
1754 print "Search Args: %s : cs: %s : retact: %s" % \
1755 ("".join(pargs), case_sensitive, return_actions)
1756
1757 last_name = ""
1758 self.current_search_publisher = None
1759 try:
1760 for query_num, publisher, (v, return_type, tmp) in \
1761 itertools.chain(*searches):
1762 if v < 1 or return_type != api.Query.RETURN_PACKAGES:
1763 gobject.idle_add(self.w_progress_dialog.hide)
1764 self.__process_after_search_failure()
1765 return
1766
1767 pub = None
1768 if publisher is not None \
1769 and "prefix" in publisher:
1770 pub = publisher["prefix"]
1771 name = fmri.PkgFmri(str(tmp)).get_name()
1772 if last_name != name:
1773 if debug:
1774 print "Result Name: %s (%s)" % (name, pub)
1775 a_res = name, pub
1776 result.append(a_res)
1777 #Ignore Status when fetching
1778 application_list = \
1779 self.__get_min_list_from_search(result)
1780 self.current_search_publisher = pub
1781 self.in_setup = True
1782 gobject.idle_add(self.__init_tree_views,
1783 application_list, None, None)
1784 last_name = name
1785 self.pylintstub = query_num
1786 except api_errors.ProblematicSearchServers, ex:
1787 self.__process_api_search_error(ex)
1788 gobject.idle_add(self.w_progress_dialog.hide)
1789 gobject.idle_add(self.__handle_api_search_error)
1790 if len(result) == 0:
1791 self.__process_after_search_with_zero_results()
1792 return
1793 except Exception, ex:
1794 # We are not interested in this error
1795 gobject.idle_add(self.w_progress_dialog.hide)
1796 self.__process_after_search_failure()
1797 return
1798 if debug:
1799 print "Number of search results:", len(result)
1800 if len(result) == 0:
1801 if debug:
1802 print "No search results"
1803 self.__process_after_search_with_zero_results()
1804 return
1805 # We cannot get status of the packages if catalogs have not
1806 # been loaded so we pause for up to 5 seconds here to
1807 # allow catalogs to be loaded
1808 times = 5
1809 while self.catalog_loaded == False:
1810 if times == 0:
1811 break
1812 time.sleep(1)
1813 times -= 1
1814
1815 #Now fetch full result set with Status
1816 self.in_setup = True
1817 application_list = self.__get_full_list_from_search(result)
1818 gobject.idle_add(self.__init_tree_views, application_list, None, None)
1819
1820 if self.search_start > 0:
1821 self.search_time_sec = int(time.time() - self.search_start)
1822 if debug:
1823 print "Search time: %d (sec)" % self.search_time_sec
1824 self.search_start = 0
1825
1826 def __process_after_search_with_zero_results(self):
1827 if self.search_start > 0:
1828 self.search_time_sec = int(time.time() - self.search_start)
1829 self.search_start = 0
1830 self.in_setup = True
1831 application_list = self.__get_new_application_liststore()
1832 gobject.idle_add(self.__set_empty_details_panel)
1833 gobject.idle_add(self.__set_main_view_package_list)
1834 gobject.idle_add(self.__init_tree_views, application_list, None, None)
1835
1836 def __get_min_list_from_search(self, search_result):
1837 application_list = self.__get_new_application_liststore()
1838 for name, publisher in search_result:
1839 application_list.append(
1840 [False, None, name, '...', enumerations.NOT_INSTALLED, None,
1841 "pkg://" + publisher + "/" + name, None, True, None,
1842 publisher])
1843 return application_list
1844
1845 def __get_full_list_from_search(self, search_result):
1846 application_list = self.__get_new_application_liststore()
1847 self.__add_pkgs_to_list_from_search(search_result,
1848 application_list)
1849 return application_list
1850
1851 def __add_pkgs_to_list_from_search(self, search_result,
1852 application_list):
1853 pargs = []
1854 default_pub = self.api_o.get_preferred_publisher().prefix
1855 for name, publisher in search_result:
1856 pargs.append("pkg://" + publisher + "/" + name)
1857 # We now need to get the status for each package
1858 if debug_descriptions:
1859 print "pargs:", pargs
1860 try:
1861 pkgs_known = self.__get_inventory_list(pargs,
1862 True, True)
1863 except api_errors.InventoryException:
1864 # This can happen if load_catalogs has not been run
1865 err = _("Unable to get status for search results.\n"
1866 "The catalogs have not been loaded.\n"
2093 self.w_preferencesdialog.show()
2094
2095 def __on_preferencesclose_clicked(self, widget):
2096 self.w_preferencesdialog.hide()
2097
2098 def __on_preferenceshelp_clicked(self, widget):
2099 gui_misc.display_help(self.application_dir, "pm_win")
2100
2101 def __on_startpage_checkbutton_toggled(self, widget):
2102 self.show_startpage = self.w_startpage_checkbutton.get_active()
2103 try:
2104 self.client.set_bool(SHOW_STARTPAGE_PREFERENCES,
2105 self.show_startpage)
2106 except GError:
2107 pass
2108
2109 def __on_api_search_checkbox_toggled(self, widget):
2110 active = self.api_search_checkbox.get_active()
2111 if len(self.current_repos_with_search_errors) > 0:
2112 if active:
2113 for pub, err_type, err_str in \
2114 self.current_repos_with_search_errors:
2115 if pub not in self.gconf_not_show_repos:
2116 self.gconf_not_show_repos += pub + ","
2117 else:
2118 for pub, err_type, err_str in \
2119 self.current_repos_with_search_errors:
2120 self.gconf_not_show_repos = \
2121 self.gconf_not_show_repos.replace(
2122 pub + ",", "")
2123 try:
2124 self.client.set_string(API_SEARCH_ERROR_PREFERENCES,
2125 self.gconf_not_show_repos)
2126 except GError:
2127 pass
2128
2129 def __on_searchentry_focus_in(self, widget, event):
2130 if self.w_main_clipboard.wait_is_text_available():
2131 self.w_paste_menuitem.set_sensitive(True)
2132 char_count = widget.get_text_length()
2133 if char_count > 0:
2134 self.w_selectall_menuitem.set_sensitive(True)
2135 else:
2136 self.w_selectall_menuitem.set_sensitive(False)
2137 bounds = widget.get_selection_bounds()
2138 if bounds:
2139 offset1 = bounds[0]
2140 offset2 = bounds[1]
2141 if abs(offset2 - offset1) == char_count:
2142 self.w_selectall_menuitem.set_sensitive(False)
2443 start, end = self.w_searchentry.get_selection_bounds()
2444 self.w_searchentry.select_region(end, end)
2445
2446 pub = [active_publisher, ]
2447 self.set_show_filter = self.initial_show_filter
2448 self.set_section = self.initial_section
2449 Thread(target = self.__setup_publisher, args = [pub]).start()
2450 self.__set_main_view_package_list()
2451
2452 def __get_active_publisher(self):
2453 pub_iter = self.w_repository_combobox.get_active_iter()
2454 if pub_iter == None:
2455 return None
2456 return self.repositories_list.get_value(pub_iter, \
2457 enumerations.REPOSITORY_NAME)
2458
2459 def __setup_publisher(self, publishers=[]):
2460 self.saved_filter_combobox_active = self.initial_show_filter
2461 application_list, category_list , section_list = \
2462 self.__get_application_categories_lists(publishers)
2463 self.__unset_saved()
2464 gobject.idle_add(self.__init_tree_views, application_list,
2465 category_list, section_list)
2466
2467 def __unset_saved(self):
2468 self.saved_application_list = None
2469 self.saved_application_list_filter = None
2470 self.saved_application_list_sort = None
2471 self.saved_category_list = None
2472 self.saved_section_list = None
2473
2474 def __get_application_categories_lists(self, publishers=[]):
2475 if not self.visible_repository:
2476 self.visible_repository = self.__get_active_publisher()
2477 application_list = self.__get_new_application_liststore()
2478 category_list = self.__get_new_category_liststore()
2479 section_list = self.__get_new_section_liststore()
2480 first_loop = True
2481 for publisher in publishers:
2482 uptodate = False
2483 try:
2484 uptodate = self.__check_if_cache_uptodate(publisher)
2485 if uptodate:
2486 self.__add_pkgs_to_lists_from_cache(publisher,
2487 application_list, category_list,
2488 section_list)
2489 except (UnpicklingError, EOFError, IOError):
2490 #Most likely cache is corrupted, silently load list
2491 #from api.
2492 application_list = self.__get_new_application_liststore()
2493 category_list = self.__get_new_category_liststore()
2494 uptodate = False
2495 if not uptodate:
2496 if first_loop == True:
2497 first_loop = False
2498 gobject.idle_add(self.setup_progressdialog_show)
2499 self.api_o.refresh(pubs=[publisher])
2500 self.__add_pkgs_to_lists_from_api(publisher,
2501 application_list, category_list, section_list)
2502 category_list.prepend([0, _('All'), None, None, False,
2503 True, None])
2504 if self.application_list and self.category_list and \
2505 not self.visible_repository_uptodate:
2506 if self.visible_repository:
2507 dump_list = self.application_list
2508 if self.saved_application_list != None:
2509 dump_list = \
2510 self.saved_application_list
2511 self.__dump_datamodels(self.visible_repository,
2512 dump_list, self.category_list,
2513 self.section_list)
2514 self.visible_repository = self.__get_active_publisher()
2515 self.visible_repository_uptodate = uptodate
2516 return application_list, category_list, section_list
2517
2518 def __check_if_cache_uptodate(self, publisher):
2519 if self.cache_o:
2520 return self.cache_o.check_if_cache_uptodate(publisher)
2521 return False
2522
2523 def __dump_datamodels(self, publisher, application_list, category_list,
2524 section_list):
2525 #Consistency check - only dump models if publisher passed in matches
2526 #publisher in application list
2527 if application_list == None:
2528 return
2529 app_pub = application_list[0][enumerations.AUTHORITY_COLUMN]
2530 if publisher != app_pub:
2531 if debug:
2532 print "ERROR: __dump_data_models(): INCONSISTENT " \
2533 "pub %s != app_list_pub %s" % \
2534 (publisher, app_pub)
2535 return
2536
2537 if self.cache_o:
2538 if self.img_timestamp == \
2539 self.cache_o.get_index_timestamp():
2540 Thread(target = self.cache_o.dump_datamodels,
2541 args = (publisher, application_list, category_list,
2542 section_list)).start()
2543 else:
2544 self.__remove_cache()
2545
2546 def __remove_cache(self):
2547 model = self.w_repository_combobox.get_model()
2548 for publisher in model:
2549 pub_name = publisher[1]
2550 if pub_name and pub_name != _("Add..."):
2551 Thread(target = self.cache_o.remove_datamodel,
2552 args = [publisher[1]]).start()
2553
2554 def __on_install_update(self, widget):
2555 self.api_o.reset()
2556 install_update = []
3849 self.set_show_filter != enumerations.FILTER_ALL:
3850 self.__application_refilter()
3851 else:
3852 self.unset_busy_cursor()
3853
3854 if self.first_run or self.in_reload:
3855 Thread(target = self.__enable_disable_update_all).start()
3856 self.first_run = False
3857 self.in_reload = False
3858
3859 def get_icon_pixbuf_from_glade_dir(self, icon_name):
3860 return gui_misc.get_pixbuf_from_path(self.application_dir +
3861 "/usr/share/package-manager/", icon_name)
3862
3863 def update_statusbar(self):
3864 '''Function which updates statusbar'''
3865 if self.statusbar_message_id > 0:
3866 self.w_main_statusbar.remove(0, self.statusbar_message_id)
3867 self.statusbar_message_id = 0
3868 search_text = self.w_searchentry.get_text()
3869
3870 if not self.in_search_mode:
3871 installed = 0
3872 self.selected = 0
3873 sel = 0
3874 if self.application_list == None:
3875 return
3876 visible_repository = self.__get_visible_repository_name()
3877 pkgs = self.selected_pkgs.get(visible_repository)
3878 if pkgs:
3879 self.selected = len(pkgs)
3880 for pkg_row in self.application_list:
3881 if pkg_row[enumerations.STATUS_COLUMN] == \
3882 enumerations.INSTALLED \
3883 or pkg_row[enumerations.STATUS_COLUMN] == \
3884 enumerations.UPDATABLE:
3885 installed = installed + 1
3886 if pkg_row[enumerations.MARK_COLUMN]:
3887 sel = sel + 1
3888 listed_str = _('%d listed') % len(self.application_list)
3889 sel_str = _('%d selected') % sel
3890 inst_str = _('%d installed') % installed
3891 status_str = _("%s: %s , %s, %s.") % (visible_repository,
3892 listed_str, inst_str, sel_str)
3893 self.w_main_statusbar.push(0, status_str)
3894 return
3895
3896 # In Search Mode
3897 active = ""
3898 if self.is_search_all:
3899 if self.__doing_search():
3900 if self.current_search_publisher != None:
3901 active = "(" + self.current_search_publisher + \
3902 ") "
3903 opt_str = _('Searching... '
3904 '%(active)sfor "%(search_text)s"') % \
3905 {"active": active, "search_text": search_text}
3906 else:
3907 opt_str = _('Searched All for "%s"') % (search_text)
3908 else:
3909 search_str = _("Searched")
3910 if self.__doing_search():
3911 search_str = _("Searching...")
3912 if self.last_active_publisher != None:
3913 active = "(" + self.last_active_publisher + ") "
3914 opt_str = \
3915 _('%(search)s %(last_active)sfor "%(search_text)s"') \
3916 % {"search": search_str, "last_active" : active,
3917 "search_text" : search_text}
3918 fmt_str = _("%(option_str)s: %(number)d found %(time)s")
3919 time_str = ""
3920 if self.search_time_sec > 0:
3921 time_str = _("in %d seconds") % self.search_time_sec
3922 status_str = fmt_str % {"option_str" : opt_str, "number" :
3923 len(self.application_list), "time" : time_str}
3924 self.w_main_statusbar.push(0, status_str)
3925
3926 def update_package_list(self, update_list):
3927 if update_list == None and self.img_timestamp:
3928 return
3929 visible_repository = self.__get_visible_repository_name()
3930 default_publisher = self.default_publisher
3931 self.api_o.refresh()
3932 if not self.img_timestamp:
3933 self.img_timestamp = self.cache_o.get_index_timestamp()
3934 self.__on_reload(None)
3935 return
3936 self.img_timestamp = self.cache_o.get_index_timestamp()
3937 installed_icon = gui_misc.get_icon(self.icon_theme,
3938 "status_installed")
3939 visible_list = update_list.get(visible_repository)
3940 if visible_list:
3941 i = 0
3942 while i < len(visible_list):
3943 visible_list[i] = gui_misc.get_pkg_name(
3944 visible_list[i])
3945 i += 1
|