gnome-shell/js/ui/search.js

826 lines
26 KiB
JavaScript
Raw Normal View History

// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported SearchResultsView, SearchResultInterface */
const { Clutter, Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
const AppDisplay = imports.ui.appDisplay;
const IconGrid = imports.ui.iconGrid;
const Main = imports.ui.main;
const RemoteSearch = imports.ui.remoteSearch;
const Util = imports.misc.util;
const SEARCH_PROVIDERS_SCHEMA = 'org.gnome.desktop.search-providers';
var MAX_LIST_SEARCH_RESULTS_ROWS = 5;
var MAX_GRID_SEARCH_RESULTS_ROWS = 1;
var MaxWidthBox = GObject.registerClass(
class MaxWidthBox extends St.BoxLayout {
vfunc_allocate(box, flags) {
let themeNode = this.get_theme_node();
let maxWidth = themeNode.get_max_width();
let availWidth = box.x2 - box.x1;
let adjustedBox = box;
if (availWidth > maxWidth) {
let excessWidth = availWidth - maxWidth;
adjustedBox.x1 += Math.floor(excessWidth / 2);
adjustedBox.x2 -= Math.floor(excessWidth / 2);
}
super.vfunc_allocate(adjustedBox, flags);
}
});
var SearchResultInterface = GObject.registerClass({
Requires: [Clutter.Actor],
}, class SearchResultInterface extends GObject.Interface {
activate() {
throw new GObject.NotImplementedError('activate in %s'.format(this.constructor.name));
}
});
var SearchResult = GObject.registerClass({
Implements: [SearchResultInterface]
}, class SearchResult extends St.Button {
_init(provider, metaInfo, resultsView) {
this.provider = provider;
this.metaInfo = metaInfo;
this._resultsView = resultsView;
super._init({
reactive: true,
can_focus: true,
track_hover: true,
x_align: St.Align.START,
y_fill: true
});
}
vfunc_clicked() {
this.activate();
}
activate() {
this.provider.activateResult(this.metaInfo.id, this._resultsView.terms);
if (this.metaInfo.clipboardText)
St.Clipboard.get_default().set_text(
St.ClipboardType.CLIPBOARD, this.metaInfo.clipboardText);
Main.overview.toggle();
}
});
var ListSearchResult = GObject.registerClass(
class ListSearchResult extends SearchResult {
_init(provider, metaInfo, resultsView) {
super._init(provider, metaInfo, resultsView);
this.style_class = 'list-search-result';
this.x_fill = true;
let content = new St.BoxLayout({ style_class: 'list-search-result-content',
vertical: false });
this.set_child(content);
this._termsChangedId = 0;
let titleBox = new St.BoxLayout({ style_class: 'list-search-result-title' });
content.add(titleBox, { x_fill: true,
y_fill: false,
x_align: St.Align.START,
y_align: St.Align.MIDDLE });
// An icon for, or thumbnail of, content
let icon = this.metaInfo['createIcon'](this.ICON_SIZE);
if (icon) {
titleBox.add(icon);
}
let title = new St.Label({ text: this.metaInfo['name'] });
titleBox.add(title, { x_fill: false,
y_fill: false,
x_align: St.Align.START,
y_align: St.Align.MIDDLE });
this.label_actor = title;
if (this.metaInfo['description']) {
this._descriptionLabel = new St.Label({ style_class: 'list-search-result-description' });
content.add(this._descriptionLabel, { x_fill: false,
y_fill: false,
x_align: St.Align.START,
y_align: St.Align.MIDDLE });
this._termsChangedId =
this._resultsView.connect('terms-changed',
this._highlightTerms.bind(this));
this._highlightTerms();
}
this.connect('destroy', this._onDestroy.bind(this));
}
get ICON_SIZE() {
return 24;
}
_highlightTerms() {
let markup = this._resultsView.highlightTerms(this.metaInfo['description'].split('\n')[0]);
this._descriptionLabel.clutter_text.set_markup(markup);
}
_onDestroy() {
if (this._termsChangedId)
this._resultsView.disconnect(this._termsChangedId);
this._termsChangedId = 0;
}
});
var GridSearchResult = GObject.registerClass(
class GridSearchResult extends SearchResult {
_init(provider, metaInfo, resultsView) {
super._init(provider, metaInfo, resultsView);
this.style_class = 'grid-search-result';
this.icon = new IconGrid.BaseIcon(this.metaInfo['name'],
{ createIcon: this.metaInfo['createIcon'] });
let content = new St.Bin({ child: this.icon });
this.set_child(content);
this.label_actor = this.icon.label;
}
});
var SearchResultsBase = GObject.registerClass({
GTypeFlags: GObject.TypeFlags.ABSTRACT,
Properties: {
'focus-child': GObject.ParamSpec.object(
'focus-child', 'focus-child', 'focus-child',
GObject.ParamFlags.READABLE,
Clutter.Actor.$gtype),
}
}, class SearchResultsBase extends St.BoxLayout {
_init(provider, resultsView) {
super._init({ style_class: 'search-section', vertical: true });
this.provider = provider;
this._resultsView = resultsView;
this._terms = [];
this._focusChild = null;
this._resultDisplayBin = new St.Bin({ x_fill: true,
y_fill: true });
this.add(this._resultDisplayBin, { expand: true });
let separator = new St.Widget({ style_class: 'search-section-separator' });
this.add(separator);
this._resultDisplays = {};
this._cancellable = new Gio.Cancellable();
this.connect('destroy', this._onDestroy.bind(this));
}
_onDestroy() {
this._terms = [];
}
_createResultDisplay(meta) {
if (this.provider.createResultObject)
return this.provider.createResultObject(meta, this._resultsView);
return null;
}
clear() {
this._cancellable.cancel();
for (let resultId in this._resultDisplays)
this._resultDisplays[resultId].destroy();
this._resultDisplays = {};
this._clearResultDisplay();
this.hide();
}
get focusChild() {
return this._focusChild;
}
_keyFocusIn(actor) {
if (this._focusChild == actor)
return;
this._focusChild = actor;
this.notify('focus-child');
}
_setMoreCount(_count) {
}
_ensureResultActors(results, callback) {
let metasNeeded = results.filter(
resultId => this._resultDisplays[resultId] === undefined
);
if (metasNeeded.length === 0) {
callback(true);
} else {
this._cancellable.cancel();
this._cancellable.reset();
this.provider.getResultMetas(metasNeeded, metas => {
if (this._cancellable.is_cancelled()) {
if (metas.length > 0)
log(`Search provider ${this.provider.id} returned results after the request was canceled`);
callback(false);
return;
}
if (metas.length != metasNeeded.length) {
log(`Wrong number of result metas returned by search provider ${this.provider.id}: ` +
`expected ${metasNeeded.length} but got ${metas.length}`);
callback(false);
return;
}
if (metas.some(meta => !meta.name || !meta.id)) {
log(`Invalid result meta returned from search provider ${this.provider.id}`);
callback(false);
return;
}
metasNeeded.forEach((resultId, i) => {
let meta = metas[i];
let display = this._createResultDisplay(meta);
if (!(display instanceof SearchResultInterface))
throw new Error(`${display} is not a valid search result`);
display.connect('key-focus-in', this._keyFocusIn.bind(this));
this._resultDisplays[resultId] = display;
});
callback(true);
}, this._cancellable);
}
}
updateSearch(providerResults, terms, callback) {
this._terms = terms;
if (providerResults.length == 0) {
this._clearResultDisplay();
this.hide();
callback();
} else {
let maxResults = this._getMaxDisplayedResults();
search: Don't use max number of results if allocation width is 0 Since commit 1a27ff6130e03e64d9e426ece72a12e4e2a80f50 we use the allocation width of the GridSearchResults actor to calculate the max number of results that can be shown for this search provider. On the first run of the search, when no previous (cached) allocation is available for the actor of GridSearchResults, the allocation width used in `_getMaxDisplayedResults` will be 0, which in turn will make `updateSearch` filter out all results returned by the search provider. Now if this search provider is the only search provider that's enabled, after calling `updateSearch`, the `SearchResults` class will call `_updateSearchProgress` to check if any results are visible, assume nothing was found and therefore hide the scrollView. This in turn causes the GridSearchResults actor to not get a new allocation, which prevents our code to fixup the max number of results on `notify::allocation` from working: The number will continue to be 0 and we'll never show any results. To fix this regression, return -1 in `_getMaxDisplayedResults` if the allocation width is 0 to inform `updateSearch` that we can't calculate the maximum number yet and interpret a return value of -1 as "show all results" in `updateSearch`. The same problem would probably also appear if the allocation width is anything between 0 and the width of the iconGrid with one icon in it, although this might as well be a valid width in case a very small screen is used or with very large icons. So let's only check for a width of 0 and hope the GridSearchResults actor won't get weird temporary allocations in that range. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/672
2019-08-07 14:42:17 +00:00
let results = maxResults > -1
? this.provider.filterResults(providerResults, maxResults)
: providerResults;
let moreCount = Math.max(providerResults.length - results.length, 0);
this._ensureResultActors(results, successful => {
if (!successful) {
this._clearResultDisplay();
callback();
return;
}
// To avoid CSS transitions causing flickering when
// the first search result stays the same, we hide the
// content while filling in the results.
this.hide();
this._clearResultDisplay();
results.forEach(resultId => {
this._addItem(this._resultDisplays[resultId]);
});
this._setMoreCount(this.provider.canLaunchSearch ? moreCount : 0);
this.show();
callback();
});
}
}
});
var ListSearchResults = GObject.registerClass(
class ListSearchResults extends SearchResultsBase {
_init(provider, resultsView) {
super._init(provider, resultsView);
this._container = new St.BoxLayout({ style_class: 'search-section-content' });
this.providerInfo = new ProviderInfo(provider);
this.providerInfo.connect('key-focus-in', this._keyFocusIn.bind(this));
this.providerInfo.connect('clicked', () => {
this.providerInfo.animateLaunch();
provider.launchSearch(this._terms);
Main.overview.toggle();
});
this._container.add(this.providerInfo, { x_fill: false,
y_fill: false,
x_align: St.Align.START,
y_align: St.Align.START });
this._content = new St.BoxLayout({ style_class: 'list-search-results',
vertical: true });
this._container.add(this._content, { expand: true });
this._resultDisplayBin.set_child(this._container);
}
_setMoreCount(count) {
this.providerInfo.setMoreCount(count);
}
_getMaxDisplayedResults() {
return MAX_LIST_SEARCH_RESULTS_ROWS;
}
_clearResultDisplay() {
this._content.remove_all_children();
}
_createResultDisplay(meta) {
return super._createResultDisplay(meta) ||
new ListSearchResult(this.provider, meta, this._resultsView);
}
_addItem(display) {
this._content.add_actor(display);
}
getFirstResult() {
if (this._content.get_n_children() > 0)
return this._content.get_child_at_index(0);
else
return null;
}
});
var GridSearchResults = GObject.registerClass(
class GridSearchResults extends SearchResultsBase {
_init(provider, resultsView) {
super._init(provider, resultsView);
this._grid = new IconGrid.IconGrid({ rowLimit: MAX_GRID_SEARCH_RESULTS_ROWS,
xAlign: St.Align.START });
this._bin = new St.Bin({ x_align: St.Align.MIDDLE });
this._bin.set_child(this._grid);
this._resultDisplayBin.set_child(this._bin);
}
_onDestroy() {
if (this._updateSearchLater) {
Meta.later_remove(this._updateSearchLater);
delete this._updateSearchLater;
}
super._onDestroy();
}
search: Fix calculation of max number of displayed results for grid The calculation of how many results can be shown in GridSearchResults is broken: The width of the parent container (resultsView.actor) we're using as the maximum width right now is the width of the scrollView of SearchResults (which always expands to the whole screen size). This width will only be correct if the scrollView (ie. the whole screen) is smaller than the max width of searchResultsContent, which only is the case for screens smaller than 1000px. To fix the calculation, use the width of our own actor and don't get it using clutter_actor_get_width(), but using the last allocation of the actor. This way we don't get the preferred width if the actor is not allocated at this point (it's hidden by _ensureProviderDisplay() when starting a new search). Then, when the allocation of the actor changes, rebuild the grid search results by calling updateSearch() with the old arguments to ensure the number of visible results is correct. The fact that we're only listening for allocation changes here is the reason why we never want to use the preferred width of the actor inside _getMaxDisplayedResults(): While the actor is hidden clutter_actor_get_width() would return the preferred width, which we'd then use the as the maximum width. But if the actor had a correct allocation before, no notify::allocation signal will be emitted when the actor is shown again because the allocation is still the same, and we'll end up using the preferred width as maximium width forever. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/110
2018-11-24 23:57:00 +00:00
updateSearch(...args) {
if (this._notifyAllocationId)
this.disconnect(this._notifyAllocationId);
if (this._updateSearchLater) {
Meta.later_remove(this._updateSearchLater);
delete this._updateSearchLater;
}
search: Fix calculation of max number of displayed results for grid The calculation of how many results can be shown in GridSearchResults is broken: The width of the parent container (resultsView.actor) we're using as the maximum width right now is the width of the scrollView of SearchResults (which always expands to the whole screen size). This width will only be correct if the scrollView (ie. the whole screen) is smaller than the max width of searchResultsContent, which only is the case for screens smaller than 1000px. To fix the calculation, use the width of our own actor and don't get it using clutter_actor_get_width(), but using the last allocation of the actor. This way we don't get the preferred width if the actor is not allocated at this point (it's hidden by _ensureProviderDisplay() when starting a new search). Then, when the allocation of the actor changes, rebuild the grid search results by calling updateSearch() with the old arguments to ensure the number of visible results is correct. The fact that we're only listening for allocation changes here is the reason why we never want to use the preferred width of the actor inside _getMaxDisplayedResults(): While the actor is hidden clutter_actor_get_width() would return the preferred width, which we'd then use the as the maximum width. But if the actor had a correct allocation before, no notify::allocation signal will be emitted when the actor is shown again because the allocation is still the same, and we'll end up using the preferred width as maximium width forever. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/110
2018-11-24 23:57:00 +00:00
// Make sure the maximum number of results calculated by
// _getMaxDisplayedResults() is updated after width changes.
this._notifyAllocationId = this.connect('notify::allocation', () => {
if (this._updateSearchLater)
return;
this._updateSearchLater = Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
delete this._updateSearchLater;
super.updateSearch(...args);
return GLib.SOURCE_REMOVE;
});
search: Fix calculation of max number of displayed results for grid The calculation of how many results can be shown in GridSearchResults is broken: The width of the parent container (resultsView.actor) we're using as the maximum width right now is the width of the scrollView of SearchResults (which always expands to the whole screen size). This width will only be correct if the scrollView (ie. the whole screen) is smaller than the max width of searchResultsContent, which only is the case for screens smaller than 1000px. To fix the calculation, use the width of our own actor and don't get it using clutter_actor_get_width(), but using the last allocation of the actor. This way we don't get the preferred width if the actor is not allocated at this point (it's hidden by _ensureProviderDisplay() when starting a new search). Then, when the allocation of the actor changes, rebuild the grid search results by calling updateSearch() with the old arguments to ensure the number of visible results is correct. The fact that we're only listening for allocation changes here is the reason why we never want to use the preferred width of the actor inside _getMaxDisplayedResults(): While the actor is hidden clutter_actor_get_width() would return the preferred width, which we'd then use the as the maximum width. But if the actor had a correct allocation before, no notify::allocation signal will be emitted when the actor is shown again because the allocation is still the same, and we'll end up using the preferred width as maximium width forever. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/110
2018-11-24 23:57:00 +00:00
});
super.updateSearch(...args);
}
_getMaxDisplayedResults() {
let width = this.allocation.get_width();
search: Don't use max number of results if allocation width is 0 Since commit 1a27ff6130e03e64d9e426ece72a12e4e2a80f50 we use the allocation width of the GridSearchResults actor to calculate the max number of results that can be shown for this search provider. On the first run of the search, when no previous (cached) allocation is available for the actor of GridSearchResults, the allocation width used in `_getMaxDisplayedResults` will be 0, which in turn will make `updateSearch` filter out all results returned by the search provider. Now if this search provider is the only search provider that's enabled, after calling `updateSearch`, the `SearchResults` class will call `_updateSearchProgress` to check if any results are visible, assume nothing was found and therefore hide the scrollView. This in turn causes the GridSearchResults actor to not get a new allocation, which prevents our code to fixup the max number of results on `notify::allocation` from working: The number will continue to be 0 and we'll never show any results. To fix this regression, return -1 in `_getMaxDisplayedResults` if the allocation width is 0 to inform `updateSearch` that we can't calculate the maximum number yet and interpret a return value of -1 as "show all results" in `updateSearch`. The same problem would probably also appear if the allocation width is anything between 0 and the width of the iconGrid with one icon in it, although this might as well be a valid width in case a very small screen is used or with very large icons. So let's only check for a width of 0 and hope the GridSearchResults actor won't get weird temporary allocations in that range. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/672
2019-08-07 14:42:17 +00:00
if (width == 0)
return -1;
let nCols = this._grid.columnsForWidth(width);
search: Fix calculation of max number of displayed results for grid The calculation of how many results can be shown in GridSearchResults is broken: The width of the parent container (resultsView.actor) we're using as the maximum width right now is the width of the scrollView of SearchResults (which always expands to the whole screen size). This width will only be correct if the scrollView (ie. the whole screen) is smaller than the max width of searchResultsContent, which only is the case for screens smaller than 1000px. To fix the calculation, use the width of our own actor and don't get it using clutter_actor_get_width(), but using the last allocation of the actor. This way we don't get the preferred width if the actor is not allocated at this point (it's hidden by _ensureProviderDisplay() when starting a new search). Then, when the allocation of the actor changes, rebuild the grid search results by calling updateSearch() with the old arguments to ensure the number of visible results is correct. The fact that we're only listening for allocation changes here is the reason why we never want to use the preferred width of the actor inside _getMaxDisplayedResults(): While the actor is hidden clutter_actor_get_width() would return the preferred width, which we'd then use the as the maximum width. But if the actor had a correct allocation before, no notify::allocation signal will be emitted when the actor is shown again because the allocation is still the same, and we'll end up using the preferred width as maximium width forever. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/110
2018-11-24 23:57:00 +00:00
return nCols * this._grid.getRowLimit();
}
_clearResultDisplay() {
this._grid.removeAll();
}
_createResultDisplay(meta) {
return super._createResultDisplay(meta) ||
new GridSearchResult(this.provider, meta, this._resultsView);
}
_addItem(display) {
2013-10-30 17:06:56 +00:00
this._grid.addItem(display);
}
getFirstResult() {
if (this._grid.visibleItemsCount() > 0)
return this._grid.getItemAtIndex(0);
else
return null;
}
});
var SearchResultsView = GObject.registerClass({
Signals: { 'terms-changed': {} }
}, class SearchResultsView extends St.BoxLayout {
_init() {
super._init({ name: 'searchResults', vertical: true });
this._content = new MaxWidthBox({ name: 'searchResultsContent',
vertical: true });
this._scrollView = new St.ScrollView({ x_fill: true,
y_fill: false,
overlay_scrollbars: true,
style_class: 'search-display vfade' });
this._scrollView.set_policy(St.PolicyType.NEVER, St.PolicyType.AUTOMATIC);
this._scrollView.add_actor(this._content);
let action = new Clutter.PanAction({ interpolate: true });
action.connect('pan', this._onPan.bind(this));
this._scrollView.add_action(action);
this.add(this._scrollView, {
x_fill: true,
y_fill: true,
expand: true,
x_align: St.Align.START,
y_align: St.Align.STAR
});
this._statusText = new St.Label({ style_class: 'search-statustext' });
this._statusBin = new St.Bin({ x_align: St.Align.MIDDLE,
y_align: St.Align.MIDDLE });
this.add(this._statusBin, { expand: true });
this._statusBin.add_actor(this._statusText);
this._highlightDefault = false;
this._defaultResult = null;
this._startingSearch = false;
this._terms = [];
this._results = {};
this._providers = [];
this._highlightRegex = null;
this._searchSettings = new Gio.Settings({ schema_id: SEARCH_PROVIDERS_SCHEMA });
this._searchSettings.connect('changed::disabled', this._reloadRemoteProviders.bind(this));
this._searchSettings.connect('changed::enabled', this._reloadRemoteProviders.bind(this));
this._searchSettings.connect('changed::disable-external', this._reloadRemoteProviders.bind(this));
this._searchSettings.connect('changed::sort-order', this._reloadRemoteProviders.bind(this));
this._searchTimeoutId = 0;
this._cancellable = new Gio.Cancellable();
this._registerProvider(new AppDisplay.AppSearchProvider());
let appSystem = Shell.AppSystem.get_default();
appSystem.connect('installed-changed', this._reloadRemoteProviders.bind(this));
this._reloadRemoteProviders();
}
get terms() {
return this._terms;
}
_reloadRemoteProviders() {
let remoteProviders = this._providers.filter(p => p.isRemoteProvider);
remoteProviders.forEach(provider => {
this._unregisterProvider(provider);
});
RemoteSearch.loadRemoteSearchProviders(this._searchSettings, providers => {
providers.forEach(this._registerProvider.bind(this));
});
}
_registerProvider(provider) {
provider.searchInProgress = false;
this._providers.push(provider);
this._ensureProviderDisplay(provider);
}
_unregisterProvider(provider) {
let index = this._providers.indexOf(provider);
this._providers.splice(index, 1);
if (provider.display)
provider.display.destroy();
}
_gotResults(results, provider) {
this._results[provider.id] = results;
this._updateResults(provider, results);
}
_clearSearchTimeout() {
2014-09-30 06:19:28 +00:00
if (this._searchTimeoutId > 0) {
GLib.source_remove(this._searchTimeoutId);
this._searchTimeoutId = 0;
}
}
2014-09-30 06:19:28 +00:00
_reset() {
this._terms = [];
this._results = {};
this._clearDisplay();
this._clearSearchTimeout();
this._defaultResult = null;
this._startingSearch = false;
this._updateSearchProgress();
}
_doSearch() {
this._startingSearch = false;
let previousResults = this._results;
this._results = {};
this._providers.forEach(provider => {
provider.searchInProgress = true;
let previousProviderResults = previousResults[provider.id];
if (this._isSubSearch && previousProviderResults)
provider.getSubsearchResultSet(previousProviderResults,
this._terms,
results => {
this._gotResults(results, provider);
},
this._cancellable);
else
provider.getInitialResultSet(this._terms,
results => {
this._gotResults(results, provider);
},
this._cancellable);
});
this._updateSearchProgress();
2014-09-30 06:19:28 +00:00
this._clearSearchTimeout();
}
_onSearchTimeout() {
this._searchTimeoutId = 0;
this._doSearch();
return GLib.SOURCE_REMOVE;
}
setTerms(terms) {
// Check for the case of making a duplicate previous search before
// setting state of the current search or cancelling the search.
// This will prevent incorrect state being as a result of a duplicate
// search while the previous search is still active.
let searchString = terms.join(' ');
let previousSearchString = this._terms.join(' ');
if (searchString == previousSearchString)
return;
this._startingSearch = true;
this._cancellable.cancel();
this._cancellable.reset();
if (terms.length == 0) {
this._reset();
return;
}
let isSubSearch = false;
if (this._terms.length > 0)
isSubSearch = searchString.indexOf(previousSearchString) == 0;
this._terms = terms;
this._isSubSearch = isSubSearch;
this._updateSearchProgress();
if (this._searchTimeoutId == 0)
this._searchTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 150, this._onSearchTimeout.bind(this));
let escapedTerms = this._terms.map(term => Shell.util_regex_escape(term));
this._highlightRegex = new RegExp(`(${escapedTerms.join('|')})`, 'gi');
this.emit('terms-changed');
}
_onPan(action) {
let [dist_, dx_, dy] = action.get_motion_delta(0);
let adjustment = this._scrollView.vscroll.adjustment;
adjustment.value -= (dy / this.height) * adjustment.page_size;
return false;
}
_focusChildChanged(provider) {
Util.ensureActorVisibleInScrollView(this._scrollView, provider.focusChild);
}
_ensureProviderDisplay(provider) {
if (provider.display)
return;
let providerDisplay;
if (provider.appInfo)
providerDisplay = new ListSearchResults(provider, this);
else
providerDisplay = new GridSearchResults(provider, this);
providerDisplay.connect('notify::focus-child', this._focusChildChanged.bind(this));
providerDisplay.hide();
this._content.add(providerDisplay);
provider.display = providerDisplay;
}
_clearDisplay() {
this._providers.forEach(provider => {
provider.display.clear();
});
}
_maybeSetInitialSelection() {
let newDefaultResult = null;
let providers = this._providers;
for (let i = 0; i < providers.length; i++) {
let provider = providers[i];
let display = provider.display;
if (!display.visible)
continue;
let firstResult = display.getFirstResult();
if (firstResult) {
newDefaultResult = firstResult;
break; // select this one!
}
}
if (newDefaultResult != this._defaultResult) {
this._setSelected(this._defaultResult, false);
this._setSelected(newDefaultResult, this._highlightDefault);
this._defaultResult = newDefaultResult;
}
}
get searchInProgress() {
if (this._startingSearch)
return true;
return this._providers.some(p => p.searchInProgress);
}
_updateSearchProgress() {
let haveResults = this._providers.some(provider => {
let display = provider.display;
return (display.getFirstResult() != null);
});
this._scrollView.visible = haveResults;
this._statusBin.visible = !haveResults;
2014-09-11 23:14:54 +00:00
if (!haveResults) {
if (this.searchInProgress) {
this._statusText.set_text(_("Searching…"));
} else {
this._statusText.set_text(_("No results."));
}
2014-09-11 23:14:54 +00:00
}
}
_updateResults(provider, results) {
let terms = this._terms;
let display = provider.display;
display.updateSearch(results, terms, () => {
provider.searchInProgress = false;
this._maybeSetInitialSelection();
this._updateSearchProgress();
});
}
activateDefault() {
// If we have a search queued up, force the search now.
if (this._searchTimeoutId > 0)
this._doSearch();
if (this._defaultResult)
this._defaultResult.activate();
}
highlightDefault(highlight) {
this._highlightDefault = highlight;
this._setSelected(this._defaultResult, highlight);
}
popupMenuDefault() {
// If we have a search queued up, force the search now.
if (this._searchTimeoutId > 0)
this._doSearch();
if (this._defaultResult)
this._defaultResult.popup_menu();
}
navigateFocus(direction) {
let rtl = this.get_text_direction() == Clutter.TextDirection.RTL;
if (direction == St.DirectionType.TAB_BACKWARD ||
direction == (rtl
? St.DirectionType.RIGHT
: St.DirectionType.LEFT) ||
direction == St.DirectionType.UP) {
this.navigate_focus(null, direction, false);
return;
}
let from = this._defaultResult ? this._defaultResult : null;
this.navigate_focus(from, direction, false);
}
_setSelected(result, selected) {
if (!result)
return;
if (selected) {
result.add_style_pseudo_class('selected');
Util.ensureActorVisibleInScrollView(this._scrollView, result);
} else {
result.remove_style_pseudo_class('selected');
}
}
highlightTerms(description) {
if (!description)
return '';
if (!this._highlightRegex)
return description;
return description.replace(this._highlightRegex, '<b>$1</b>');
}
});
var ProviderInfo = GObject.registerClass(
class ProviderInfo extends St.Button {
_init(provider) {
this.provider = provider;
super._init({ style_class: 'search-provider-icon',
reactive: true,
can_focus: true,
accessible_name: provider.appInfo.get_name(),
track_hover: true });
this._content = new St.BoxLayout({ vertical: false,
style_class: 'list-search-provider-content' });
this.set_child(this._content);
let icon = new St.Icon({ icon_size: this.PROVIDER_ICON_SIZE,
gicon: provider.appInfo.get_icon() });
let detailsBox = new St.BoxLayout({ style_class: 'list-search-provider-details',
vertical: true,
x_expand: true });
let nameLabel = new St.Label({ text: provider.appInfo.get_name(),
x_align: Clutter.ActorAlign.START });
this._moreLabel = new St.Label({ x_align: Clutter.ActorAlign.START });
detailsBox.add_actor(nameLabel);
detailsBox.add_actor(this._moreLabel);
this._content.add_actor(icon);
this._content.add_actor(detailsBox);
}
get PROVIDER_ICON_SIZE() {
return 32;
}
animateLaunch() {
let appSys = Shell.AppSystem.get_default();
let app = appSys.lookup_app(this.provider.appInfo.get_id());
if (app.state == Shell.AppState.STOPPED)
IconGrid.zoomOutActor(this._content);
}
setMoreCount(count) {
this._moreLabel.text = ngettext("%d more", "%d more", count).format(count);
this._moreLabel.visible = count > 0;
}
});