2011-09-28 09:16:26 -04:00
|
|
|
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
2009-08-06 09:06:33 -04:00
|
|
|
|
|
|
|
const GLib = imports.gi.GLib;
|
|
|
|
const Gio = imports.gi.Gio;
|
|
|
|
const Shell = imports.gi.Shell;
|
|
|
|
const Lang = imports.lang;
|
|
|
|
const Mainloop = imports.mainloop;
|
|
|
|
const Signals = imports.signals;
|
2009-11-06 16:08:07 -05:00
|
|
|
const St = imports.gi.St;
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2009-08-19 16:55:39 -04:00
|
|
|
const DND = imports.ui.dnd;
|
2009-08-06 09:06:33 -04:00
|
|
|
const Main = imports.ui.main;
|
2011-01-30 16:09:58 -05:00
|
|
|
const Params = imports.misc.params;
|
2009-11-29 17:45:30 -05:00
|
|
|
const Search = imports.ui.search;
|
2010-11-17 11:43:08 -05:00
|
|
|
const Util = imports.misc.util;
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2009-08-19 16:55:39 -04:00
|
|
|
/**
|
2009-10-31 22:25:28 -04:00
|
|
|
* Represents a place object, which is most normally a bookmark entry,
|
|
|
|
* a mount/volume, or a special place like the Home Folder, Computer, and Network.
|
|
|
|
*
|
2009-08-19 16:55:39 -04:00
|
|
|
* @name: String title
|
2009-10-31 22:25:28 -04:00
|
|
|
* @iconFactory: A JavaScript callback which will create an icon texture given a size parameter
|
|
|
|
* @launch: A JavaScript callback to launch the entry
|
2009-08-19 16:55:39 -04:00
|
|
|
*/
|
2009-11-29 17:45:30 -05:00
|
|
|
function PlaceInfo(id, name, iconFactory, launch) {
|
|
|
|
this._init(id, name, iconFactory, launch);
|
2009-08-06 09:06:33 -04:00
|
|
|
}
|
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
PlaceInfo.prototype = {
|
2009-11-29 17:45:30 -05:00
|
|
|
_init: function(id, name, iconFactory, launch) {
|
|
|
|
this.id = id;
|
2009-10-31 22:25:28 -04:00
|
|
|
this.name = name;
|
2009-11-29 17:45:30 -05:00
|
|
|
this._lowerName = name.toLowerCase();
|
2009-10-31 22:25:28 -04:00
|
|
|
this.iconFactory = iconFactory;
|
|
|
|
this.launch = launch;
|
2009-11-29 17:45:30 -05:00
|
|
|
},
|
|
|
|
|
|
|
|
matchTerms: function(terms) {
|
|
|
|
let mtype = Search.MatchType.NONE;
|
|
|
|
for (let i = 0; i < terms.length; i++) {
|
|
|
|
let term = terms[i];
|
|
|
|
let idx = this._lowerName.indexOf(term);
|
2010-06-06 19:09:15 -04:00
|
|
|
if (idx == 0) {
|
|
|
|
mtype = Search.MatchType.PREFIX;
|
|
|
|
} else if (idx > 0) {
|
|
|
|
if (mtype == Search.MatchType.NONE)
|
|
|
|
mtype = Search.MatchType.SUBSTRING;
|
|
|
|
} else {
|
|
|
|
return Search.MatchType.NONE;
|
|
|
|
}
|
2009-11-29 17:45:30 -05:00
|
|
|
}
|
|
|
|
return mtype;
|
2009-11-27 06:20:02 -05:00
|
|
|
},
|
|
|
|
|
|
|
|
isRemovable: function() {
|
|
|
|
return false;
|
|
|
|
}
|
2010-03-15 09:50:05 -04:00
|
|
|
};
|
2009-11-27 06:20:02 -05:00
|
|
|
|
2011-01-30 16:09:58 -05:00
|
|
|
// Helper function to translate launch parameters into a GAppLaunchContext
|
|
|
|
function _makeLaunchContext(params)
|
|
|
|
{
|
2011-08-11 05:35:23 -04:00
|
|
|
params = Params.parse(params, { workspace: -1,
|
|
|
|
timestamp: 0 });
|
2011-01-30 16:09:58 -05:00
|
|
|
|
|
|
|
let launchContext = global.create_app_launch_context();
|
2011-08-11 05:35:23 -04:00
|
|
|
if (params.workspace != -1)
|
|
|
|
launchContext.set_desktop(params.workspace);
|
|
|
|
if (params.timestamp != 0)
|
2011-01-30 16:09:58 -05:00
|
|
|
launchContext.set_timestamp(params.timestamp);
|
|
|
|
|
|
|
|
return launchContext;
|
|
|
|
}
|
|
|
|
|
2009-11-27 06:20:02 -05:00
|
|
|
function PlaceDeviceInfo(mount) {
|
|
|
|
this._init(mount);
|
|
|
|
}
|
|
|
|
|
|
|
|
PlaceDeviceInfo.prototype = {
|
|
|
|
__proto__: PlaceInfo.prototype,
|
|
|
|
|
|
|
|
_init: function(mount) {
|
|
|
|
this._mount = mount;
|
|
|
|
this.name = mount.get_name();
|
|
|
|
this._lowerName = this.name.toLowerCase();
|
2010-05-13 15:46:04 -04:00
|
|
|
this.id = 'mount:' + mount.get_root().get_uri();
|
2009-11-27 06:20:02 -05:00
|
|
|
},
|
|
|
|
|
|
|
|
iconFactory: function(size) {
|
|
|
|
let icon = this._mount.get_icon();
|
2010-09-26 11:18:26 -04:00
|
|
|
return St.TextureCache.get_default().load_gicon(null, icon, size);
|
2009-11-27 06:20:02 -05:00
|
|
|
},
|
|
|
|
|
2011-02-13 09:49:57 -05:00
|
|
|
launch: function(params) {
|
2009-11-27 06:20:02 -05:00
|
|
|
Gio.app_info_launch_default_for_uri(this._mount.get_root().get_uri(),
|
2011-02-12 21:46:50 -05:00
|
|
|
_makeLaunchContext(params));
|
2009-11-27 06:20:02 -05:00
|
|
|
},
|
|
|
|
|
|
|
|
isRemovable: function() {
|
|
|
|
return this._mount.can_unmount();
|
|
|
|
},
|
|
|
|
|
|
|
|
remove: function() {
|
|
|
|
if (!this.isRemovable())
|
|
|
|
return;
|
|
|
|
|
2010-03-20 09:52:40 -04:00
|
|
|
if (this._mount.can_eject())
|
|
|
|
this._mount.eject(0, null, Lang.bind(this, this._removeFinish));
|
|
|
|
else
|
|
|
|
this._mount.unmount(0, null, Lang.bind(this, this._removeFinish));
|
2009-11-27 06:20:02 -05:00
|
|
|
},
|
|
|
|
|
|
|
|
_removeFinish: function(o, res, data) {
|
2010-03-10 09:25:08 -05:00
|
|
|
try {
|
2010-03-20 09:52:40 -04:00
|
|
|
if (this._mount.can_eject())
|
|
|
|
this._mount.eject_finish(res);
|
|
|
|
else
|
|
|
|
this._mount.unmount_finish(res);
|
2010-03-10 09:25:08 -05:00
|
|
|
} catch (e) {
|
|
|
|
let message = _("Failed to unmount '%s'").format(o.get_name());
|
2011-08-28 10:07:44 -04:00
|
|
|
Main.overview.setMessage(message,
|
|
|
|
Lang.bind(this, this.remove),
|
|
|
|
_("Retry"));
|
2010-03-10 09:25:08 -05:00
|
|
|
}
|
2009-08-06 09:06:33 -04:00
|
|
|
}
|
2010-03-15 09:50:05 -04:00
|
|
|
};
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
function PlacesManager() {
|
|
|
|
this._init();
|
|
|
|
}
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
PlacesManager.prototype = {
|
|
|
|
_init: function() {
|
2009-11-29 17:45:30 -05:00
|
|
|
this._defaultPlaces = [];
|
2009-10-31 22:25:28 -04:00
|
|
|
this._mounts = [];
|
|
|
|
this._bookmarks = [];
|
2011-01-16 14:18:09 -05:00
|
|
|
|
2009-08-06 09:06:33 -04:00
|
|
|
let homeFile = Gio.file_new_for_path (GLib.get_home_dir());
|
|
|
|
let homeUri = homeFile.get_uri();
|
|
|
|
let homeLabel = Shell.util_get_label_for_uri (homeUri);
|
|
|
|
let homeIcon = Shell.util_get_icon_for_uri (homeUri);
|
2009-11-29 17:45:30 -05:00
|
|
|
this._home = new PlaceInfo('special:home', homeLabel,
|
2009-10-31 22:25:28 -04:00
|
|
|
function(size) {
|
2010-09-26 11:18:26 -04:00
|
|
|
return St.TextureCache.get_default().load_gicon(null, homeIcon, size);
|
2009-08-19 16:55:39 -04:00
|
|
|
},
|
2011-01-30 16:09:58 -05:00
|
|
|
function(params) {
|
|
|
|
Gio.app_info_launch_default_for_uri(homeUri, _makeLaunchContext(params));
|
2009-08-19 16:55:39 -04:00
|
|
|
});
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2009-10-01 06:18:13 -04:00
|
|
|
let desktopPath = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DESKTOP);
|
|
|
|
let desktopFile = Gio.file_new_for_path (desktopPath);
|
|
|
|
let desktopUri = desktopFile.get_uri();
|
|
|
|
let desktopLabel = Shell.util_get_label_for_uri (desktopUri);
|
|
|
|
let desktopIcon = Shell.util_get_icon_for_uri (desktopUri);
|
2009-11-29 17:45:30 -05:00
|
|
|
this._desktopMenu = new PlaceInfo('special:desktop', desktopLabel,
|
2009-10-31 22:25:28 -04:00
|
|
|
function(size) {
|
2010-09-26 11:18:26 -04:00
|
|
|
return St.TextureCache.get_default().load_gicon(null, desktopIcon, size);
|
2009-10-01 06:18:13 -04:00
|
|
|
},
|
2011-01-30 16:09:58 -05:00
|
|
|
function(params) {
|
|
|
|
Gio.app_info_launch_default_for_uri(desktopUri, _makeLaunchContext(params));
|
2009-10-01 06:18:13 -04:00
|
|
|
});
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
this._connect = new PlaceInfo('special:connect', _("Connect to..."),
|
2009-10-31 22:25:28 -04:00
|
|
|
function (size) {
|
2010-11-02 18:33:22 -04:00
|
|
|
return new St.Icon({ icon_name: 'applications-internet',
|
|
|
|
icon_type: St.IconType.FULLCOLOR,
|
|
|
|
icon_size: size });
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
2011-01-30 16:09:58 -05:00
|
|
|
function (params) {
|
|
|
|
// BUG: nautilus-connect-server doesn't have a desktop file, so we can't
|
|
|
|
// launch it with the workspace from params. It's probably pretty rare
|
|
|
|
// and odd to drag this place onto a workspace in any case
|
|
|
|
|
2010-11-17 11:43:08 -05:00
|
|
|
Util.spawn(['nautilus-connect-server']);
|
2009-10-31 22:25:28 -04:00
|
|
|
});
|
2009-09-02 14:41:32 -04:00
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
this._defaultPlaces.push(this._home);
|
2011-01-17 14:52:26 -05:00
|
|
|
this._defaultPlaces.push(this._desktopMenu);
|
2009-11-29 17:45:30 -05:00
|
|
|
this._defaultPlaces.push(this._connect);
|
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
/*
|
|
|
|
* Show devices, code more or less ported from nautilus-places-sidebar.c
|
|
|
|
*/
|
|
|
|
this._volumeMonitor = Gio.VolumeMonitor.get();
|
|
|
|
this._volumeMonitor.connect('volume-added', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('volume-removed',Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('volume-changed', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('mount-added', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('mount-removed', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('mount-changed', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('drive-connected', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('drive-disconnected', Lang.bind(this, this._updateDevices));
|
|
|
|
this._volumeMonitor.connect('drive-changed', Lang.bind(this, this._updateDevices));
|
|
|
|
this._updateDevices();
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2010-05-13 15:46:04 -04:00
|
|
|
this._bookmarksPath = GLib.build_filenamev([GLib.get_home_dir(), '.gtk-bookmarks']);
|
2009-08-06 09:06:33 -04:00
|
|
|
this._bookmarksFile = Gio.file_new_for_path(this._bookmarksPath);
|
2011-10-16 12:30:13 -04:00
|
|
|
this._monitor = this._bookmarksFile.monitor_file(Gio.FileMonitorFlags.NONE, null);
|
2009-08-12 12:29:33 -04:00
|
|
|
this._bookmarkTimeoutId = 0;
|
2011-10-16 12:30:13 -04:00
|
|
|
this._monitor.connect('changed', Lang.bind(this, function () {
|
2009-08-12 12:29:33 -04:00
|
|
|
if (this._bookmarkTimeoutId > 0)
|
2009-08-06 09:06:33 -04:00
|
|
|
return;
|
|
|
|
/* Defensive event compression */
|
2009-08-12 12:29:33 -04:00
|
|
|
this._bookmarkTimeoutId = Mainloop.timeout_add(100, Lang.bind(this, function () {
|
|
|
|
this._bookmarkTimeoutId = 0;
|
2009-08-06 09:06:33 -04:00
|
|
|
this._reloadBookmarks();
|
|
|
|
return false;
|
|
|
|
}));
|
|
|
|
}));
|
|
|
|
|
|
|
|
this._reloadBookmarks();
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
|
|
|
_updateDevices: function() {
|
|
|
|
this._mounts = [];
|
|
|
|
|
|
|
|
/* first go through all connected drives */
|
|
|
|
let drives = this._volumeMonitor.get_connected_drives();
|
|
|
|
for (let i = 0; i < drives.length; i++) {
|
|
|
|
let volumes = drives[i].get_volumes();
|
|
|
|
for(let j = 0; j < volumes.length; j++) {
|
|
|
|
let mount = volumes[j].get_mount();
|
|
|
|
if(mount != null) {
|
|
|
|
this._addMount(mount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add all volumes that is not associated with a drive */
|
|
|
|
let volumes = this._volumeMonitor.get_volumes();
|
|
|
|
for(let i = 0; i < volumes.length; i++) {
|
|
|
|
if(volumes[i].get_drive() != null)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
let mount = volumes[i].get_mount();
|
|
|
|
if(mount != null) {
|
|
|
|
this._addMount(mount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add mounts that have no volume (/etc/mtab mounts, ftp, sftp,...) */
|
|
|
|
let mounts = this._volumeMonitor.get_mounts();
|
|
|
|
for(let i = 0; i < mounts.length; i++) {
|
|
|
|
if(mounts[i].is_shadowed())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if(mounts[i].get_volume())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
this._addMount(mounts[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We emit two signals, one for a generic 'all places' update
|
|
|
|
* and the other for one specific to mounts. We do this because
|
|
|
|
* clients like PlaceDisplay may only care about places in general
|
|
|
|
* being updated while clients like DashPlaceDisplay care which
|
|
|
|
* specific type of place got updated.
|
|
|
|
*/
|
|
|
|
this.emit('mounts-updated');
|
|
|
|
this.emit('places-updated');
|
|
|
|
|
2009-08-06 09:06:33 -04:00
|
|
|
},
|
|
|
|
|
|
|
|
_reloadBookmarks: function() {
|
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
this._bookmarks = [];
|
2009-08-06 09:06:33 -04:00
|
|
|
|
2009-08-20 16:39:04 -04:00
|
|
|
if (!GLib.file_test(this._bookmarksPath, GLib.FileTest.EXISTS))
|
2009-10-31 22:25:28 -04:00
|
|
|
return;
|
2009-08-20 16:39:04 -04:00
|
|
|
|
2011-05-11 14:19:24 -04:00
|
|
|
let bookmarksContent = Shell.get_file_contents_utf8_sync(this._bookmarksPath);
|
2009-08-06 09:06:33 -04:00
|
|
|
|
|
|
|
let bookmarks = bookmarksContent.split('\n');
|
|
|
|
|
|
|
|
let bookmarksToLabel = {};
|
|
|
|
let bookmarksOrder = [];
|
|
|
|
for (let i = 0; i < bookmarks.length; i++) {
|
|
|
|
let bookmarkLine = bookmarks[i];
|
|
|
|
let components = bookmarkLine.split(' ');
|
|
|
|
let bookmark = components[0];
|
|
|
|
if (bookmark in bookmarksToLabel)
|
|
|
|
continue;
|
|
|
|
let label = null;
|
|
|
|
if (components.length > 1)
|
2009-08-09 13:19:07 -04:00
|
|
|
label = components.slice(1).join(' ');
|
2009-08-06 09:06:33 -04:00
|
|
|
bookmarksToLabel[bookmark] = label;
|
|
|
|
bookmarksOrder.push(bookmark);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (let i = 0; i < bookmarksOrder.length; i++) {
|
|
|
|
let bookmark = bookmarksOrder[i];
|
|
|
|
let label = bookmarksToLabel[bookmark];
|
|
|
|
let file = Gio.file_new_for_uri(bookmark);
|
|
|
|
if (!file.query_exists(null))
|
|
|
|
continue;
|
|
|
|
if (label == null)
|
|
|
|
label = Shell.util_get_label_for_uri(bookmark);
|
|
|
|
if (label == null)
|
|
|
|
continue;
|
|
|
|
let icon = Shell.util_get_icon_for_uri(bookmark);
|
2009-08-19 16:55:39 -04:00
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
let item = new PlaceInfo('bookmark:' + bookmark, label,
|
2009-10-31 22:25:28 -04:00
|
|
|
function(size) {
|
2010-09-26 11:18:26 -04:00
|
|
|
return St.TextureCache.get_default().load_gicon(null, icon, size);
|
2009-08-19 16:55:39 -04:00
|
|
|
},
|
2011-01-30 16:09:58 -05:00
|
|
|
function(params) {
|
|
|
|
Gio.app_info_launch_default_for_uri(bookmark, _makeLaunchContext(params));
|
2009-08-19 16:55:39 -04:00
|
|
|
});
|
2009-10-31 22:25:28 -04:00
|
|
|
this._bookmarks.push(item);
|
2009-09-02 14:41:32 -04:00
|
|
|
}
|
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
/* See comment in _updateDevices for explanation why there are two signals. */
|
|
|
|
this.emit('bookmarks-updated');
|
|
|
|
this.emit('places-updated');
|
|
|
|
},
|
2009-09-02 14:41:32 -04:00
|
|
|
|
|
|
|
_addMount: function(mount) {
|
2009-11-27 06:20:02 -05:00
|
|
|
let devItem = new PlaceDeviceInfo(mount);
|
2009-10-31 22:25:28 -04:00
|
|
|
this._mounts.push(devItem);
|
2009-10-01 06:18:13 -04:00
|
|
|
},
|
2009-09-02 14:41:32 -04:00
|
|
|
|
2009-10-31 22:25:28 -04:00
|
|
|
getAllPlaces: function () {
|
|
|
|
return this.getDefaultPlaces().concat(this.getBookmarks(), this.getMounts());
|
|
|
|
},
|
|
|
|
|
|
|
|
getDefaultPlaces: function () {
|
2009-11-29 17:45:30 -05:00
|
|
|
return this._defaultPlaces;
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
|
|
|
getBookmarks: function () {
|
|
|
|
return this._bookmarks;
|
|
|
|
},
|
|
|
|
|
|
|
|
getMounts: function () {
|
|
|
|
return this._mounts;
|
2009-11-29 17:45:30 -05:00
|
|
|
},
|
|
|
|
|
2010-01-14 10:23:47 -05:00
|
|
|
_lookupIndexById: function(sourceArray, id) {
|
2009-11-29 17:45:30 -05:00
|
|
|
for (let i = 0; i < sourceArray.length; i++) {
|
|
|
|
let place = sourceArray[i];
|
|
|
|
if (place.id == id)
|
2010-01-14 10:23:47 -05:00
|
|
|
return i;
|
2009-11-29 17:45:30 -05:00
|
|
|
}
|
2010-01-14 10:23:47 -05:00
|
|
|
return -1;
|
2009-11-29 17:45:30 -05:00
|
|
|
},
|
|
|
|
|
|
|
|
lookupPlaceById: function(id) {
|
|
|
|
let colonIdx = id.indexOf(':');
|
|
|
|
let type = id.substring(0, colonIdx);
|
|
|
|
let sourceArray = null;
|
|
|
|
if (type == 'special')
|
|
|
|
sourceArray = this._defaultPlaces;
|
|
|
|
else if (type == 'mount')
|
|
|
|
sourceArray = this._mounts;
|
|
|
|
else if (type == 'bookmark')
|
|
|
|
sourceArray = this._bookmarks;
|
2010-01-14 10:23:47 -05:00
|
|
|
return sourceArray[this._lookupIndexById(sourceArray, id)];
|
|
|
|
},
|
|
|
|
|
|
|
|
_removeById: function(sourceArray, id) {
|
|
|
|
sourceArray.splice(this._lookupIndexById(sourceArray, id), 1);
|
2009-10-31 22:25:28 -04:00
|
|
|
}
|
|
|
|
};
|
|
|
|
Signals.addSignalMethods(PlacesManager.prototype);
|
|
|
|
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
function PlaceSearchProvider() {
|
|
|
|
this._init();
|
2009-10-31 22:25:28 -04:00
|
|
|
}
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
PlaceSearchProvider.prototype = {
|
|
|
|
__proto__: Search.SearchProvider.prototype,
|
2009-10-31 22:25:28 -04:00
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
_init: function() {
|
2009-12-25 12:41:58 -05:00
|
|
|
Search.SearchProvider.prototype._init.call(this, _("PLACES & DEVICES"));
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
getResultMeta: function(resultId) {
|
|
|
|
let placeInfo = Main.placesManager.lookupPlaceById(resultId);
|
|
|
|
if (!placeInfo)
|
|
|
|
return null;
|
|
|
|
return { 'id': resultId,
|
|
|
|
'name': placeInfo.name,
|
2011-02-28 14:36:52 -05:00
|
|
|
'createIcon': function(size) {
|
|
|
|
return placeInfo.iconFactory(size);
|
|
|
|
}
|
|
|
|
};
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
2011-01-30 16:09:58 -05:00
|
|
|
activateResult: function(id, params) {
|
2009-11-29 17:45:30 -05:00
|
|
|
let placeInfo = Main.placesManager.lookupPlaceById(id);
|
2011-01-30 16:09:58 -05:00
|
|
|
placeInfo.launch(params);
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
_compareResultMeta: function (idA, idB) {
|
|
|
|
let infoA = Main.placesManager.lookupPlaceById(idA);
|
|
|
|
let infoB = Main.placesManager.lookupPlaceById(idB);
|
|
|
|
return infoA.name.localeCompare(infoB.name);
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
_searchPlaces: function(places, terms) {
|
2010-06-06 19:09:15 -04:00
|
|
|
let multiplePrefixResults = [];
|
2009-11-29 17:45:30 -05:00
|
|
|
let prefixResults = [];
|
2010-06-06 19:09:15 -04:00
|
|
|
let multipleSubstringResults = [];
|
2009-11-29 17:45:30 -05:00
|
|
|
let substringResults = [];
|
|
|
|
|
|
|
|
terms = terms.map(String.toLowerCase);
|
|
|
|
|
|
|
|
for (let i = 0; i < places.length; i++) {
|
|
|
|
let place = places[i];
|
|
|
|
let mtype = place.matchTerms(terms);
|
2010-06-06 19:09:15 -04:00
|
|
|
if (mtype == Search.MatchType.MULTIPLE_PREFIX)
|
|
|
|
multiplePrefixResults.push(place.id);
|
2009-11-29 17:45:30 -05:00
|
|
|
else if (mtype == Search.MatchType.PREFIX)
|
|
|
|
prefixResults.push(place.id);
|
2010-06-06 19:09:15 -04:00
|
|
|
else if (mtype == Search.MatchType.MULTIPLE_SUBSTRING)
|
|
|
|
multipleSubstringResults.push(place.id);
|
2009-11-29 17:45:30 -05:00
|
|
|
else if (mtype == Search.MatchType.SUBSTRING)
|
|
|
|
substringResults.push(place.id);
|
2009-10-31 22:25:28 -04:00
|
|
|
}
|
2010-06-06 19:09:15 -04:00
|
|
|
multiplePrefixResults.sort(this._compareResultMeta);
|
2009-11-29 17:45:30 -05:00
|
|
|
prefixResults.sort(this._compareResultMeta);
|
2010-06-06 19:09:15 -04:00
|
|
|
multipleSubstringResults.sort(this._compareResultMeta);
|
2009-11-29 17:45:30 -05:00
|
|
|
substringResults.sort(this._compareResultMeta);
|
2010-06-06 19:09:15 -04:00
|
|
|
return multiplePrefixResults.concat(prefixResults.concat(multipleSubstringResults.concat(substringResults)));
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
getInitialResultSet: function(terms) {
|
|
|
|
let places = Main.placesManager.getAllPlaces();
|
|
|
|
return this._searchPlaces(places, terms);
|
2009-10-31 22:25:28 -04:00
|
|
|
},
|
|
|
|
|
2009-11-29 17:45:30 -05:00
|
|
|
getSubsearchResultSet: function(previousResults, terms) {
|
|
|
|
let places = previousResults.map(function (id) { return Main.placesManager.lookupPlaceById(id); });
|
|
|
|
return this._searchPlaces(places, terms);
|
2009-10-01 06:18:13 -04:00
|
|
|
}
|
2010-03-15 09:50:05 -04:00
|
|
|
};
|