f7fff83647
Don't use a clone of an actor that's not part of the scene graph for the item previews. This patch fixes previews in the details pane for documents for which we don't have full previews and for applications. Use create_icon_texture() from AppInfo instead of looking up the file for gicon when creating an application icon for the details pane.
761 lines
26 KiB
JavaScript
761 lines
26 KiB
JavaScript
/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
|
|
const Big = imports.gi.Big;
|
|
const Clutter = imports.gi.Clutter;
|
|
const Pango = imports.gi.Pango;
|
|
const GLib = imports.gi.GLib;
|
|
const Gio = imports.gi.Gio;
|
|
const Gtk = imports.gi.Gtk;
|
|
const Tidy = imports.gi.Tidy;
|
|
const Shell = imports.gi.Shell;
|
|
const Lang = imports.lang;
|
|
const Signals = imports.signals;
|
|
const Mainloop = imports.mainloop;
|
|
|
|
const DND = imports.ui.dnd;
|
|
const GenericDisplay = imports.ui.genericDisplay;
|
|
const Workspaces = imports.ui.workspaces;
|
|
|
|
const ENTERED_MENU_COLOR = new Clutter.Color();
|
|
ENTERED_MENU_COLOR.from_pixel(0x00ff0022);
|
|
|
|
const GLOW_COLOR = new Clutter.Color();
|
|
GLOW_COLOR.from_pixel(0x4f6ba4ff);
|
|
const GLOW_PADDING = 5;
|
|
|
|
const APP_ICON_SIZE = 48;
|
|
const APP_PADDING = 18;
|
|
|
|
const MENU_ICON_SIZE = 24;
|
|
const MENU_SPACING = 15;
|
|
|
|
const MAX_ITEMS = 30;
|
|
|
|
/* This class represents a single display item containing information about an application.
|
|
*
|
|
* appInfo - AppInfo object containing information about the application
|
|
* availableWidth - total width available for the item
|
|
*/
|
|
function AppDisplayItem(appInfo, availableWidth) {
|
|
this._init(appInfo, availableWidth);
|
|
}
|
|
|
|
AppDisplayItem.prototype = {
|
|
__proto__: GenericDisplay.GenericDisplayItem.prototype,
|
|
|
|
_init : function(appInfo, availableWidth) {
|
|
GenericDisplay.GenericDisplayItem.prototype._init.call(this, availableWidth);
|
|
this._appInfo = appInfo;
|
|
|
|
this._setItemInfo(appInfo.get_name(), appInfo.get_description());
|
|
},
|
|
|
|
getId: function() {
|
|
return this._appInfo.get_id();
|
|
},
|
|
|
|
//// Public method overrides ////
|
|
|
|
// Opens an application represented by this display item.
|
|
launch : function() {
|
|
this._appInfo.launch();
|
|
},
|
|
|
|
//// Protected method overrides ////
|
|
|
|
// Returns an icon for the item.
|
|
_createIcon : function() {
|
|
return this._appInfo.create_icon_texture(GenericDisplay.ITEM_DISPLAY_ICON_SIZE);
|
|
},
|
|
|
|
// Returns a preview icon for the item.
|
|
_createPreviewIcon : function() {
|
|
return this._appInfo.create_icon_texture(GenericDisplay.PREVIEW_ICON_SIZE);
|
|
}
|
|
};
|
|
|
|
const MENU_UNSELECTED = 0;
|
|
const MENU_SELECTED = 1;
|
|
const MENU_ENTERED = 2;
|
|
|
|
function MenuItem(name, id, iconName) {
|
|
this._init(name, id, iconName);
|
|
}
|
|
|
|
/**
|
|
* MenuItem:
|
|
* Shows the list of menus in the sidebar.
|
|
*/
|
|
MenuItem.prototype = {
|
|
_init: function(name, id, iconName) {
|
|
this.id = id;
|
|
|
|
this.actor = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
spacing: 4,
|
|
corner_radius: 4,
|
|
padding_right: 4,
|
|
reactive: true });
|
|
this.actor.connect('button-press-event', Lang.bind(this, function (a, e) {
|
|
this.setState(MENU_SELECTED);
|
|
}));
|
|
|
|
let iconTheme = Gtk.IconTheme.get_default();
|
|
let pixbuf = null;
|
|
this._icon = new Clutter.Texture({ width: MENU_ICON_SIZE,
|
|
height: MENU_ICON_SIZE });
|
|
// Wine manages not to have an icon
|
|
try {
|
|
pixbuf = iconTheme.load_icon(iconName, MENU_ICON_SIZE, 0 /* flags */);
|
|
} catch (e) {
|
|
pixbuf = iconTheme.load_icon('gtk-file', MENU_ICON_SIZE, 0);
|
|
}
|
|
if (pixbuf != null)
|
|
Shell.clutter_texture_set_from_pixbuf(this._icon, pixbuf);
|
|
this.actor.append(this._icon, Big.BoxPackFlags.NONE);
|
|
this._text = new Clutter.Text({ color: GenericDisplay.ITEM_DISPLAY_NAME_COLOR,
|
|
font_name: "Sans 14px",
|
|
ellipsize: Pango.EllipsizeMode.END,
|
|
text: name });
|
|
|
|
// We use individual boxes for the label and the arrow to ensure that they
|
|
// are aligned vertically. Just setting y_align: Big.BoxAlignment.CENTER
|
|
// on this.actor does not seem to achieve that.
|
|
let labelBox = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
|
|
|
|
labelBox.append(this._text, Big.BoxPackFlags.NONE);
|
|
|
|
this.actor.append(labelBox, Big.BoxPackFlags.EXPAND);
|
|
|
|
let arrowBox = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
|
|
|
|
this._arrow = new Shell.Arrow({ surface_width: MENU_ICON_SIZE / 2,
|
|
surface_height: MENU_ICON_SIZE / 2,
|
|
direction: Gtk.ArrowType.RIGHT,
|
|
opacity: 0 });
|
|
arrowBox.append(this._arrow, Big.BoxPackFlags.NONE);
|
|
this.actor.append(arrowBox, Big.BoxPackFlags.NONE);
|
|
},
|
|
|
|
getState: function() {
|
|
return this._state;
|
|
},
|
|
|
|
setState: function (state) {
|
|
if (state == this._state)
|
|
return;
|
|
this._state = state;
|
|
if (this._state == MENU_UNSELECTED) {
|
|
this.actor.background_color = null;
|
|
this._arrow.set_opacity(0);
|
|
} else if (this._state == MENU_ENTERED) {
|
|
this.actor.background_color = ENTERED_MENU_COLOR;
|
|
this._arrow.set_opacity(0xFF/2);
|
|
} else {
|
|
this.actor.background_color = GenericDisplay.ITEM_DISPLAY_SELECTED_BACKGROUND_COLOR;
|
|
this._arrow.set_opacity(0xFF);
|
|
}
|
|
this.emit('state-changed')
|
|
}
|
|
}
|
|
Signals.addSignalMethods(MenuItem.prototype);
|
|
|
|
|
|
/* This class represents a display containing a collection of application items.
|
|
* The applications are sorted based on their popularity by default, and based on
|
|
* their name if some search filter is applied.
|
|
*
|
|
* width - width available for the display
|
|
*/
|
|
function AppDisplay(width) {
|
|
this._init(width);
|
|
}
|
|
|
|
AppDisplay.prototype = {
|
|
__proto__: GenericDisplay.GenericDisplay.prototype,
|
|
|
|
_init : function(width) {
|
|
GenericDisplay.GenericDisplay.prototype._init.call(this, width);
|
|
|
|
this._menus = [];
|
|
this._menuDisplays = [];
|
|
|
|
// map<itemId, array of category names>
|
|
this._appCategories = {};
|
|
|
|
this._appMonitor = Shell.AppMonitor.get_default();
|
|
this._appSystem = Shell.AppSystem.get_default();
|
|
this._appsStale = true;
|
|
this._appSystem.connect('installed-changed', Lang.bind(this, function(appSys) {
|
|
this._appsStale = true;
|
|
this._redisplay(false);
|
|
this._redisplayMenus();
|
|
}));
|
|
this._appSystem.connect('favorites-changed', Lang.bind(this, function(appSys) {
|
|
this._redisplay(false);
|
|
}));
|
|
this._appMonitor.connect('changed', Lang.bind(this, function(monitor) {
|
|
this._redisplay(false);
|
|
}));
|
|
|
|
// Load the apps now so it doesn't slow down the first
|
|
// transition into the overlay
|
|
this._refreshCache();
|
|
|
|
this._focusInMenus = true;
|
|
this._activeMenuIndex = -1;
|
|
this._activeMenu = null;
|
|
this._activeMenuApps = null;
|
|
this._menuDisplay = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
|
|
spacing: MENU_SPACING
|
|
});
|
|
this._redisplayMenus();
|
|
|
|
this.connect('expanded', Lang.bind(this, function (self) {
|
|
this._filterReset();
|
|
}));
|
|
this._filterReset();
|
|
},
|
|
|
|
moveRight: function() {
|
|
if (this._expanded && this._focusInMenu) {
|
|
this._focusInMenu = false;
|
|
this._activeMenu.setState(MENU_ENTERED);
|
|
this.selectFirstItem();
|
|
}
|
|
},
|
|
|
|
moveLeft: function() {
|
|
if (this._expanded && !this._focusInMenu) {
|
|
this._activeMenu.setState(MENU_SELECTED);
|
|
this.unsetSelected();
|
|
this._focusInMenu = true;
|
|
}
|
|
},
|
|
|
|
// Override genericDisplay.js
|
|
getNavigationArea: function() {
|
|
return this._menuDisplay;
|
|
},
|
|
|
|
selectUp: function() {
|
|
if (!(this._expanded && this._focusInMenu))
|
|
return GenericDisplay.GenericDisplay.prototype.selectUp.call(this);
|
|
this._selectMenuIndex(this._activeMenuIndex - 1);
|
|
return true;
|
|
},
|
|
|
|
selectDown: function() {
|
|
if (!(this._expanded && this._focusInMenu))
|
|
return GenericDisplay.GenericDisplay.prototype.selectDown.call(this);
|
|
this._selectMenuIndex(this._activeMenuIndex+1);
|
|
return true;
|
|
},
|
|
|
|
// Protected overrides
|
|
|
|
_filterActive: function() {
|
|
// We always have a filter now since a menu must be selected
|
|
return true;
|
|
},
|
|
|
|
_filterReset: function() {
|
|
GenericDisplay.GenericDisplay.prototype._filterReset.call(this);
|
|
this._selectMenuIndex(0);
|
|
},
|
|
|
|
//// Private ////
|
|
|
|
_emitStateChange: function() {
|
|
this.emit('state-changed');
|
|
},
|
|
|
|
_selectMenuIndex: function(index) {
|
|
if (index < 0 || index >= this._menus.length)
|
|
return;
|
|
this._menuDisplays[index].setState(MENU_SELECTED);
|
|
},
|
|
|
|
_getMostUsed: function() {
|
|
return this._appMonitor.get_most_used_apps(0, 30).map(Lang.bind(this, function (id) {
|
|
return this._appSystem.lookup_app(id + '.desktop');
|
|
})).filter(function (e) { return e != null });
|
|
},
|
|
|
|
_addMenuItem: function(name, id, icon, index) {
|
|
let display = new MenuItem(name, id, icon);
|
|
this._menuDisplays.push(display);
|
|
display.connect('state-changed', Lang.bind(this, function (display) {
|
|
let activated = display.getState() != MENU_UNSELECTED;
|
|
if (!activated && display == this._activeMenu) {
|
|
this._activeMenuIndex = -1;
|
|
this._activeMenu = null;
|
|
} else if (activated) {
|
|
if (display != this._activeMenu && this._activeMenu != null)
|
|
this._activeMenu.setState(MENU_UNSELECTED);
|
|
this._activeMenuIndex = index;
|
|
this._activeMenu = display;
|
|
if (id == null) {
|
|
this._activeMenuApps = this._getMostUsed();
|
|
} else {
|
|
this._activeMenuApps = this._appSystem.get_applications_for_menu(id);
|
|
}
|
|
}
|
|
this._redisplay(true);
|
|
}));
|
|
this._menuDisplay.append(display.actor, 0);
|
|
},
|
|
|
|
_redisplayMenus: function() {
|
|
this._menuDisplay.remove_all();
|
|
this._addMenuItem('Frequent', null, 'gtk-select-all');
|
|
for (let i = 0; i < this._menus.length; i++) {
|
|
let menu = this._menus[i];
|
|
this._addMenuItem(menu.name, menu.id, menu.icon, i+1);
|
|
}
|
|
},
|
|
|
|
_addApp: function(appInfo) {
|
|
let appId = appInfo.get_id();
|
|
this._allItems[appId] = appInfo;
|
|
},
|
|
|
|
//// Protected method overrides ////
|
|
|
|
// Gets information about all applications by calling Gio.app_info_get_all().
|
|
_refreshCache : function() {
|
|
let me = this;
|
|
if (!this._appsStale)
|
|
return;
|
|
this._allItems = {};
|
|
this._appCategories = {};
|
|
|
|
this._menus = this._appSystem.get_menus();
|
|
// Loop over the toplevel menu items, load the set of desktop file ids
|
|
// associated with each one
|
|
for (let i = 0; i < this._menus.length; i++) {
|
|
let menu = this._menus[i];
|
|
let menuApps = this._appSystem.get_applications_for_menu(menu.id);
|
|
for (let j = 0; j < menuApps.length; j++) {
|
|
let app = menuApps[j];
|
|
this._addApp(app);
|
|
}
|
|
}
|
|
|
|
// Now grab the desktop file ids for settings/preferences.
|
|
// These show up in search, but not with the rest of apps.
|
|
let settings = this._appSystem.get_all_settings();
|
|
for (let i = 0; i < settings.length; i++) {
|
|
let app = settings[i];
|
|
this._addApp(app);
|
|
}
|
|
|
|
this._appsStale = false;
|
|
},
|
|
|
|
// Stub this out; the app display always has a category selected
|
|
_setDefaultList : function() {
|
|
this._matchedItems = [];
|
|
},
|
|
|
|
// Compares items associated with the item ids based on the alphabetical order
|
|
// of the item names.
|
|
// Returns an integer value indicating the result of the comparison.
|
|
_compareItems : function(itemIdA, itemIdB) {
|
|
let appA = this._allItems[itemIdA];
|
|
let appB = this._allItems[itemIdB];
|
|
return appA.get_name().localeCompare(appB.get_name());
|
|
},
|
|
|
|
// Checks if the item info can be a match for the search string by checking
|
|
// the name, description, execution command, and categories for the application.
|
|
// Item info is expected to be Shell.AppInfo.
|
|
// Returns a boolean flag indicating if itemInfo is a match.
|
|
_isInfoMatching : function(itemInfo, search) {
|
|
// Don't show nodisplay items here
|
|
if (itemInfo.get_is_nodisplay())
|
|
return false;
|
|
// Search takes precedence; not typically useful to search within a
|
|
// menu
|
|
if (this._activeMenu == null || search != "")
|
|
return this._isInfoMatchingSearch(itemInfo, search);
|
|
else
|
|
return this._isInfoMatchingMenu(itemInfo, search);
|
|
},
|
|
|
|
_isInfoMatchingMenu : function(itemInfo, search) {
|
|
let id = itemInfo.get_id();
|
|
for (let i = 0; i < this._activeMenuApps.length; i++) {
|
|
let activeApp = this._activeMenuApps[i];
|
|
if (activeApp.get_id() == id)
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
|
|
_isInfoMatchingSearch: function(itemInfo, search) {
|
|
if (search == null || search == '')
|
|
return true;
|
|
|
|
let fold = function(s) {
|
|
if (!s)
|
|
return s;
|
|
return GLib.utf8_casefold(GLib.utf8_normalize(s, -1,
|
|
GLib.NormalizeMode.ALL), -1);
|
|
};
|
|
let name = fold(itemInfo.get_name());
|
|
if (name.indexOf(search) >= 0)
|
|
return true;
|
|
|
|
let description = fold(itemInfo.get_description());
|
|
if (description) {
|
|
if (description.indexOf(search) >= 0)
|
|
return true;
|
|
}
|
|
|
|
let exec = fold(itemInfo.get_executable());
|
|
if (exec == null) {
|
|
log("Missing an executable for " + itemInfo.name);
|
|
} else {
|
|
if (exec.indexOf(search) >= 0)
|
|
return true;
|
|
}
|
|
|
|
let categories = itemInfo.get_categories();
|
|
for (let i = 0; i < categories.length; i++) {
|
|
let category = fold(categories[i]);
|
|
if (category.indexOf(search) >= 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
// Creates an AppDisplayItem based on itemInfo, which is expected be an Shell.AppInfo object.
|
|
_createDisplayItem: function(itemInfo, width) {
|
|
return new AppDisplayItem(itemInfo, width);
|
|
}
|
|
};
|
|
|
|
Signals.addSignalMethods(AppDisplay.prototype);
|
|
|
|
function WellDisplayItem(appInfo, isFavorite) {
|
|
this._init(appInfo, isFavorite);
|
|
}
|
|
|
|
WellDisplayItem.prototype = {
|
|
_init : function(appInfo, isFavorite) {
|
|
this.appInfo = appInfo;
|
|
|
|
this.isFavorite = isFavorite;
|
|
|
|
this.actor = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
|
|
corner_radius: 2,
|
|
border: 0,
|
|
padding: 1,
|
|
border_color: GenericDisplay.ITEM_DISPLAY_SELECTED_BACKGROUND_COLOR,
|
|
reactive: true });
|
|
this.actor.connect('enter-event', Lang.bind(this,
|
|
function(o, event) {
|
|
this.actor.border = 1;
|
|
this.actor.padding = 0;
|
|
return false;
|
|
}));
|
|
this.actor.connect('leave-event', Lang.bind(this,
|
|
function(o, event) {
|
|
this.actor.border = 0;
|
|
this.actor.padding = 1;
|
|
return false;
|
|
}));
|
|
this.actor._delegate = this;
|
|
this.actor.connect('button-release-event', Lang.bind(this, function (b, e) {
|
|
this._handleActivate();
|
|
}));
|
|
|
|
let draggable = DND.makeDraggable(this.actor);
|
|
|
|
let iconBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
|
|
x_align: Big.BoxAlignment.CENTER });
|
|
this._icon = appInfo.create_icon_texture(APP_ICON_SIZE);
|
|
iconBox.append(this._icon, Big.BoxPackFlags.NONE);
|
|
|
|
this.actor.append(iconBox, Big.BoxPackFlags.NONE);
|
|
|
|
this._windows = Shell.AppMonitor.get_default().get_windows_for_app(appInfo.get_id());
|
|
|
|
let nameBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
x_align: Big.BoxAlignment.CENTER });
|
|
this._nameBox = nameBox;
|
|
|
|
this._wordWidth = Shell.Global.get().get_max_word_width(this.actor, appInfo.get_name(),
|
|
"Sans 12px");
|
|
this._name = new Clutter.Text({ color: GenericDisplay.ITEM_DISPLAY_NAME_COLOR,
|
|
font_name: "Sans 12px",
|
|
line_alignment: Pango.Alignment.CENTER,
|
|
ellipsize: Pango.EllipsizeMode.END,
|
|
text: appInfo.get_name() });
|
|
nameBox.append(this._name, Big.BoxPackFlags.NONE);
|
|
if (this._windows.length > 0) {
|
|
let glow = new Shell.DrawingArea({});
|
|
glow.connect('redraw', Lang.bind(this, function (e, tex) {
|
|
Shell.Global.clutter_cairo_texture_draw_glow(tex,
|
|
GLOW_COLOR.red / 255,
|
|
GLOW_COLOR.green / 255,
|
|
GLOW_COLOR.blue / 255,
|
|
GLOW_COLOR.alpha / 255);
|
|
}));
|
|
this._name.connect('notify::allocation', Lang.bind(this, function (n, alloc) {
|
|
let x = this._name.x;
|
|
let y = this._name.y;
|
|
let width = this._name.width;
|
|
let height = this._name.height;
|
|
// If we're smaller than the allocated box width, pad out the glow a bit
|
|
// to make it more visible
|
|
if ((width + GLOW_PADDING * 2) < this._nameBox.width) {
|
|
width += GLOW_PADDING * 2;
|
|
x -= GLOW_PADDING;
|
|
}
|
|
glow.set_size(width, height);
|
|
glow.set_position(x, y);
|
|
}));
|
|
nameBox.add_actor(glow);
|
|
glow.lower(this._name);
|
|
}
|
|
this.actor.append(nameBox, Big.BoxPackFlags.NONE);
|
|
},
|
|
|
|
_handleActivate: function () {
|
|
if (this._windows.length == 0)
|
|
this.launch();
|
|
else {
|
|
/* Pick the first window and activate it, switching to its workspace
|
|
* if necessary. In the future, we want to have a menu dropdown here. */
|
|
let first = this._windows[0];
|
|
let firstWorkspace = first.get_workspace();
|
|
let currentWorkspaceIndex = Shell.Global.get().screen.get_active_workspace_index();
|
|
let currentWorkspace = Shell.Global.get().screen.get_workspace_by_index(currentWorkspaceIndex);
|
|
let ts = Clutter.get_current_event_time();
|
|
if (currentWorkspace != firstWorkspace)
|
|
firstWorkspace.activate_with_focus(first, ts);
|
|
else
|
|
first.activate(ts);
|
|
}
|
|
this.emit('activated');
|
|
},
|
|
|
|
// Opens an application represented by this display item.
|
|
launch : function() {
|
|
this.appInfo.launch();
|
|
},
|
|
|
|
// Draggable interface - FIXME deduplicate with GenericDisplay
|
|
getDragActor: function(stageX, stageY) {
|
|
this.dragActor = this.appInfo.create_icon_texture(APP_ICON_SIZE);
|
|
|
|
// If the user dragged from the icon itself, then position
|
|
// the dragActor over the original icon. Otherwise center it
|
|
// around the pointer
|
|
let [iconX, iconY] = this._icon.get_transformed_position();
|
|
let [iconWidth, iconHeight] = this._icon.get_transformed_size();
|
|
if (stageX > iconX && stageX <= iconX + iconWidth &&
|
|
stageY > iconY && stageY <= iconY + iconHeight)
|
|
this.dragActor.set_position(iconX, iconY);
|
|
else
|
|
this.dragActor.set_position(stageX - this.dragActor.width / 2, stageY - this.dragActor.height / 2);
|
|
return this.dragActor;
|
|
},
|
|
|
|
// Returns the original icon that is being used as a source for the cloned texture
|
|
// that represents the item as it is being dragged.
|
|
getDragActorSource: function() {
|
|
return this._icon;
|
|
},
|
|
|
|
getWordWidth: function() {
|
|
return this._wordWidth;
|
|
},
|
|
|
|
setWidth: function(width) {
|
|
this._nameBox.width = width + GLOW_PADDING * 2;
|
|
}
|
|
};
|
|
|
|
Signals.addSignalMethods(WellDisplayItem.prototype);
|
|
|
|
function WellArea(width, isFavorite) {
|
|
this._init(width, isFavorite);
|
|
}
|
|
|
|
WellArea.prototype = {
|
|
_init : function(width, isFavorite) {
|
|
this.isFavorite = isFavorite;
|
|
|
|
this._grid = new Tidy.Grid({ width: width, row_gap: 4 });
|
|
this._grid._delegate = this;
|
|
|
|
this.actor = this._grid;
|
|
},
|
|
|
|
redisplay: function (infos) {
|
|
let children;
|
|
|
|
children = this._grid.get_children();
|
|
children.forEach(Lang.bind(this, function (v) {
|
|
v.destroy();
|
|
}));
|
|
|
|
this._maxWordWidth = 0;
|
|
let displays = []
|
|
for (let i = 0; i < infos.length; i++) {
|
|
let app = infos[i];
|
|
let display = new WellDisplayItem(app, this.isFavorite);
|
|
displays.push(display);
|
|
let width = display.getWordWidth();
|
|
if (width > this._maxWordWidth)
|
|
this._maxWordWidth = width;
|
|
display.connect('activated', Lang.bind(this, function (display) {
|
|
this.emit('activated', display);
|
|
}));
|
|
this.actor.add_actor(display.actor);
|
|
}
|
|
this._displays = displays;
|
|
},
|
|
|
|
getWordWidth: function() {
|
|
return this._maxWordWidth;
|
|
},
|
|
|
|
setItemWidth: function(width) {
|
|
for (let i = 0; i < this._displays.length; i++) {
|
|
let display = this._displays[i];
|
|
display.setWidth(width);
|
|
}
|
|
},
|
|
|
|
// Draggable target interface
|
|
acceptDrop : function(source, actor, x, y, time) {
|
|
let global = Shell.Global.get();
|
|
|
|
let id = null;
|
|
if (source instanceof WellDisplayItem) {
|
|
id = source.appInfo.get_id();
|
|
} else if (source instanceof AppDisplayItem) {
|
|
id = source.getId();
|
|
} else if (source instanceof Workspaces.WindowClone) {
|
|
let appMonitor = Shell.AppMonitor.get_default();
|
|
let app = appMonitor.get_window_app(source.metaWindow);
|
|
id = app.get_id();
|
|
if (id === null)
|
|
return false;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
let appSystem = Shell.AppSystem.get_default();
|
|
|
|
if (source.isFavorite && (!this.isFavorite)) {
|
|
Mainloop.idle_add(function () {
|
|
appSystem.remove_favorite(id);
|
|
});
|
|
} else if ((!source.isFavorite) && this.isFavorite) {
|
|
Mainloop.idle_add(function () {
|
|
appSystem.add_favorite(id);
|
|
});
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Signals.addSignalMethods(WellArea.prototype);
|
|
|
|
function AppWell(width) {
|
|
this._init(width);
|
|
}
|
|
|
|
AppWell.prototype = {
|
|
_init : function(width) {
|
|
this._menus = [];
|
|
this._menuDisplays = [];
|
|
|
|
this.actor = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
|
|
spacing: 4,
|
|
width: width });
|
|
|
|
this._appSystem = Shell.AppSystem.get_default();
|
|
this._appMonitor = Shell.AppMonitor.get_default();
|
|
|
|
this._appSystem.connect('installed-changed', Lang.bind(this, function(appSys) {
|
|
this._redisplay();
|
|
}));
|
|
this._appSystem.connect('favorites-changed', Lang.bind(this, function(appSys) {
|
|
this._redisplay();
|
|
}));
|
|
this._appMonitor.connect('changed', Lang.bind(this, function(monitor) {
|
|
this._redisplay();
|
|
}));
|
|
|
|
this._favoritesArea = new WellArea(width, true);
|
|
this._favoritesArea.connect('activated', Lang.bind(this, function (a, display) {
|
|
this.emit('activated');
|
|
}));
|
|
this.actor.append(this._favoritesArea.actor, Big.BoxPackFlags.NONE);
|
|
|
|
this._runningBox = new Big.Box({ border_color: GenericDisplay.ITEM_DISPLAY_NAME_COLOR,
|
|
border_top: 1,
|
|
corner_radius: 3,
|
|
padding_top: GenericDisplay.PREVIEW_BOX_PADDING });
|
|
this._runningArea = new WellArea(width, false);
|
|
this._runningArea.connect('activated', Lang.bind(this, function (a, display) {
|
|
this.emit('activated');
|
|
}));
|
|
this._runningBox.append(this._runningArea.actor, Big.BoxPackFlags.EXPAND);
|
|
this.actor.append(this._runningBox, Big.BoxPackFlags.NONE);
|
|
|
|
this._redisplay();
|
|
},
|
|
|
|
_lookupApps: function(appIds) {
|
|
let result = [];
|
|
for (let i = 0; i < appIds.length; i++) {
|
|
let id = appIds[i];
|
|
let app = this._appSystem.lookup_app(id);
|
|
if (!app)
|
|
continue;
|
|
result.push(app);
|
|
}
|
|
return result;
|
|
},
|
|
|
|
_redisplay: function() {
|
|
let arrayToObject = function(a) {
|
|
let o = {};
|
|
for (let i = 0; i < a.length; i++)
|
|
o[a[i]] = 1;
|
|
return o;
|
|
};
|
|
let favoriteIds = this._appSystem.get_favorites();
|
|
let favoriteIdsObject = arrayToObject(favoriteIds);
|
|
let runningIds = this._appMonitor.get_running_app_ids().filter(function (e) {
|
|
return !(e in favoriteIdsObject);
|
|
});
|
|
let favorites = this._lookupApps(favoriteIds);
|
|
let running = this._lookupApps(runningIds);
|
|
this._favoritesArea.redisplay(favorites);
|
|
this._runningArea.redisplay(running);
|
|
let maxWidth = this._favoritesArea.getWordWidth();
|
|
if (this._runningArea.getWordWidth() > maxWidth)
|
|
maxWidth = this._runningArea.getWordWidth();
|
|
this._favoritesArea.setItemWidth(maxWidth);
|
|
this._runningArea.setItemWidth(maxWidth);
|
|
// If it's empty, we hide it so the top border doesn't show up
|
|
if (running.length == 0)
|
|
this._runningBox.hide();
|
|
else
|
|
this._runningBox.show();
|
|
}
|
|
};
|
|
|
|
Signals.addSignalMethods(AppWell.prototype);
|