295d286161
The new plans for a row of workspace thumbnails on the right side of the overview means that the mental model we present to the user will be vertical, so switch the Metacity workspace layout to be vertical and adjust the keybinding handling, animations, and workspace layout in the overview to match. (This commit does not change the workspace switching indicator pending finalization of what we want to do with that - it still shows workspaces arranged vertically.) https://bugzilla.gnome.org/show_bug.cgi?id=640996
676 lines
22 KiB
JavaScript
676 lines
22 KiB
JavaScript
/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
|
|
imports.gi.versions.Clutter = '1.0';
|
|
imports.gi.versions.Gio = '2.0';
|
|
imports.gi.versions.Gdk = '3.0';
|
|
imports.gi.versions.GdkPixbuf = '2.0';
|
|
imports.gi.versions.Gtk = '3.0';
|
|
|
|
const Clutter = imports.gi.Clutter;
|
|
const DBus = imports.dbus;
|
|
const Gdk = imports.gi.Gdk;
|
|
const Gio = imports.gi.Gio;
|
|
const GLib = imports.gi.GLib;
|
|
const GConf = imports.gi.GConf;
|
|
const Lang = imports.lang;
|
|
const Mainloop = imports.mainloop;
|
|
const Meta = imports.gi.Meta;
|
|
const Shell = imports.gi.Shell;
|
|
const St = imports.gi.St;
|
|
const Gettext = imports.gettext.domain('gnome-shell');
|
|
const _ = Gettext.gettext;
|
|
|
|
const Chrome = imports.ui.chrome;
|
|
const CtrlAltTab = imports.ui.ctrlAltTab;
|
|
const EndSessionDialog = imports.ui.endSessionDialog;
|
|
const Environment = imports.ui.environment;
|
|
const ExtensionSystem = imports.ui.extensionSystem;
|
|
const MessageTray = imports.ui.messageTray;
|
|
const Overview = imports.ui.overview;
|
|
const Panel = imports.ui.panel;
|
|
const PlaceDisplay = imports.ui.placeDisplay;
|
|
const RunDialog = imports.ui.runDialog;
|
|
const LookingGlass = imports.ui.lookingGlass;
|
|
const NotificationDaemon = imports.ui.notificationDaemon;
|
|
const WindowAttentionHandler = imports.ui.windowAttentionHandler;
|
|
const Scripting = imports.ui.scripting;
|
|
const ShellDBus = imports.ui.shellDBus;
|
|
const TelepathyClient = imports.ui.telepathyClient;
|
|
const WindowManager = imports.ui.windowManager;
|
|
const Magnifier = imports.ui.magnifier;
|
|
const XdndHandler = imports.ui.xdndHandler;
|
|
const StatusIconDispatcher = imports.ui.statusIconDispatcher;
|
|
const Util = imports.misc.util;
|
|
|
|
const DEFAULT_BACKGROUND_COLOR = new Clutter.Color();
|
|
DEFAULT_BACKGROUND_COLOR.from_pixel(0x2266bbff);
|
|
|
|
let chrome = null;
|
|
let panel = null;
|
|
let placesManager = null;
|
|
let overview = null;
|
|
let runDialog = null;
|
|
let lookingGlass = null;
|
|
let wm = null;
|
|
let messageTray = null;
|
|
let notificationDaemon = null;
|
|
let windowAttentionHandler = null;
|
|
let telepathyClient = null;
|
|
let ctrlAltTabManager = null;
|
|
let recorder = null;
|
|
let shellDBusService = null;
|
|
let modalCount = 0;
|
|
let modalActorFocusStack = [];
|
|
let uiGroup = null;
|
|
let magnifier = null;
|
|
let xdndHandler = null;
|
|
let statusIconDispatcher = null;
|
|
let _errorLogStack = [];
|
|
let _startDate;
|
|
let _defaultCssStylesheet = null;
|
|
let _cssStylesheet = null;
|
|
|
|
let background = null;
|
|
|
|
function start() {
|
|
// Add a binding for 'global' in the global JS namespace; (gjs
|
|
// keeps the web browser convention of having that namespace be
|
|
// called 'window'.)
|
|
window.global = Shell.Global.get();
|
|
|
|
// Now monkey patch utility functions into the global proxy;
|
|
// This is easier and faster than indirecting down into global
|
|
// if we want to call back up into JS.
|
|
global.logError = _logError;
|
|
global.log = _logDebug;
|
|
|
|
Gio.DesktopAppInfo.set_desktop_env('GNOME');
|
|
|
|
global.grab_dbus_service();
|
|
shellDBusService = new ShellDBus.GnomeShell();
|
|
// Force a connection now; dbus.js will do this internally
|
|
// if we use its name acquisition stuff but we aren't right
|
|
// now; to do so we'd need to convert from its async calls
|
|
// back into sync ones.
|
|
DBus.session.flush();
|
|
|
|
Environment.init();
|
|
|
|
// Ensure ShellWindowTracker and ShellAppUsage are initialized; this will
|
|
// also initialize ShellAppSystem first. ShellAppSystem
|
|
// needs to load all the .desktop files, and ShellWindowTracker
|
|
// will use those to associate with windows. Right now
|
|
// the Monitor doesn't listen for installed app changes
|
|
// and recalculate application associations, so to avoid
|
|
// races for now we initialize it here. It's better to
|
|
// be predictable anyways.
|
|
Shell.WindowTracker.get_default();
|
|
Shell.AppUsage.get_default();
|
|
|
|
// The stage is always covered so Clutter doesn't need to clear it; however
|
|
// the color is used as the default contents for the Mutter root background
|
|
// actor so set it anyways.
|
|
global.stage.color = DEFAULT_BACKGROUND_COLOR;
|
|
global.stage.no_clear_hint = true;
|
|
|
|
_defaultCssStylesheet = global.datadir + '/theme/gnome-shell.css';
|
|
loadTheme();
|
|
|
|
let shellwm = global.window_manager;
|
|
shellwm.takeover_keybinding('panel_main_menu');
|
|
shellwm.connect('keybinding::panel_main_menu', function () {
|
|
overview.toggle();
|
|
});
|
|
shellwm.takeover_keybinding('panel_run_dialog');
|
|
shellwm.connect('keybinding::panel_run_dialog', function () {
|
|
getRunDialog().open();
|
|
});
|
|
|
|
// Set up stage hierarchy to group all UI actors under one container.
|
|
uiGroup = new Clutter.Group();
|
|
global.window_group.reparent(uiGroup);
|
|
global.overlay_group.reparent(uiGroup);
|
|
global.stage.add_actor(uiGroup);
|
|
|
|
placesManager = new PlaceDisplay.PlacesManager();
|
|
xdndHandler = new XdndHandler.XdndHandler();
|
|
overview = new Overview.Overview();
|
|
chrome = new Chrome.Chrome();
|
|
magnifier = new Magnifier.Magnifier();
|
|
statusIconDispatcher = new StatusIconDispatcher.StatusIconDispatcher();
|
|
panel = new Panel.Panel();
|
|
wm = new WindowManager.WindowManager();
|
|
messageTray = new MessageTray.MessageTray();
|
|
notificationDaemon = new NotificationDaemon.NotificationDaemon();
|
|
windowAttentionHandler = new WindowAttentionHandler.WindowAttentionHandler();
|
|
telepathyClient = new TelepathyClient.Client();
|
|
|
|
panel.startStatusArea();
|
|
statusIconDispatcher.start(messageTray.actor);
|
|
|
|
ctrlAltTabManager = new CtrlAltTab.CtrlAltTabManager();
|
|
ctrlAltTabManager.addGroup(panel.actor, _("Panel"), 'gnome-panel');
|
|
|
|
_startDate = new Date();
|
|
|
|
let recorderSettings = new Gio.Settings({ schema: 'org.gnome.shell.recorder' });
|
|
|
|
global.screen.connect('toggle-recording', function() {
|
|
if (recorder == null) {
|
|
recorder = new Shell.Recorder({ stage: global.stage });
|
|
}
|
|
|
|
if (recorder.is_recording()) {
|
|
recorder.pause();
|
|
} else {
|
|
// read the parameters from GSettings always in case they have changed
|
|
recorder.set_framerate(recorderSettings.get_int('framerate'));
|
|
recorder.set_filename('shell-%d%u-%c.' + recorderSettings.get_string('file-extension'));
|
|
let pipeline = recorderSettings.get_string('pipeline');
|
|
|
|
if (!pipeline.match(/^\s*$/))
|
|
recorder.set_pipeline(pipeline);
|
|
else
|
|
recorder.set_pipeline(null);
|
|
|
|
recorder.record();
|
|
}
|
|
});
|
|
|
|
global.screen.override_workspace_layout(Meta.ScreenCorner.TOPLEFT, false, -1, 1);
|
|
|
|
// Provide the bus object for gnome-session to
|
|
// initiate logouts.
|
|
EndSessionDialog.init();
|
|
|
|
global.gdk_screen.connect('monitors-changed', _relayout);
|
|
|
|
ExtensionSystem.init();
|
|
ExtensionSystem.loadExtensions();
|
|
|
|
panel.startupAnimation();
|
|
|
|
let display = global.screen.get_display();
|
|
display.connect('overlay-key', Lang.bind(overview, overview.toggle));
|
|
|
|
global.stage.connect('captured-event', _globalKeyPressHandler);
|
|
|
|
// Perform initial relayout here
|
|
_relayout();
|
|
|
|
_log('info', 'loaded at ' + _startDate);
|
|
log('GNOME Shell started at ' + _startDate);
|
|
|
|
Mainloop.idle_add(_removeUnusedWorkspaces);
|
|
|
|
let perfModuleName = GLib.getenv("SHELL_PERF_MODULE");
|
|
if (perfModuleName) {
|
|
let perfOutput = GLib.getenv("SHELL_PERF_OUTPUT");
|
|
let module = eval('imports.perf.' + perfModuleName + ';');
|
|
Scripting.runPerfScript(module, perfOutput);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getThemeStylesheet:
|
|
*
|
|
* Get the theme CSS file that the shell will load
|
|
*
|
|
* Returns: A file path that contains the theme CSS,
|
|
* null if using the default
|
|
*/
|
|
function getThemeStylesheet()
|
|
{
|
|
return _cssStylesheet;
|
|
}
|
|
|
|
/**
|
|
* setThemeStylesheet:
|
|
* @cssStylesheet: A file path that contains the theme CSS,
|
|
* set it to null to use the default
|
|
*
|
|
* Set the theme CSS file that the shell will load
|
|
*/
|
|
function setThemeStylesheet(cssStylesheet)
|
|
{
|
|
_cssStylesheet = cssStylesheet;
|
|
}
|
|
|
|
/**
|
|
* loadTheme:
|
|
*
|
|
* Reloads the theme CSS file
|
|
*/
|
|
function loadTheme() {
|
|
let themeContext = St.ThemeContext.get_for_stage (global.stage);
|
|
|
|
let cssStylesheet = _defaultCssStylesheet;
|
|
if (_cssStylesheet != null)
|
|
cssStylesheet = _cssStylesheet;
|
|
|
|
let theme = new St.Theme ({ application_stylesheet: cssStylesheet });
|
|
themeContext.set_theme (theme);
|
|
}
|
|
|
|
/**
|
|
* _log:
|
|
* @category: string message type ('info', 'error')
|
|
* @msg: A message string
|
|
* ...: Any further arguments are converted into JSON notation,
|
|
* and appended to the log message, separated by spaces.
|
|
*
|
|
* Log a message into the LookingGlass error
|
|
* stream. This is primarily intended for use by the
|
|
* extension system as well as debugging.
|
|
*/
|
|
function _log(category, msg) {
|
|
let text = msg;
|
|
if (arguments.length > 2) {
|
|
text += ': ';
|
|
for (let i = 2; i < arguments.length; i++) {
|
|
text += JSON.stringify(arguments[i]);
|
|
if (i < arguments.length - 1)
|
|
text += ' ';
|
|
}
|
|
}
|
|
_errorLogStack.push({timestamp: new Date().getTime(),
|
|
category: category,
|
|
message: text });
|
|
}
|
|
|
|
function _logError(msg) {
|
|
return _log('error', msg);
|
|
}
|
|
|
|
function _logDebug(msg) {
|
|
return _log('debug', msg);
|
|
}
|
|
|
|
// Used by the error display in lookingGlass.js
|
|
function _getAndClearErrorStack() {
|
|
let errors = _errorLogStack;
|
|
_errorLogStack = [];
|
|
return errors;
|
|
}
|
|
|
|
function _relayout() {
|
|
let primary = global.get_primary_monitor();
|
|
panel.actor.set_position(primary.x, primary.y);
|
|
panel.actor.set_size(primary.width, Panel.PANEL_HEIGHT);
|
|
overview.relayout();
|
|
|
|
// To avoid updating the position and size of the workspaces
|
|
// in the overview, we just hide the overview. The positions
|
|
// will be updated when it is next shown.
|
|
overview.hide();
|
|
}
|
|
|
|
function isWindowActorDisplayedOnWorkspace(win, workspaceIndex) {
|
|
return win.get_workspace() == workspaceIndex ||
|
|
(win.get_meta_window() && win.get_meta_window().is_on_all_workspaces());
|
|
}
|
|
|
|
function getWindowActorsForWorkspace(workspaceIndex) {
|
|
return global.get_window_actors().filter(function (win) {
|
|
return isWindowActorDisplayedOnWorkspace(win, workspaceIndex);
|
|
});
|
|
}
|
|
|
|
// metacity-clutter currently uses the same prefs as plain metacity,
|
|
// which probably means we'll be starting out with multiple workspaces;
|
|
// remove any unused ones. (We do this from an idle handler, because
|
|
// global.get_window_actors() still returns NULL at the point when start()
|
|
// is called.)
|
|
function _removeUnusedWorkspaces() {
|
|
|
|
let windows = global.get_window_actors();
|
|
let maxWorkspace = 0;
|
|
for (let i = 0; i < windows.length; i++) {
|
|
let win = windows[i];
|
|
|
|
if (!win.get_meta_window().is_on_all_workspaces() &&
|
|
win.get_workspace() > maxWorkspace) {
|
|
maxWorkspace = win.get_workspace();
|
|
}
|
|
}
|
|
let screen = global.screen;
|
|
if (screen.n_workspaces > maxWorkspace) {
|
|
for (let w = screen.n_workspaces - 1; w > maxWorkspace; w--) {
|
|
let workspace = screen.get_workspace_by_index(w);
|
|
screen.remove_workspace(workspace, 0);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// This function encapsulates hacks to make certain global keybindings
|
|
// work even when we are in one of our modes where global keybindings
|
|
// are disabled with a global grab. (When there is a global grab, then
|
|
// all key events will be delivered to the stage, so ::captured-event
|
|
// on the stage can be used for global keybindings.)
|
|
function _globalKeyPressHandler(actor, event) {
|
|
if (modalCount == 0)
|
|
return false;
|
|
if (event.type() != Clutter.EventType.KEY_PRESS)
|
|
return false;
|
|
|
|
let symbol = event.get_key_symbol();
|
|
let keyCode = event.get_key_code();
|
|
let modifierState = Shell.get_event_state(event);
|
|
|
|
let display = global.screen.get_display();
|
|
// This relies on the fact that Clutter.ModifierType is the same as Gdk.ModifierType
|
|
let action = display.get_keybinding_action(keyCode, modifierState);
|
|
|
|
// The screenshot action should always be available (even if a
|
|
// modal dialog is present)
|
|
if (action == Meta.KeyBindingAction.COMMAND_SCREENSHOT) {
|
|
let gconf = GConf.Client.get_default();
|
|
let command = gconf.get_string('/apps/metacity/keybinding_commands/command_screenshot');
|
|
if (command != null && command != '')
|
|
Util.spawnCommandLine(command);
|
|
return true;
|
|
}
|
|
|
|
// Other bindings are only available when the overview is up and
|
|
// no modal dialog is present.
|
|
if (!overview.visible || modalCount > 1)
|
|
return false;
|
|
|
|
// This isn't a Meta.KeyBindingAction yet
|
|
if (symbol == Clutter.Super_L || symbol == Clutter.Super_R) {
|
|
overview.hide();
|
|
return true;
|
|
}
|
|
|
|
switch (action) {
|
|
case Meta.KeyBindingAction.WORKSPACE_LEFT:
|
|
wm.actionMoveWorkspaceLeft();
|
|
return true;
|
|
case Meta.KeyBindingAction.WORKSPACE_RIGHT:
|
|
wm.actionMoveWorkspaceRight();
|
|
return true;
|
|
case Meta.KeyBindingAction.WORKSPACE_UP:
|
|
wm.actionMoveWorkspaceUp();
|
|
return true;
|
|
case Meta.KeyBindingAction.WORKSPACE_DOWN:
|
|
wm.actionMoveWorkspaceDown();
|
|
return true;
|
|
case Meta.KeyBindingAction.PANEL_RUN_DIALOG:
|
|
case Meta.KeyBindingAction.COMMAND_2:
|
|
getRunDialog().open();
|
|
return true;
|
|
case Meta.KeyBindingAction.PANEL_MAIN_MENU:
|
|
overview.hide();
|
|
return true;
|
|
case Meta.KeyBindingAction.SWITCH_PANELS:
|
|
ctrlAltTabManager.popup(modifierState & Clutter.ModifierType.SHIFT_MASK);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function _findModal(actor) {
|
|
for (let i = 0; i < modalActorFocusStack.length; i++) {
|
|
let [stackActor, stackFocus] = modalActorFocusStack[i];
|
|
if (stackActor == actor) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* pushModal:
|
|
* @actor: #ClutterActor which will be given keyboard focus
|
|
* @timestamp: optional timestamp
|
|
*
|
|
* Ensure we are in a mode where all keyboard and mouse input goes to
|
|
* the stage, and focus @actor. Multiple calls to this function act in
|
|
* a stacking fashion; the effect will be undone when an equal number
|
|
* of popModal() invocations have been made.
|
|
*
|
|
* Next, record the current Clutter keyboard focus on a stack. If the
|
|
* modal stack returns to this actor, reset the focus to the actor
|
|
* which was focused at the time pushModal() was invoked.
|
|
*
|
|
* @timestamp is optionally used to associate the call with a specific user
|
|
* initiated event. If not provided then the value of
|
|
* global.get_current_time() is assumed.
|
|
*
|
|
* Returns: true iff we successfully acquired a grab or already had one
|
|
*/
|
|
function pushModal(actor, timestamp) {
|
|
|
|
if (timestamp == undefined)
|
|
timestamp = global.get_current_time();
|
|
|
|
if (modalCount == 0) {
|
|
if (!global.begin_modal(timestamp)) {
|
|
log('pushModal: invocation of begin_modal failed');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
global.set_stage_input_mode(Shell.StageInputMode.FULLSCREEN);
|
|
|
|
modalCount += 1;
|
|
actor.connect('destroy', function() {
|
|
let index = _findModal(actor);
|
|
if (index >= 0)
|
|
modalActorFocusStack.splice(index, 1);
|
|
});
|
|
let curFocus = global.stage.get_key_focus();
|
|
if (curFocus != null) {
|
|
curFocus.connect('destroy', function() {
|
|
let index = _findModal(actor);
|
|
if (index >= 0)
|
|
modalActorFocusStack[index][1] = null;
|
|
});
|
|
}
|
|
modalActorFocusStack.push([actor, curFocus]);
|
|
|
|
global.stage.set_key_focus(actor);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* popModal:
|
|
* @actor: #ClutterActor passed to original invocation of pushModal().
|
|
* @timestamp: optional timestamp
|
|
*
|
|
* Reverse the effect of pushModal(). If this invocation is undoing
|
|
* the topmost invocation, then the focus will be restored to the
|
|
* previous focus at the time when pushModal() was invoked.
|
|
*
|
|
* @timestamp is optionally used to associate the call with a specific user
|
|
* initiated event. If not provided then the value of
|
|
* global.get_current_time() is assumed.
|
|
*/
|
|
function popModal(actor, timestamp) {
|
|
|
|
if (timestamp == undefined)
|
|
timestamp = global.get_current_time();
|
|
|
|
modalCount -= 1;
|
|
let focusIndex = _findModal(actor);
|
|
if (focusIndex >= 0) {
|
|
if (focusIndex == modalActorFocusStack.length - 1) {
|
|
let [stackActor, stackFocus] = modalActorFocusStack[focusIndex];
|
|
global.stage.set_key_focus(stackFocus);
|
|
} else {
|
|
// Remove from the middle, shift the focus chain up
|
|
for (let i = focusIndex; i < modalActorFocusStack.length - 1; i++) {
|
|
modalActorFocusStack[i + 1][1] = modalActorFocusStack[i][1];
|
|
}
|
|
}
|
|
modalActorFocusStack.splice(focusIndex, 1);
|
|
}
|
|
if (modalCount > 0)
|
|
return;
|
|
|
|
global.stage.set_key_focus(null);
|
|
global.end_modal(timestamp);
|
|
global.set_stage_input_mode(Shell.StageInputMode.NORMAL);
|
|
}
|
|
|
|
function createLookingGlass() {
|
|
if (lookingGlass == null) {
|
|
lookingGlass = new LookingGlass.LookingGlass();
|
|
lookingGlass.slaveTo(panel.actor);
|
|
}
|
|
return lookingGlass;
|
|
}
|
|
|
|
function getRunDialog() {
|
|
if (runDialog == null) {
|
|
runDialog = new RunDialog.RunDialog();
|
|
}
|
|
return runDialog;
|
|
}
|
|
|
|
/**
|
|
* activateWindow:
|
|
* @window: the Meta.Window to activate
|
|
* @time: (optional) current event time
|
|
* @workspaceNum: (optional) window's workspace number
|
|
*
|
|
* Activates @window, switching to its workspace first if necessary,
|
|
* and switching out of the overview if it's currently active
|
|
*/
|
|
function activateWindow(window, time, workspaceNum) {
|
|
let activeWorkspaceNum = global.screen.get_active_workspace_index();
|
|
let windowWorkspaceNum = (workspaceNum !== undefined) ? workspaceNum : window.get_workspace().index();
|
|
|
|
if (!time)
|
|
time = global.get_current_time();
|
|
|
|
if (windowWorkspaceNum != activeWorkspaceNum) {
|
|
let workspace = global.screen.get_workspace_by_index(windowWorkspaceNum);
|
|
workspace.activate_with_focus(window, time);
|
|
} else {
|
|
window.activate(time);
|
|
}
|
|
|
|
overview.hide();
|
|
}
|
|
|
|
// TODO - replace this timeout with some system to guess when the user might
|
|
// be e.g. just reading the screen and not likely to interact.
|
|
const DEFERRED_TIMEOUT_SECONDS = 20;
|
|
var _deferredWorkData = {};
|
|
// Work scheduled for some point in the future
|
|
var _deferredWorkQueue = [];
|
|
// Work we need to process before the next redraw
|
|
var _beforeRedrawQueue = [];
|
|
// Counter to assign work ids
|
|
var _deferredWorkSequence = 0;
|
|
var _deferredTimeoutId = 0;
|
|
|
|
function _runDeferredWork(workId) {
|
|
if (!_deferredWorkData[workId])
|
|
return;
|
|
let index = _deferredWorkQueue.indexOf(workId);
|
|
if (index < 0)
|
|
return;
|
|
|
|
_deferredWorkQueue.splice(index, 1);
|
|
_deferredWorkData[workId].callback();
|
|
if (_deferredWorkQueue.length == 0 && _deferredTimeoutId > 0) {
|
|
Mainloop.source_remove(_deferredTimeoutId);
|
|
_deferredTimeoutId = 0;
|
|
}
|
|
}
|
|
|
|
function _runAllDeferredWork() {
|
|
while (_deferredWorkQueue.length > 0)
|
|
_runDeferredWork(_deferredWorkQueue[0]);
|
|
}
|
|
|
|
function _runBeforeRedrawQueue() {
|
|
for (let i = 0; i < _beforeRedrawQueue.length; i++) {
|
|
let workId = _beforeRedrawQueue[i];
|
|
_runDeferredWork(workId);
|
|
}
|
|
_beforeRedrawQueue = [];
|
|
}
|
|
|
|
function _queueBeforeRedraw(workId) {
|
|
_beforeRedrawQueue.push(workId);
|
|
if (_beforeRedrawQueue.length == 1) {
|
|
Meta.later_add(Meta.LaterType.BEFORE_REDRAW, function () {
|
|
_runBeforeRedrawQueue();
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* initializeDeferredWork:
|
|
* @actor: A #ClutterActor
|
|
* @callback: Function to invoke to perform work
|
|
*
|
|
* This function sets up a callback to be invoked when either the
|
|
* given actor is mapped, or after some period of time when the machine
|
|
* is idle. This is useful if your actor isn't always visible on the
|
|
* screen (for example, all actors in the overview), and you don't want
|
|
* to consume resources updating if the actor isn't actually going to be
|
|
* displaying to the user.
|
|
*
|
|
* Note that queueDeferredWork is called by default immediately on
|
|
* initialization as well, under the assumption that new actors
|
|
* will need it.
|
|
*
|
|
* Returns: A string work identifer
|
|
*/
|
|
function initializeDeferredWork(actor, callback, props) {
|
|
// Turn into a string so we can use as an object property
|
|
let workId = '' + (++_deferredWorkSequence);
|
|
_deferredWorkData[workId] = { 'actor': actor,
|
|
'callback': callback };
|
|
actor.connect('notify::mapped', function () {
|
|
if (!(actor.mapped && _deferredWorkQueue.indexOf(workId) >= 0))
|
|
return;
|
|
_queueBeforeRedraw(workId);
|
|
});
|
|
actor.connect('destroy', function() {
|
|
let index = _deferredWorkQueue.indexOf(workId);
|
|
if (index >= 0)
|
|
_deferredWorkQueue.splice(index, 1);
|
|
delete _deferredWorkData[workId];
|
|
});
|
|
queueDeferredWork(workId);
|
|
return workId;
|
|
}
|
|
|
|
/**
|
|
* queueDeferredWork:
|
|
* @workId: work identifier
|
|
*
|
|
* Ensure that the work identified by @workId will be
|
|
* run on map or timeout. You should call this function
|
|
* for example when data being displayed by the actor has
|
|
* changed.
|
|
*/
|
|
function queueDeferredWork(workId) {
|
|
let data = _deferredWorkData[workId];
|
|
if (!data) {
|
|
global.logError('invalid work id ', workId);
|
|
return;
|
|
}
|
|
if (_deferredWorkQueue.indexOf(workId) < 0)
|
|
_deferredWorkQueue.push(workId);
|
|
if (data.actor.mapped) {
|
|
_queueBeforeRedraw(workId);
|
|
return;
|
|
} else if (_deferredTimeoutId == 0) {
|
|
_deferredTimeoutId = Mainloop.timeout_add_seconds(DEFERRED_TIMEOUT_SECONDS, function () {
|
|
_runAllDeferredWork();
|
|
_deferredTimeoutId = 0;
|
|
return false;
|
|
});
|
|
}
|
|
}
|