def test_navhistory_lobby_search_then_clear(self):
(back_forward_btn, options, navhistory, view_manager,
pane) = self._get_boring_stuff()
# first we must initialize the NavHistory with the equivalent of the initial category view
# NnavigationItem(view_manager, pane, page, view_state, callback)
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY,
DisplayState())
navhistory.append(item)
# append equivalent of a typed search
dstate = DisplayState()
dstate.search_term = "chess"
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate the user clearing the search entry
dstate = DisplayState()
dstate.search_term = ""
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY,
dstate)
navhistory.append(item)
self.assertFalse(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
def test_navhistory_lobby_search_then_clear(self):
(back_forward_btn, options, navhistory, view_manager, pane) = self._get_boring_stuff()
# first we must initialize the NavHistory with the equivalent of the initial category view
# NnavigationItem(view_manager, pane, page, view_state, callback)
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY, DisplayState())
navhistory.append(item)
# append equivalent of a typed search
dstate = DisplayState()
dstate.search_term = "chess"
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate the user clearing the search entry
dstate = DisplayState()
dstate.search_term = ""
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY, dstate)
navhistory.append(item)
self.assertFalse(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
def __init__(self, icons):
Gtk.ScrolledWindow.__init__(self)
BasePane.__init__(self)
self.state = DisplayState()
self.pane_name = _("Progress")
self.tv = Gtk.TreeView()
# customization
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.add(self.tv)
self.tv.set_headers_visible(False)
self.tv.connect("button-press-event", self._on_button_pressed)
# icon
self.icons = icons
tp = Gtk.CellRendererPixbuf()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
column = Gtk.TreeViewColumn("Icon", tp, pixbuf=PendingStore.COL_ICON)
self.tv.append_column(column)
# name
tr = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Name", tr, markup=PendingStore.COL_STATUS)
column.set_min_width(200)
column.set_expand(True)
self.tv.append_column(column)
# progress
tp = Gtk.CellRendererProgress()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
tp.set_property("text", "")
column = Gtk.TreeViewColumn("Progress",
tp,
value=PendingStore.COL_PROGRESS,
pulse=PendingStore.COL_PULSE)
column.set_min_width(200)
self.tv.append_column(column)
# cancel icon
tpix = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("Cancel",
tpix,
stock_id=PendingStore.COL_CANCEL)
self.tv.append_column(column)
# fake columns that eats the extra space at the end
tt = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Cancel", tt)
self.tv.append_column(column)
# add it
store = PendingStore(icons)
self.tv.set_model(store)
def __init__(self, cache, db, distro, icons, show_ratings=True):
Gtk.VBox.__init__(self)
BasePane.__init__(self)
# other classes we need
self.enquirer = AppEnquire(cache, db)
self._query_complete_handler = self.enquirer.connect(
"query-complete", self.on_query_complete)
self.cache = cache
self.db = db
self.distro = distro
self.icons = icons
self.show_ratings = show_ratings
self.backend = get_install_backend()
self.nonapps_visible = NonAppVisibility.MAYBE_VISIBLE
# refreshes can happen out-of-bound so we need to be sure
# that we only set the new model (when its available) if
# the refresh_seq_nr of the ready model matches that of the
# request (e.g. people click on ubuntu channel, get impatient, click
# on partner channel)
self.refresh_seq_nr = 0
# this should be initialized
self.apps_search_term = ""
# Create the basic frame for the common view
self.state = DisplayState()
vm = get_viewmanager()
self.searchentry = vm.get_global_searchentry()
self.back_forward = vm.get_global_backforward()
# a notebook below
self.notebook = Gtk.Notebook()
if not SOFTWARE_CENTER_DEBUG_TABS:
self.notebook.set_show_tabs(False)
self.notebook.set_show_border(False)
# make a spinner view to display while the applist is loading
self.spinner_notebook = SpinnerNotebook(self.notebook)
self.pack_start(self.spinner_notebook, True, True, 0)
# add a bar at the bottom (hidden by default) for contextual actions
self.action_bar = ActionBar()
self.pack_start(self.action_bar, False, True, 0)
# cursor
self.busy_cursor = Gdk.Cursor.new(Gdk.CursorType.WATCH)
# views to be created in init_view
self.app_view = None
self.app_details_view = None
def test_navhistory_cat_search_then_clear(self):
(back_forward_btn, options, navhistory, view_manager, pane) = self._get_boring_stuff()
# first we must initialize the NavHistory with the equivalent of the initial category view
# NnavigationItem(view_manager, pane, page, view_state, callback)
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY, DisplayState())
navhistory.append(item)
# simulate Accessories category LIST
dstate = DisplayState()
dstate.category = Category('accessories', 'Accessories', 'iconname', 'query')
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
# displaying the Accessories LIST
self.assertTrue(len(navhistory.stack) == 2)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate a user search
dstate = DisplayState()
dstate.category = Category('accessories', 'Accessories', 'iconname', 'query')
dstate.search_term = "chess"
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
# should be displaying the search results for Accessories
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
self.assertTrue(len(navhistory.stack) == 3)
# simulate a user clearing the search
dstate = DisplayState()
dstate.category = Category('accessories', 'Accessories', 'iconname', 'query')
dstate.search_term = ""
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# should be returned to the Accessories list view
self.assertTrue(len(navhistory.stack) == 2)
def test_navhistory_subcat_search_then_clear(self):
(back_forward_btn, options, navhistory, view_manager, pane) = self._get_boring_stuff()
# first we must initialize the NavHistory with the equivalent of the initial category view
# NnavigationItem(view_manager, pane, page, view_state, callback)
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY, DisplayState())
navhistory.append(item)
board_games = Category('board-games', 'Board Games', 'iconname', 'query')
games = Category('games', 'Games', 'iconname', 'query', subcategories=[board_games,])
# simulate Games category (with subcats)
dstate = DisplayState()
dstate.category = games
item = NavigationItem(view_manager, pane, AvailablePane.Pages.SUBCATEGORY, dstate)
navhistory.append(item)
# displaying the Games SUBCATEGORY
self.assertTrue(len(navhistory.stack) == 2)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate Board Games subcategory LIST
dstate = DisplayState()
dstate.category = games
dstate.subcategory = board_games
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
# displaying the Accessories LIST
self.assertTrue(len(navhistory.stack) == 3)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate a user search within subcat
dstate = DisplayState()
dstate.category = games
dstate.subcategory = board_games
dstate.search_term = "chess"
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
# should be displaying the search results for Accessories
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
self.assertTrue(len(navhistory.stack) == 4)
# simulate a user clearing the search
dstate = DisplayState()
dstate.category = games
dstate.subcategory = board_games
dstate.search_term = ""
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST, dstate)
navhistory.append(item)
# should be returned to the Board Games LIST view
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
self.assertTrue(len(navhistory.stack) == 3)
# verify that navhistory item 2 is LIST page
self.assertTrue(navhistory.stack[2].page == AvailablePane.Pages.LIST)
# verify that navhistory item 1 is SUBCATEGORY page
self.assertTrue(navhistory.stack[1].page == AvailablePane.Pages.SUBCATEGORY)
# verify that navhistory item 0 is LOBBY page
self.assertTrue(navhistory.stack[0].page == AvailablePane.Pages.LOBBY)
def test_navhistory_cat_search_then_clear(self):
(back_forward_btn, options, navhistory, view_manager,
pane) = self._get_boring_stuff()
# first we must initialize the NavHistory with the equivalent of the initial category view
# NnavigationItem(view_manager, pane, page, view_state, callback)
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY,
DisplayState())
navhistory.append(item)
# simulate Accessories category LIST
dstate = DisplayState()
dstate.category = Category('accessories', 'Accessories', 'iconname',
'query')
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
# displaying the Accessories LIST
self.assertTrue(len(navhistory.stack) == 2)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate a user search
dstate = DisplayState()
dstate.category = Category('accessories', 'Accessories', 'iconname',
'query')
dstate.search_term = "chess"
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
# should be displaying the search results for Accessories
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
self.assertTrue(len(navhistory.stack) == 3)
# simulate a user clearing the search
dstate = DisplayState()
dstate.category = Category('accessories', 'Accessories', 'iconname',
'query')
dstate.search_term = ""
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# should be returned to the Accessories list view
self.assertTrue(len(navhistory.stack) == 2)
def test_navhistory_subcat_search_then_clear(self):
(back_forward_btn, options, navhistory, view_manager,
pane) = self._get_boring_stuff()
# first we must initialize the NavHistory with the equivalent of the initial category view
# NnavigationItem(view_manager, pane, page, view_state, callback)
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LOBBY,
DisplayState())
navhistory.append(item)
board_games = Category('board-games', 'Board Games', 'iconname',
'query')
games = Category('games',
'Games',
'iconname',
'query',
subcategories=[
board_games,
])
# simulate Games category (with subcats)
dstate = DisplayState()
dstate.category = games
item = NavigationItem(view_manager, pane,
AvailablePane.Pages.SUBCATEGORY, dstate)
navhistory.append(item)
# displaying the Games SUBCATEGORY
self.assertTrue(len(navhistory.stack) == 2)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate Board Games subcategory LIST
dstate = DisplayState()
dstate.category = games
dstate.subcategory = board_games
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
# displaying the Accessories LIST
self.assertTrue(len(navhistory.stack) == 3)
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
# simulate a user search within subcat
dstate = DisplayState()
dstate.category = games
dstate.subcategory = board_games
dstate.search_term = "chess"
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
# should be displaying the search results for Accessories
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
self.assertTrue(len(navhistory.stack) == 4)
# simulate a user clearing the search
dstate = DisplayState()
dstate.category = games
dstate.subcategory = board_games
dstate.search_term = ""
item = NavigationItem(view_manager, pane, AvailablePane.Pages.LIST,
dstate)
navhistory.append(item)
# should be returned to the Board Games LIST view
self.assertTrue(back_forward_btn.left.sensitive)
self.assertFalse(back_forward_btn.right.sensitive)
self.assertTrue(len(navhistory.stack) == 3)
# verify that navhistory item 2 is LIST page
self.assertTrue(navhistory.stack[2].page == AvailablePane.Pages.LIST)
# verify that navhistory item 1 is SUBCATEGORY page
self.assertTrue(
navhistory.stack[1].page == AvailablePane.Pages.SUBCATEGORY)
# verify that navhistory item 0 is LOBBY page
self.assertTrue(navhistory.stack[0].page == AvailablePane.Pages.LOBBY)
def __init__(self, cache, db, distro, icons):
Gtk.VBox.__init__(self)
self.cache = cache
self.db = db
self.distro = distro
self.icons = icons
self.apps_filter = None
self.state = DisplayState()
self.pane_name = _("History")
# Icon cache, invalidated upon icon theme changes
self._app_icon_cache = {}
self._reset_icon_cache()
self.icons.connect('changed', self._reset_icon_cache)
self._emblems = {}
self._get_emblems(self.icons)
vm = get_viewmanager()
self.searchentry = vm.get_global_searchentry()
self.toolbar = Gtk.Toolbar()
self.toolbar.show()
self.toolbar.set_style(Gtk.ToolbarStyle.TEXT)
self.pack_start(self.toolbar, False, True, 0)
all_action = Gtk.RadioAction('filter_all', _('All Changes'), None,
None, self.ALL)
all_action.connect('changed', self.change_filter)
all_button = all_action.create_tool_item()
self.toolbar.insert(all_button, 0)
installs_action = Gtk.RadioAction('filter_installs',
_('Installations'), None, None,
self.INSTALLED)
installs_action.join_group(all_action)
installs_button = installs_action.create_tool_item()
self.toolbar.insert(installs_button, 1)
upgrades_action = Gtk.RadioAction('filter_upgrads', _('Updates'), None,
None, self.UPGRADED)
upgrades_action.join_group(all_action)
upgrades_button = upgrades_action.create_tool_item()
self.toolbar.insert(upgrades_button, 2)
removals_action = Gtk.RadioAction('filter_removals', _('Removals'),
None, None, self.REMOVED)
removals_action.join_group(all_action)
removals_button = removals_action.create_tool_item()
self.toolbar.insert(removals_button, 3)
self.toolbar.connect('draw', self.on_toolbar_draw)
self._actions_list = all_action.get_group()
self._set_actions_sensitive(False)
self.view = Gtk.TreeView()
self.view.set_headers_visible(False)
self.view.show()
self.history_view = Gtk.ScrolledWindow()
self.history_view.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.history_view.show()
self.history_view.add(self.view)
# make a spinner to display while history is loading
self.spinner_notebook = SpinnerNotebook(self.history_view,
_('Loading history'))
self.pack_start(self.spinner_notebook, True, True, 0)
self.store = Gtk.TreeStore(*self.COL_TYPES)
self.visible_changes = 0
self.store_filter = self.store.filter_new(None)
self.store_filter.set_visible_func(self.filter_row, None)
self.view.set_model(self.store_filter)
all_action.set_active(True)
self.last = None
# to save (a lot of) time at startup we load history later, only when
# it is selected to be viewed
self.history = None
self.column = Gtk.TreeViewColumn(_('Date'))
self.view.append_column(self.column)
self.cell_icon = Gtk.CellRendererPixbuf()
self.cell_icon.set_padding(self.PADDING, self.PADDING / 2)
self.column.pack_start(self.cell_icon, False)
self.column.set_cell_data_func(self.cell_icon, self.render_cell_icon)
self.cell_text = Gtk.CellRendererText()
self.column.pack_start(self.cell_text, True)
self.column.set_cell_data_func(self.cell_text, self.render_cell_text)
self.cell_time = Gtk.CellRendererText()
self.cell_time.set_padding(6, 0)
self.cell_time.set_alignment(1.0, 0.5)
self.column.pack_end(self.cell_time, False)
self.column.set_cell_data_func(self.cell_time, self.render_cell_time)
# busy cursor
self.busy_cursor = Gdk.Cursor.new(Gdk.CursorType.WATCH)