2011-09-28 13:16:26 +00:00
|
|
|
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
2011-06-13 13:54:05 +00:00
|
|
|
|
2011-07-14 12:35:55 +00:00
|
|
|
const Clutter = imports.gi.Clutter;
|
2013-02-21 19:32:23 +00:00
|
|
|
const GLib = imports.gi.GLib;
|
2012-08-14 13:37:12 +00:00
|
|
|
const GObject = imports.gi.GObject;
|
2011-06-13 13:54:05 +00:00
|
|
|
const Lang = imports.lang;
|
2011-07-25 13:56:51 +00:00
|
|
|
const Mainloop = imports.mainloop;
|
|
|
|
const Meta = imports.gi.Meta;
|
|
|
|
const Shell = imports.gi.Shell;
|
2011-06-13 13:54:05 +00:00
|
|
|
const Signals = imports.signals;
|
|
|
|
const St = imports.gi.St;
|
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
const Background = imports.ui.background;
|
|
|
|
const BackgroundMenu = imports.ui.backgroundMenu;
|
|
|
|
|
2012-02-11 10:14:43 +00:00
|
|
|
const DND = imports.ui.dnd;
|
2011-06-13 13:54:05 +00:00
|
|
|
const Main = imports.ui.main;
|
2011-07-25 13:56:51 +00:00
|
|
|
const Params = imports.misc.params;
|
2011-07-14 12:35:55 +00:00
|
|
|
const Tweener = imports.ui.tweener;
|
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
const STARTUP_ANIMATION_TIME = 0.5;
|
2012-11-15 15:35:20 +00:00
|
|
|
const KEYBOARD_ANIMATION_TIME = 0.15;
|
2013-02-20 01:17:55 +00:00
|
|
|
const BACKGROUND_FADE_ANIMATION_TIME = 1.0;
|
2013-01-10 21:02:20 +00:00
|
|
|
const DEFAULT_BACKGROUND_COLOR = Clutter.Color.from_pixel(0x2e3436ff);
|
2011-07-25 18:25:51 +00:00
|
|
|
|
2012-07-30 19:25:07 +00:00
|
|
|
// The message tray takes this much pressure
|
|
|
|
// in the pressure barrier at once to release it.
|
2013-02-21 21:43:28 +00:00
|
|
|
const MESSAGE_TRAY_PRESSURE_THRESHOLD = 250; // pixels
|
|
|
|
const MESSAGE_TRAY_PRESSURE_TIMEOUT = 1000; // ms
|
2012-07-30 19:25:07 +00:00
|
|
|
|
2013-03-01 21:19:07 +00:00
|
|
|
const HOT_CORNER_PRESSURE_THRESHOLD = 100; // pixels
|
|
|
|
const HOT_CORNER_PRESSURE_TIMEOUT = 1000; // ms
|
|
|
|
|
2013-02-12 21:00:41 +00:00
|
|
|
function isPopupMetaWindow(actor) {
|
|
|
|
switch(actor.meta_window.get_window_type()) {
|
|
|
|
case Meta.WindowType.DROPDOWN_MENU:
|
|
|
|
case Meta.WindowType.POPUP_MENU:
|
|
|
|
case Meta.WindowType.COMBO:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-14 13:37:12 +00:00
|
|
|
const MonitorConstraint = new Lang.Class({
|
|
|
|
Name: 'MonitorConstraint',
|
|
|
|
Extends: Clutter.Constraint,
|
|
|
|
Properties: {'primary': GObject.ParamSpec.boolean('primary',
|
|
|
|
'Primary', 'Track primary monitor',
|
|
|
|
GObject.ParamFlags.READABLE | GObject.ParamFlags.WRITABLE,
|
|
|
|
false),
|
|
|
|
'index': GObject.ParamSpec.int('index',
|
|
|
|
'Monitor index', 'Track specific monitor',
|
|
|
|
GObject.ParamFlags.READABLE | GObject.ParamFlags.WRITABLE,
|
|
|
|
-1, 64, -1)},
|
|
|
|
|
|
|
|
_init: function(props) {
|
|
|
|
this._primary = false;
|
|
|
|
this._index = -1;
|
|
|
|
|
|
|
|
this.parent(props);
|
|
|
|
},
|
|
|
|
|
|
|
|
get primary() {
|
|
|
|
return this._primary;
|
|
|
|
},
|
|
|
|
|
|
|
|
set primary(v) {
|
2012-10-14 16:34:22 +00:00
|
|
|
if (v)
|
|
|
|
this._index = -1;
|
2012-08-14 13:37:12 +00:00
|
|
|
this._primary = v;
|
|
|
|
if (this.actor)
|
|
|
|
this.actor.queue_relayout();
|
|
|
|
this.notify('primary');
|
|
|
|
},
|
|
|
|
|
|
|
|
get index() {
|
|
|
|
return this._index;
|
|
|
|
},
|
|
|
|
|
|
|
|
set index(v) {
|
2012-10-14 16:34:22 +00:00
|
|
|
this._primary = false;
|
2012-08-14 13:37:12 +00:00
|
|
|
this._index = v;
|
|
|
|
if (this.actor)
|
|
|
|
this.actor.queue_relayout();
|
|
|
|
this.notify('index');
|
|
|
|
},
|
|
|
|
|
|
|
|
vfunc_set_actor: function(actor) {
|
|
|
|
if (actor) {
|
|
|
|
if (!this._monitorsChangedId) {
|
|
|
|
this._monitorsChangedId = Main.layoutManager.connect('monitors-changed', Lang.bind(this, function() {
|
|
|
|
this.actor.queue_relayout();
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (this._monitorsChangedId)
|
|
|
|
Main.layoutManager.disconnect(this._monitorsChangedId);
|
|
|
|
this._monitorsChangedId = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.parent(actor);
|
|
|
|
},
|
|
|
|
|
|
|
|
vfunc_update_allocation: function(actor, actorBox) {
|
|
|
|
if (!this._primary && this._index < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
let monitor;
|
|
|
|
if (this._primary) {
|
|
|
|
monitor = Main.layoutManager.primaryMonitor;
|
|
|
|
} else {
|
2012-08-16 20:12:23 +00:00
|
|
|
let index = Math.min(this._index, Main.layoutManager.monitors.length - 1);
|
2012-08-14 13:37:12 +00:00
|
|
|
monitor = Main.layoutManager.monitors[index];
|
|
|
|
}
|
|
|
|
|
|
|
|
actorBox.init_rect(monitor.x, monitor.y, monitor.width, monitor.height);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
const defaultParams = {
|
|
|
|
trackFullscreen: false,
|
|
|
|
affectsStruts: false,
|
|
|
|
affectsInputRegion: true
|
|
|
|
};
|
|
|
|
|
2011-11-20 17:56:27 +00:00
|
|
|
const LayoutManager = new Lang.Class({
|
|
|
|
Name: 'LayoutManager',
|
2011-06-13 13:54:05 +00:00
|
|
|
|
|
|
|
_init: function () {
|
2012-02-14 01:37:28 +00:00
|
|
|
this._rtl = (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL);
|
2011-06-13 13:54:05 +00:00
|
|
|
this.monitors = [];
|
|
|
|
this.primaryMonitor = null;
|
|
|
|
this.primaryIndex = -1;
|
2013-03-01 21:00:37 +00:00
|
|
|
this.hotCorners = [];
|
|
|
|
|
2012-10-14 16:57:45 +00:00
|
|
|
this._keyboardIndex = -1;
|
2012-07-30 17:02:33 +00:00
|
|
|
this._rightPanelBarrier = null;
|
2012-07-30 19:25:07 +00:00
|
|
|
this._trayBarrier = null;
|
2011-07-25 13:53:19 +00:00
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
this._inOverview = false;
|
|
|
|
this._updateRegionIdle = 0;
|
|
|
|
|
|
|
|
this._trackedActors = [];
|
2013-03-12 19:27:51 +00:00
|
|
|
this._topActors = [];
|
2013-02-12 21:00:41 +00:00
|
|
|
this._isPopupWindowVisible = false;
|
2013-02-20 01:20:44 +00:00
|
|
|
this._startingUp = true;
|
2011-07-25 18:25:51 +00:00
|
|
|
|
2013-01-10 21:02:20 +00:00
|
|
|
// Normally, the stage is always covered so Clutter doesn't need to clear
|
|
|
|
// it; however it becomes visible during the startup animation
|
|
|
|
// See the comment below for a longer explanation
|
|
|
|
global.stage.color = DEFAULT_BACKGROUND_COLOR;
|
|
|
|
|
|
|
|
// Set up stage hierarchy to group all UI actors under one container.
|
|
|
|
this.uiGroup = new Shell.GenericContainer({ name: 'uiGroup' });
|
|
|
|
this.uiGroup.connect('allocate',
|
|
|
|
function (actor, box, flags) {
|
|
|
|
let children = actor.get_children();
|
|
|
|
for (let i = 0; i < children.length; i++)
|
|
|
|
children[i].allocate_preferred_size(flags);
|
|
|
|
});
|
|
|
|
this.uiGroup.connect('get-preferred-width',
|
|
|
|
function(actor, forHeight, alloc) {
|
|
|
|
let width = global.stage.width;
|
|
|
|
[alloc.min_size, alloc.natural_size] = [width, width];
|
|
|
|
});
|
|
|
|
this.uiGroup.connect('get-preferred-height',
|
|
|
|
function(actor, forWidth, alloc) {
|
|
|
|
let height = global.stage.height;
|
|
|
|
[alloc.min_size, alloc.natural_size] = [height, height];
|
|
|
|
});
|
|
|
|
|
2013-02-13 17:30:26 +00:00
|
|
|
global.stage.remove_actor(global.window_group);
|
|
|
|
this.uiGroup.add_actor(global.window_group);
|
2013-01-10 21:02:20 +00:00
|
|
|
|
2013-02-13 17:30:26 +00:00
|
|
|
global.stage.remove_actor(global.overlay_group);
|
|
|
|
this.uiGroup.add_actor(global.overlay_group);
|
2013-01-10 21:02:20 +00:00
|
|
|
global.stage.add_child(this.uiGroup);
|
|
|
|
|
2012-05-22 22:27:06 +00:00
|
|
|
this.screenShieldGroup = new St.Widget({ name: 'screenShieldGroup',
|
|
|
|
visible: false,
|
|
|
|
clip_to_allocation: true,
|
2012-08-14 13:39:17 +00:00
|
|
|
layout_manager: new Clutter.BinLayout(),
|
2012-05-22 22:27:06 +00:00
|
|
|
});
|
|
|
|
this.addChrome(this.screenShieldGroup);
|
|
|
|
|
2011-07-25 18:25:51 +00:00
|
|
|
this.panelBox = new St.BoxLayout({ name: 'panelBox',
|
|
|
|
vertical: true });
|
2012-05-22 20:16:31 +00:00
|
|
|
this.addChrome(this.panelBox, { affectsStruts: true,
|
|
|
|
trackFullscreen: true });
|
2011-07-25 18:25:51 +00:00
|
|
|
this.panelBox.connect('allocation-changed',
|
2012-12-03 20:56:18 +00:00
|
|
|
Lang.bind(this, this._panelBoxChanged));
|
2011-07-25 18:25:51 +00:00
|
|
|
|
2012-09-05 00:26:09 +00:00
|
|
|
this.trayBox = new St.Widget({ name: 'trayBox',
|
|
|
|
layout_manager: new Clutter.BinLayout() });
|
2012-05-22 20:16:31 +00:00
|
|
|
this.addChrome(this.trayBox);
|
2013-03-01 19:57:38 +00:00
|
|
|
this._setupTrayPressure();
|
2011-08-29 15:11:22 +00:00
|
|
|
|
2011-09-09 14:56:51 +00:00
|
|
|
this.keyboardBox = new St.BoxLayout({ name: 'keyboardBox',
|
|
|
|
reactive: true,
|
|
|
|
track_hover: true });
|
2012-05-22 20:16:31 +00:00
|
|
|
this.addChrome(this.keyboardBox);
|
2011-09-01 15:37:54 +00:00
|
|
|
this._keyboardHeightNotifyId = 0;
|
2011-07-25 18:25:51 +00:00
|
|
|
|
2013-02-12 21:00:41 +00:00
|
|
|
global.stage.remove_actor(global.top_window_group);
|
|
|
|
this.uiGroup.add_actor(global.top_window_group);
|
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
this._backgroundGroup = new Meta.BackgroundGroup();
|
|
|
|
global.window_group.add_child(this._backgroundGroup);
|
|
|
|
this._backgroundGroup.lower_bottom();
|
|
|
|
this._bgManagers = [];
|
|
|
|
|
2013-02-17 19:45:14 +00:00
|
|
|
// This blocks the XDND picks from finding the activities button
|
|
|
|
// and we never attempt to pick anything from it anyway so make
|
|
|
|
// it invisible from picks
|
|
|
|
Shell.util_set_hidden_from_pick(global.top_window_group, true);
|
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
// Need to update struts on new workspaces when they are added
|
|
|
|
global.screen.connect('notify::n-workspaces',
|
|
|
|
Lang.bind(this, this._queueUpdateRegions));
|
|
|
|
global.screen.connect('restacked',
|
|
|
|
Lang.bind(this, this._windowsRestacked));
|
2011-07-25 18:25:51 +00:00
|
|
|
global.screen.connect('monitors-changed',
|
|
|
|
Lang.bind(this, this._monitorsChanged));
|
|
|
|
this._monitorsChanged();
|
2011-06-13 13:54:05 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
// This is called by Main after everything else is constructed;
|
2013-01-28 04:34:33 +00:00
|
|
|
// it needs access to Main.overview, which didn't exist
|
2011-06-13 13:54:05 +00:00
|
|
|
// yet when the LayoutManager was constructed.
|
|
|
|
init: function() {
|
2013-01-28 04:34:33 +00:00
|
|
|
Main.overview.connect('showing', Lang.bind(this, this._overviewShowing));
|
|
|
|
Main.overview.connect('hidden', Lang.bind(this, this._overviewHidden));
|
|
|
|
Main.sessionMode.connect('updated', Lang.bind(this, this._sessionUpdated));
|
2013-03-06 22:55:33 +00:00
|
|
|
|
|
|
|
this._prepareStartupAnimation();
|
2013-01-28 04:34:33 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_overviewShowing: function() {
|
|
|
|
this._inOverview = true;
|
|
|
|
this._updateVisibility();
|
|
|
|
this._queueUpdateRegions();
|
|
|
|
},
|
2011-07-25 18:25:51 +00:00
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
_overviewHidden: function() {
|
|
|
|
this._inOverview = false;
|
|
|
|
this._updateVisibility();
|
|
|
|
this._queueUpdateRegions();
|
|
|
|
},
|
|
|
|
|
|
|
|
_sessionUpdated: function() {
|
|
|
|
this._updateVisibility();
|
|
|
|
this._queueUpdateRegions();
|
2011-06-13 13:54:05 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_updateMonitors: function() {
|
|
|
|
let screen = global.screen;
|
|
|
|
|
|
|
|
this.monitors = [];
|
|
|
|
let nMonitors = screen.get_n_monitors();
|
|
|
|
for (let i = 0; i < nMonitors; i++)
|
|
|
|
this.monitors.push(screen.get_monitor_geometry(i));
|
|
|
|
|
2011-06-13 14:37:10 +00:00
|
|
|
if (nMonitors == 1) {
|
|
|
|
this.primaryIndex = this.bottomIndex = 0;
|
|
|
|
} else {
|
|
|
|
// If there are monitors below the primary, then we need
|
|
|
|
// to split primary from bottom.
|
|
|
|
this.primaryIndex = this.bottomIndex = screen.get_primary_monitor();
|
|
|
|
for (let i = 0; i < this.monitors.length; i++) {
|
|
|
|
let monitor = this.monitors[i];
|
|
|
|
if (this._isAboveOrBelowPrimary(monitor)) {
|
|
|
|
if (monitor.y > this.monitors[this.bottomIndex].y)
|
|
|
|
this.bottomIndex = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-13 13:54:05 +00:00
|
|
|
this.primaryMonitor = this.monitors[this.primaryIndex];
|
2011-06-13 14:37:10 +00:00
|
|
|
this.bottomMonitor = this.monitors[this.bottomIndex];
|
2011-06-13 13:54:05 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_updateHotCorners: function() {
|
|
|
|
// destroy old hot corners
|
2013-03-01 21:00:37 +00:00
|
|
|
for (let i = 0; i < this.hotCorners.length; i++)
|
|
|
|
this.hotCorners[i].destroy();
|
|
|
|
this.hotCorners = [];
|
2011-06-13 13:54:05 +00:00
|
|
|
|
2013-03-01 20:07:11 +00:00
|
|
|
let size = this.panelBox.height;
|
|
|
|
|
2011-06-13 13:54:05 +00:00
|
|
|
// build new hot corners
|
|
|
|
for (let i = 0; i < this.monitors.length; i++) {
|
|
|
|
let monitor = this.monitors[i];
|
|
|
|
let cornerX = this._rtl ? monitor.x + monitor.width : monitor.x;
|
|
|
|
let cornerY = monitor.y;
|
|
|
|
|
2013-03-01 21:00:37 +00:00
|
|
|
if (i != this.primaryIndex) {
|
|
|
|
let haveTopLeftCorner = true;
|
2011-06-13 13:54:05 +00:00
|
|
|
|
2013-03-01 21:00:37 +00:00
|
|
|
// Check if we have a top left (right for RTL) corner.
|
|
|
|
// I.e. if there is no monitor directly above or to the left(right)
|
|
|
|
let besideX = this._rtl ? monitor.x + 1 : cornerX - 1;
|
|
|
|
let besideY = cornerY;
|
|
|
|
let aboveX = cornerX;
|
|
|
|
let aboveY = cornerY - 1;
|
2011-07-14 12:35:55 +00:00
|
|
|
|
2013-03-01 21:00:37 +00:00
|
|
|
for (let j = 0; j < this.monitors.length; j++) {
|
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
let otherMonitor = this.monitors[j];
|
|
|
|
if (besideX >= otherMonitor.x &&
|
|
|
|
besideX < otherMonitor.x + otherMonitor.width &&
|
|
|
|
besideY >= otherMonitor.y &&
|
|
|
|
besideY < otherMonitor.y + otherMonitor.height) {
|
|
|
|
haveTopLeftCorner = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (aboveX >= otherMonitor.x &&
|
|
|
|
aboveX < otherMonitor.x + otherMonitor.width &&
|
|
|
|
aboveY >= otherMonitor.y &&
|
|
|
|
aboveY < otherMonitor.y + otherMonitor.height) {
|
|
|
|
haveTopLeftCorner = false;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-13 13:54:05 +00:00
|
|
|
}
|
|
|
|
|
2013-03-01 21:00:37 +00:00
|
|
|
if (!haveTopLeftCorner)
|
|
|
|
continue;
|
|
|
|
}
|
2011-06-13 13:54:05 +00:00
|
|
|
|
2013-03-10 02:12:37 +00:00
|
|
|
let corner = new HotCorner(this, monitor, cornerX, cornerY);
|
2013-03-01 20:07:11 +00:00
|
|
|
corner.setBarrierSize(size);
|
2013-03-01 21:00:37 +00:00
|
|
|
this.hotCorners.push(corner);
|
2011-06-13 13:54:05 +00:00
|
|
|
}
|
2013-03-01 21:00:37 +00:00
|
|
|
|
|
|
|
this.emit('hot-corners-changed');
|
2011-06-13 13:54:05 +00:00
|
|
|
},
|
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
_createBackground: function(monitorIndex) {
|
|
|
|
let bgManager = new Background.BackgroundManager({ container: this._backgroundGroup,
|
|
|
|
layoutManager: this,
|
|
|
|
monitorIndex: monitorIndex });
|
2013-02-20 01:18:14 +00:00
|
|
|
BackgroundMenu.addBackgroundMenu(bgManager.background.actor);
|
2012-12-24 14:20:39 +00:00
|
|
|
|
|
|
|
bgManager.connect('changed', Lang.bind(this, function() {
|
|
|
|
BackgroundMenu.addBackgroundMenu(bgManager.background.actor);
|
|
|
|
}));
|
|
|
|
|
|
|
|
this._bgManagers.push(bgManager);
|
|
|
|
|
|
|
|
return bgManager.background;
|
|
|
|
},
|
|
|
|
|
|
|
|
_createSecondaryBackgrounds: function() {
|
|
|
|
for (let i = 0; i < this.monitors.length; i++) {
|
|
|
|
if (i != this.primaryIndex) {
|
|
|
|
let background = this._createBackground(i);
|
|
|
|
|
|
|
|
background.actor.opacity = 0;
|
|
|
|
Tweener.addTween(background.actor,
|
|
|
|
{ opacity: 255,
|
|
|
|
time: BACKGROUND_FADE_ANIMATION_TIME,
|
|
|
|
transition: 'easeOutQuad' });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
_createPrimaryBackground: function() {
|
|
|
|
this._createBackground(this.primaryIndex);
|
|
|
|
},
|
|
|
|
|
|
|
|
_updateBackgrounds: function() {
|
|
|
|
let i;
|
|
|
|
for (i = 0; i < this._bgManagers.length; i++)
|
|
|
|
this._bgManagers[i].destroy();
|
|
|
|
|
|
|
|
this._bgManagers = [];
|
|
|
|
|
|
|
|
if (Main.sessionMode.isGreeter)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (this._startingUp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (let i = 0; i < this.monitors.length; i++) {
|
|
|
|
this._createBackground(i);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2011-07-25 18:25:51 +00:00
|
|
|
_updateBoxes: function() {
|
2012-05-24 20:47:48 +00:00
|
|
|
this.screenShieldGroup.set_position(0, 0);
|
|
|
|
this.screenShieldGroup.set_size(global.screen_width, global.screen_height);
|
|
|
|
|
2011-07-25 18:25:51 +00:00
|
|
|
this.panelBox.set_position(this.primaryMonitor.x, this.primaryMonitor.y);
|
|
|
|
this.panelBox.set_size(this.primaryMonitor.width, -1);
|
|
|
|
|
2012-10-14 16:57:45 +00:00
|
|
|
if (this.keyboardIndex < 0)
|
|
|
|
this.keyboardIndex = this.primaryIndex;
|
2011-08-29 15:11:22 +00:00
|
|
|
|
2011-09-01 15:37:54 +00:00
|
|
|
this.trayBox.set_position(this.bottomMonitor.x,
|
|
|
|
this.bottomMonitor.y + this.bottomMonitor.height);
|
|
|
|
this.trayBox.set_size(this.bottomMonitor.width, -1);
|
2011-07-25 18:25:51 +00:00
|
|
|
},
|
|
|
|
|
2012-12-03 20:56:18 +00:00
|
|
|
_panelBoxChanged: function() {
|
2013-03-01 20:07:11 +00:00
|
|
|
this._updatePanelBarrier();
|
2012-12-03 20:56:18 +00:00
|
|
|
|
2013-03-01 20:07:11 +00:00
|
|
|
let size = this.panelBox.height;
|
|
|
|
this.hotCorners.forEach(function(corner) {
|
|
|
|
corner.setBarrierSize(size);
|
|
|
|
});
|
|
|
|
},
|
2012-07-30 17:02:33 +00:00
|
|
|
|
2013-03-01 20:07:11 +00:00
|
|
|
_updatePanelBarrier: function() {
|
2012-07-30 17:02:33 +00:00
|
|
|
if (this._rightPanelBarrier) {
|
|
|
|
this._rightPanelBarrier.destroy();
|
|
|
|
this._rightPanelBarrier = null;
|
|
|
|
}
|
2011-07-25 18:25:51 +00:00
|
|
|
|
|
|
|
if (this.panelBox.height) {
|
|
|
|
let primary = this.primaryMonitor;
|
2012-07-30 17:02:33 +00:00
|
|
|
|
|
|
|
this._rightPanelBarrier = new Meta.Barrier({ display: global.display,
|
|
|
|
x1: primary.x + primary.width, y1: primary.y,
|
|
|
|
x2: primary.x + primary.width, y2: primary.y + this.panelBox.height,
|
|
|
|
directions: Meta.BarrierDirection.NEGATIVE_X });
|
2011-07-25 18:25:51 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
_setupTrayPressure: function() {
|
|
|
|
this._trayPressure = new PressureBarrier(MESSAGE_TRAY_PRESSURE_THRESHOLD,
|
|
|
|
MESSAGE_TRAY_PRESSURE_TIMEOUT,
|
|
|
|
Shell.KeyBindingMode.NORMAL |
|
|
|
|
Shell.KeyBindingMode.OVERVIEW);
|
|
|
|
this._trayPressure.setEventFilter(this._trayBarrierEventFilter);
|
|
|
|
this._trayPressure.connect('trigger', function(barrier) {
|
2013-03-10 02:11:46 +00:00
|
|
|
if (Main.layoutManager.bottomMonitor.inFullscreen)
|
|
|
|
return;
|
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
Main.messageTray.openTray();
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2012-07-30 19:25:07 +00:00
|
|
|
_updateTrayBarrier: function() {
|
|
|
|
let monitor = this.bottomMonitor;
|
|
|
|
|
|
|
|
if (this._trayBarrier) {
|
2013-03-01 19:57:38 +00:00
|
|
|
this._trayPressure.removeBarrier(this._trayBarrier);
|
2012-07-30 19:25:07 +00:00
|
|
|
this._trayBarrier.destroy();
|
2013-02-18 09:45:06 +00:00
|
|
|
this._trayBarrier = null;
|
2012-07-30 19:25:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
this._trayBarrier = new Meta.Barrier({ display: global.display,
|
|
|
|
x1: monitor.x, x2: monitor.x + monitor.width,
|
|
|
|
y1: monitor.y + monitor.height, y2: monitor.y + monitor.height,
|
|
|
|
directions: Meta.BarrierDirection.NEGATIVE_Y });
|
2013-03-01 19:57:38 +00:00
|
|
|
this._trayPressure.addBarrier(this._trayBarrier);
|
2012-07-30 19:25:07 +00:00
|
|
|
},
|
|
|
|
|
2013-03-01 20:33:39 +00:00
|
|
|
_trayBarrierEventFilter: function(event) {
|
|
|
|
// Throw out all events where the pointer was grabbed by another
|
|
|
|
// client, as the client that grabbed the pointer expects to have
|
|
|
|
// complete control over it
|
|
|
|
if (event.grabbed && Main.modalCount == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
2011-06-13 13:54:05 +00:00
|
|
|
_monitorsChanged: function() {
|
|
|
|
this._updateMonitors();
|
2011-07-25 18:25:51 +00:00
|
|
|
this._updateBoxes();
|
2012-07-30 19:25:07 +00:00
|
|
|
this._updateTrayBarrier();
|
2011-06-13 13:54:05 +00:00
|
|
|
this._updateHotCorners();
|
2012-12-24 14:20:39 +00:00
|
|
|
this._updateBackgrounds();
|
2013-01-28 04:34:33 +00:00
|
|
|
this._updateFullscreen();
|
|
|
|
this._updateVisibility();
|
|
|
|
this._queueUpdateRegions();
|
2011-06-13 13:54:05 +00:00
|
|
|
|
|
|
|
this.emit('monitors-changed');
|
|
|
|
},
|
|
|
|
|
2011-06-13 14:37:10 +00:00
|
|
|
_isAboveOrBelowPrimary: function(monitor) {
|
|
|
|
let primary = this.monitors[this.primaryIndex];
|
|
|
|
let monitorLeft = monitor.x, monitorRight = monitor.x + monitor.width;
|
|
|
|
let primaryLeft = primary.x, primaryRight = primary.x + primary.width;
|
|
|
|
|
2011-10-10 17:21:18 +00:00
|
|
|
if ((monitorLeft >= primaryLeft && monitorLeft < primaryRight) ||
|
|
|
|
(monitorRight > primaryLeft && monitorRight <= primaryRight) ||
|
|
|
|
(primaryLeft >= monitorLeft && primaryLeft < monitorRight) ||
|
|
|
|
(primaryRight > monitorLeft && primaryRight <= monitorRight))
|
2011-06-13 14:37:10 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
2012-06-08 08:26:58 +00:00
|
|
|
get currentMonitor() {
|
|
|
|
let index = global.screen.get_current_monitor();
|
2012-08-22 07:15:53 +00:00
|
|
|
return this.monitors[index];
|
2011-07-25 13:53:19 +00:00
|
|
|
},
|
|
|
|
|
2012-10-14 16:57:45 +00:00
|
|
|
get keyboardMonitor() {
|
|
|
|
return this.monitors[this.keyboardIndex];
|
|
|
|
},
|
|
|
|
|
|
|
|
get focusIndex() {
|
|
|
|
let i = Main.layoutManager.primaryIndex;
|
|
|
|
|
|
|
|
if (global.stage_input_mode == Shell.StageInputMode.FOCUSED ||
|
|
|
|
global.stage_input_mode == Shell.StageInputMode.FULLSCREEN) {
|
|
|
|
let focusActor = global.stage.key_focus;
|
|
|
|
if (focusActor)
|
2013-01-28 04:34:33 +00:00
|
|
|
i = this.findIndexForActor(focusActor);
|
2012-10-14 16:57:45 +00:00
|
|
|
} else {
|
|
|
|
let focusWindow = global.display.focus_window;
|
|
|
|
if (focusWindow)
|
2013-01-28 19:47:51 +00:00
|
|
|
i = focusWindow.get_monitor();
|
2012-10-14 16:57:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return i;
|
|
|
|
},
|
|
|
|
|
|
|
|
get focusMonitor() {
|
|
|
|
return this.monitors[this.focusIndex];
|
|
|
|
},
|
|
|
|
|
|
|
|
set keyboardIndex(v) {
|
|
|
|
this._keyboardIndex = v;
|
|
|
|
this.keyboardBox.set_position(this.keyboardMonitor.x,
|
|
|
|
this.keyboardMonitor.y + this.keyboardMonitor.height);
|
|
|
|
this.keyboardBox.set_size(this.keyboardMonitor.width, -1);
|
|
|
|
},
|
|
|
|
|
|
|
|
get keyboardIndex() {
|
|
|
|
return this._keyboardIndex;
|
|
|
|
},
|
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
// Startup Animations
|
|
|
|
//
|
|
|
|
// We have two different animations, depending on whether we're a greeter
|
|
|
|
// or a normal session.
|
|
|
|
//
|
|
|
|
// In the greeter, we want to animate the panel from the top, and smoothly
|
|
|
|
// fade the login dialog on top of whatever plymouth left on screen which
|
|
|
|
// we get as a still frame background before drawing anything else.
|
|
|
|
//
|
|
|
|
// Here we just have the code to animate the panel, and fade up the background.
|
|
|
|
// The login dialog animation is handled by modalDialog.js
|
|
|
|
//
|
|
|
|
// When starting a normal user session, we want to grow it out of the middle
|
|
|
|
// of the screen.
|
|
|
|
//
|
|
|
|
// Usually, we don't want to paint the stage background color because the
|
|
|
|
// MetaBackgroundActor inside global.window_group covers the entirety of the
|
|
|
|
// screen. So, we set no_clear_hint at the end of the animation.
|
|
|
|
|
2013-03-06 22:55:33 +00:00
|
|
|
_prepareStartupAnimation: function() {
|
2012-12-24 14:20:39 +00:00
|
|
|
// Set ourselves to FULLSCREEN input mode while the animation is running
|
|
|
|
// so events don't get delivered to X11 windows (which are distorted by the animation)
|
|
|
|
global.stage_input_mode = Shell.StageInputMode.FULLSCREEN;
|
|
|
|
|
|
|
|
if (Main.sessionMode.isGreeter) {
|
|
|
|
this.panelBox.translation_y = -this.panelBox.height;
|
|
|
|
} else {
|
2013-02-20 04:21:35 +00:00
|
|
|
// We need to force an update of the regions now before we scale
|
|
|
|
// the UI group to get the coorect allocation for the struts.
|
|
|
|
this._updateRegions();
|
|
|
|
|
2013-02-20 00:56:56 +00:00
|
|
|
this.trayBox.hide();
|
|
|
|
this.keyboardBox.hide();
|
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
let monitor = this.primaryMonitor;
|
|
|
|
let x = monitor.x + monitor.width / 2.0;
|
|
|
|
let y = monitor.y + monitor.height / 2.0;
|
|
|
|
|
|
|
|
this.uiGroup.set_pivot_point(x / global.screen_width,
|
|
|
|
y / global.screen_height);
|
2013-02-21 19:38:50 +00:00
|
|
|
this.uiGroup.scale_x = this.uiGroup.scale_y = 0.5;
|
|
|
|
this.uiGroup.opacity = 0;
|
2012-12-24 14:20:39 +00:00
|
|
|
}
|
2013-02-21 19:32:23 +00:00
|
|
|
|
|
|
|
this._systemBackground = new Background.SystemBackground();
|
|
|
|
this._systemBackground.actor.hide();
|
|
|
|
|
|
|
|
global.stage.insert_child_below(this._systemBackground.actor, null);
|
|
|
|
|
|
|
|
let constraint = new Clutter.BindConstraint({ source: global.stage,
|
|
|
|
coordinate: Clutter.BindCoordinate.ALL });
|
|
|
|
this._systemBackground.actor.add_constraint(constraint);
|
|
|
|
|
|
|
|
let signalId = this._systemBackground.connect('loaded',
|
|
|
|
Lang.bind(this, function() {
|
|
|
|
this._systemBackground.disconnect(signalId);
|
|
|
|
this._systemBackground.actor.show();
|
2013-03-06 22:55:33 +00:00
|
|
|
global.stage.show();
|
|
|
|
|
|
|
|
this.emit('startup-prepared');
|
2013-02-21 19:32:23 +00:00
|
|
|
|
|
|
|
// We're mostly prepared for the startup animation
|
|
|
|
// now, but since a lot is going on asynchronously
|
2013-03-06 22:55:33 +00:00
|
|
|
// during startup, let's defer the startup animation
|
|
|
|
// until the event loop is uncontended and idle.
|
|
|
|
// This helps to prevent us from running the animation
|
|
|
|
// when the system is bogged down
|
2013-02-21 19:32:23 +00:00
|
|
|
GLib.idle_add(GLib.PRIORITY_LOW,
|
|
|
|
Lang.bind(this, function() {
|
2013-03-06 22:55:33 +00:00
|
|
|
this._startupAnimation();
|
|
|
|
return false;
|
|
|
|
}));
|
2013-02-21 19:32:23 +00:00
|
|
|
}));
|
2012-08-22 07:22:30 +00:00
|
|
|
},
|
|
|
|
|
2013-03-06 22:55:33 +00:00
|
|
|
_startupAnimation: function() {
|
2012-12-24 14:20:39 +00:00
|
|
|
if (Main.sessionMode.isGreeter)
|
|
|
|
this._startupAnimationGreeter();
|
|
|
|
else
|
|
|
|
this._startupAnimationSession();
|
|
|
|
},
|
2011-09-02 20:36:02 +00:00
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
_startupAnimationGreeter: function() {
|
2013-02-20 01:41:29 +00:00
|
|
|
Tweener.addTween(this.panelBox,
|
|
|
|
{ translation_y: 0,
|
|
|
|
time: STARTUP_ANIMATION_TIME,
|
|
|
|
transition: 'easeOutQuad',
|
|
|
|
onComplete: this._startupAnimationComplete,
|
|
|
|
onCompleteScope: this });
|
2012-12-24 14:20:39 +00:00
|
|
|
},
|
2012-08-22 07:22:30 +00:00
|
|
|
|
2012-12-24 14:20:39 +00:00
|
|
|
_startupAnimationSession: function() {
|
|
|
|
this._createPrimaryBackground();
|
|
|
|
Tweener.addTween(this.uiGroup,
|
|
|
|
{ scale_x: 1,
|
|
|
|
scale_y: 1,
|
2013-02-21 19:38:50 +00:00
|
|
|
opacity: 255,
|
2011-07-25 18:25:51 +00:00
|
|
|
time: STARTUP_ANIMATION_TIME,
|
2011-09-02 20:36:02 +00:00
|
|
|
transition: 'easeOutQuad',
|
|
|
|
onComplete: this._startupAnimationComplete,
|
2012-12-24 14:20:39 +00:00
|
|
|
onCompleteScope: this });
|
2011-07-25 18:25:51 +00:00
|
|
|
},
|
|
|
|
|
2011-09-02 20:36:02 +00:00
|
|
|
_startupAnimationComplete: function() {
|
2012-12-24 14:20:39 +00:00
|
|
|
// At this point, the UI group is covering everything, so
|
|
|
|
// we no longer need to clear the stage
|
|
|
|
global.stage.no_clear_hint = true;
|
|
|
|
|
|
|
|
global.stage_input_mode = Shell.StageInputMode.NORMAL;
|
|
|
|
|
2013-02-21 19:32:23 +00:00
|
|
|
this._systemBackground.actor.destroy();
|
|
|
|
this._systemBackground = null;
|
2013-02-20 01:31:56 +00:00
|
|
|
|
2013-02-20 01:20:44 +00:00
|
|
|
this._startingUp = false;
|
2012-12-24 14:20:39 +00:00
|
|
|
|
2013-02-20 00:56:56 +00:00
|
|
|
this.trayBox.show();
|
|
|
|
this.keyboardBox.show();
|
|
|
|
|
2013-02-20 01:21:06 +00:00
|
|
|
if (!Main.sessionMode.isGreeter)
|
2012-12-24 14:20:39 +00:00
|
|
|
this._createSecondaryBackgrounds();
|
|
|
|
|
2013-02-20 04:21:35 +00:00
|
|
|
this._queueUpdateRegions();
|
2013-03-04 13:07:14 +00:00
|
|
|
|
|
|
|
this.emit('startup-complete');
|
2011-09-02 20:36:02 +00:00
|
|
|
},
|
|
|
|
|
2011-08-29 15:11:22 +00:00
|
|
|
showKeyboard: function () {
|
2011-09-01 15:02:50 +00:00
|
|
|
this.keyboardBox.raise_top();
|
2011-09-01 15:37:54 +00:00
|
|
|
Tweener.addTween(this.keyboardBox,
|
|
|
|
{ anchor_y: this.keyboardBox.height,
|
2011-08-29 15:11:22 +00:00
|
|
|
time: KEYBOARD_ANIMATION_TIME,
|
|
|
|
transition: 'easeOutQuad',
|
|
|
|
onComplete: this._showKeyboardComplete,
|
|
|
|
onCompleteScope: this
|
|
|
|
});
|
2012-09-08 18:01:30 +00:00
|
|
|
this.emit('keyboard-visible-changed', true);
|
2011-08-29 15:11:22 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_showKeyboardComplete: function() {
|
|
|
|
// Poke Chrome to update the input shape; it doesn't notice
|
|
|
|
// anchor point changes
|
2013-01-28 04:34:33 +00:00
|
|
|
this._updateRegions();
|
2011-08-29 15:11:22 +00:00
|
|
|
|
2011-09-01 15:37:54 +00:00
|
|
|
this._keyboardHeightNotifyId = this.keyboardBox.connect('notify::height', Lang.bind(this, function () {
|
|
|
|
this.keyboardBox.anchor_y = this.keyboardBox.height;
|
2011-08-29 15:11:22 +00:00
|
|
|
}));
|
|
|
|
},
|
|
|
|
|
|
|
|
hideKeyboard: function (immediate) {
|
2011-09-01 15:35:25 +00:00
|
|
|
if (this._keyboardHeightNotifyId) {
|
2011-09-01 15:37:54 +00:00
|
|
|
this.keyboardBox.disconnect(this._keyboardHeightNotifyId);
|
2011-09-01 15:35:25 +00:00
|
|
|
this._keyboardHeightNotifyId = 0;
|
|
|
|
}
|
2011-09-01 15:37:54 +00:00
|
|
|
Tweener.addTween(this.keyboardBox,
|
2011-08-29 15:11:22 +00:00
|
|
|
{ anchor_y: 0,
|
|
|
|
time: immediate ? 0 : KEYBOARD_ANIMATION_TIME,
|
2012-11-15 15:35:20 +00:00
|
|
|
transition: 'easeInQuad',
|
2011-09-01 15:35:25 +00:00
|
|
|
onComplete: this._hideKeyboardComplete,
|
2011-08-29 15:11:22 +00:00
|
|
|
onCompleteScope: this
|
|
|
|
});
|
2012-10-14 16:57:45 +00:00
|
|
|
|
2012-09-08 18:01:30 +00:00
|
|
|
this.emit('keyboard-visible-changed', false);
|
2011-08-29 15:11:22 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_hideKeyboardComplete: function() {
|
2013-01-28 04:34:33 +00:00
|
|
|
this._updateRegions();
|
2011-08-29 15:11:22 +00:00
|
|
|
},
|
|
|
|
|
2011-07-25 13:53:19 +00:00
|
|
|
// addChrome:
|
2011-09-01 14:20:52 +00:00
|
|
|
// @actor: an actor to add to the chrome
|
2011-07-25 13:53:19 +00:00
|
|
|
// @params: (optional) additional params
|
|
|
|
//
|
2011-09-01 14:20:52 +00:00
|
|
|
// Adds @actor to the chrome, and (unless %affectsInputRegion in
|
|
|
|
// @params is %false) extends the input region to include it.
|
2011-07-25 13:53:19 +00:00
|
|
|
// Changes in @actor's size, position, and visibility will
|
|
|
|
// automatically result in appropriate changes to the input
|
|
|
|
// region.
|
|
|
|
//
|
|
|
|
// If %affectsStruts in @params is %true (and @actor is along a
|
|
|
|
// screen edge), then @actor's size and position will also affect
|
|
|
|
// the window manager struts. Changes to @actor's visibility will
|
|
|
|
// NOT affect whether or not the strut is present, however.
|
|
|
|
//
|
2012-05-22 20:16:31 +00:00
|
|
|
// If %trackFullscreen in @params is %true, the actor's visibility
|
|
|
|
// will be bound to the presence of fullscreen windows on the same
|
|
|
|
// monitor (it will be hidden whenever a fullscreen window is visible,
|
|
|
|
// and shown otherwise)
|
2011-07-25 13:53:19 +00:00
|
|
|
addChrome: function(actor, params) {
|
2013-01-10 21:02:20 +00:00
|
|
|
this.uiGroup.add_actor(actor);
|
2013-01-28 04:34:33 +00:00
|
|
|
this._trackActor(actor, params);
|
2011-07-25 13:53:19 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
// trackChrome:
|
|
|
|
// @actor: a descendant of the chrome to begin tracking
|
|
|
|
// @params: parameters describing how to track @actor
|
|
|
|
//
|
|
|
|
// Tells the chrome to track @actor, which must be a descendant
|
|
|
|
// of an actor added via addChrome(). This can be used to extend the
|
|
|
|
// struts or input region to cover specific children.
|
|
|
|
//
|
|
|
|
// @params can have any of the same values as in addChrome(),
|
2012-05-22 20:16:31 +00:00
|
|
|
// though some possibilities don't make sense. By default, @actor has
|
|
|
|
// the same params as its chrome ancestor.
|
2011-07-25 13:53:19 +00:00
|
|
|
trackChrome: function(actor, params) {
|
2011-07-25 13:56:51 +00:00
|
|
|
let ancestor = actor.get_parent();
|
|
|
|
let index = this._findActor(ancestor);
|
|
|
|
while (ancestor && index == -1) {
|
|
|
|
ancestor = ancestor.get_parent();
|
|
|
|
index = this._findActor(ancestor);
|
|
|
|
}
|
|
|
|
if (!ancestor)
|
2011-09-01 14:20:52 +00:00
|
|
|
throw new Error('actor is not a descendent of a chrome actor');
|
2011-07-25 13:56:51 +00:00
|
|
|
|
|
|
|
let ancestorData = this._trackedActors[index];
|
|
|
|
if (!params)
|
|
|
|
params = {};
|
|
|
|
// We can't use Params.parse here because we want to drop
|
|
|
|
// the extra values like ancestorData.actor
|
|
|
|
for (let prop in defaultParams) {
|
2011-10-01 02:23:04 +00:00
|
|
|
if (!params.hasOwnProperty(prop))
|
2011-07-25 13:56:51 +00:00
|
|
|
params[prop] = ancestorData[prop];
|
|
|
|
}
|
|
|
|
|
|
|
|
this._trackActor(actor, params);
|
|
|
|
},
|
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
// untrackChrome:
|
|
|
|
// @actor: an actor previously tracked via trackChrome()
|
|
|
|
//
|
|
|
|
// Undoes the effect of trackChrome()
|
|
|
|
untrackChrome: function(actor) {
|
2011-07-25 13:56:51 +00:00
|
|
|
this._untrackActor(actor);
|
|
|
|
},
|
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
// removeChrome:
|
|
|
|
// @actor: a chrome actor
|
|
|
|
//
|
|
|
|
// Removes @actor from the chrome
|
|
|
|
removeChrome: function(actor) {
|
2013-01-10 21:02:20 +00:00
|
|
|
this.uiGroup.remove_actor(actor);
|
2011-07-25 13:56:51 +00:00
|
|
|
this._untrackActor(actor);
|
|
|
|
},
|
|
|
|
|
|
|
|
_findActor: function(actor) {
|
|
|
|
for (let i = 0; i < this._trackedActors.length; i++) {
|
|
|
|
let actorData = this._trackedActors[i];
|
|
|
|
if (actorData.actor == actor)
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
},
|
|
|
|
|
|
|
|
_trackActor: function(actor, params) {
|
|
|
|
if (this._findActor(actor) != -1)
|
|
|
|
throw new Error('trying to re-track existing chrome actor');
|
|
|
|
|
|
|
|
let actorData = Params.parse(params, defaultParams);
|
|
|
|
actorData.actor = actor;
|
2013-01-10 21:02:20 +00:00
|
|
|
actorData.isToplevel = actor.get_parent() == this.uiGroup;
|
2011-07-25 13:56:51 +00:00
|
|
|
actorData.visibleId = actor.connect('notify::visible',
|
|
|
|
Lang.bind(this, this._queueUpdateRegions));
|
|
|
|
actorData.allocationId = actor.connect('notify::allocation',
|
|
|
|
Lang.bind(this, this._queueUpdateRegions));
|
|
|
|
actorData.parentSetId = actor.connect('parent-set',
|
|
|
|
Lang.bind(this, this._actorReparented));
|
|
|
|
// Note that destroying actor will unset its parent, so we don't
|
|
|
|
// need to connect to 'destroy' too.
|
|
|
|
|
|
|
|
this._trackedActors.push(actorData);
|
|
|
|
this._queueUpdateRegions();
|
|
|
|
},
|
|
|
|
|
|
|
|
_untrackActor: function(actor) {
|
|
|
|
let i = this._findActor(actor);
|
|
|
|
|
|
|
|
if (i == -1)
|
|
|
|
return;
|
|
|
|
let actorData = this._trackedActors[i];
|
|
|
|
|
|
|
|
this._trackedActors.splice(i, 1);
|
|
|
|
actor.disconnect(actorData.visibleId);
|
|
|
|
actor.disconnect(actorData.allocationId);
|
|
|
|
actor.disconnect(actorData.parentSetId);
|
|
|
|
|
|
|
|
this._queueUpdateRegions();
|
|
|
|
},
|
|
|
|
|
|
|
|
_actorReparented: function(actor, oldParent) {
|
2011-09-01 14:20:52 +00:00
|
|
|
let newParent = actor.get_parent();
|
2012-03-27 18:08:54 +00:00
|
|
|
if (!newParent) {
|
2011-07-25 13:56:51 +00:00
|
|
|
this._untrackActor(actor);
|
2012-03-27 18:08:54 +00:00
|
|
|
} else {
|
|
|
|
let i = this._findActor(actor);
|
|
|
|
let actorData = this._trackedActors[i];
|
2013-01-10 21:02:20 +00:00
|
|
|
actorData.isToplevel = (newParent == this.uiGroup);
|
2012-03-27 18:08:54 +00:00
|
|
|
}
|
2011-07-25 13:56:51 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_updateVisibility: function() {
|
|
|
|
for (let i = 0; i < this._trackedActors.length; i++) {
|
2012-05-22 21:24:32 +00:00
|
|
|
let actorData = this._trackedActors[i], visible;
|
2012-05-22 20:16:31 +00:00
|
|
|
if (!actorData.trackFullscreen)
|
|
|
|
continue;
|
2011-09-01 14:20:52 +00:00
|
|
|
if (!actorData.isToplevel)
|
|
|
|
continue;
|
|
|
|
|
2012-09-06 09:42:30 +00:00
|
|
|
if (this._inOverview || !Main.sessionMode.hasWindows)
|
2011-09-01 14:20:52 +00:00
|
|
|
visible = true;
|
2012-05-22 20:16:31 +00:00
|
|
|
else if (this.findMonitorForActor(actorData.actor).inFullscreen)
|
2011-09-01 14:20:52 +00:00
|
|
|
visible = false;
|
2011-07-25 13:56:51 +00:00
|
|
|
else
|
2011-09-01 14:20:52 +00:00
|
|
|
visible = true;
|
2012-05-22 20:16:31 +00:00
|
|
|
actorData.actor.visible = visible;
|
2011-07-25 13:56:51 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2013-01-28 05:09:12 +00:00
|
|
|
getWorkAreaForMonitor: function(monitorIndex) {
|
|
|
|
// Assume that all workspaces will have the same
|
|
|
|
// struts and pick the first one.
|
|
|
|
let ws = global.screen.get_workspace_by_index(0);
|
|
|
|
return ws.get_work_area_for_monitor(monitorIndex);
|
|
|
|
},
|
|
|
|
|
2011-07-25 13:56:51 +00:00
|
|
|
// This call guarantees that we return some monitor to simplify usage of it
|
|
|
|
// In practice all tracked actors should be visible on some monitor anyway
|
2012-10-14 16:57:45 +00:00
|
|
|
findIndexForActor: function(actor) {
|
2011-07-25 13:56:51 +00:00
|
|
|
let [x, y] = actor.get_transformed_position();
|
|
|
|
let [w, h] = actor.get_transformed_size();
|
2013-01-28 04:41:30 +00:00
|
|
|
let rect = new Meta.Rectangle({ x: x, y: y, width: w, height: h });
|
|
|
|
return global.screen.get_monitor_index_for_rect(rect);
|
2012-10-14 16:57:45 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
findMonitorForActor: function(actor) {
|
2013-01-28 04:34:33 +00:00
|
|
|
return this.monitors[this.findIndexForActor(actor)];
|
2011-07-25 13:56:51 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_queueUpdateRegions: function() {
|
2013-02-20 02:06:33 +00:00
|
|
|
if (Main.sessionMode.isGreeter)
|
|
|
|
return;
|
|
|
|
|
2013-02-20 04:21:35 +00:00
|
|
|
if (this._startingUp)
|
|
|
|
return;
|
|
|
|
|
2013-02-20 04:17:16 +00:00
|
|
|
if (!this._updateRegionIdle)
|
2013-01-28 04:34:33 +00:00
|
|
|
this._updateRegionIdle = Mainloop.idle_add(Lang.bind(this, this._updateRegions),
|
2011-07-25 13:56:51 +00:00
|
|
|
Meta.PRIORITY_BEFORE_REDRAW);
|
|
|
|
},
|
|
|
|
|
2013-01-14 17:43:24 +00:00
|
|
|
_getWindowActorsForWorkspace: function(workspace) {
|
|
|
|
return global.get_window_actors().filter(function (actor) {
|
|
|
|
let win = actor.meta_window;
|
|
|
|
return win.located_on_workspace(workspace);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2013-03-12 19:27:51 +00:00
|
|
|
_disconnectTopActor: function(window) {
|
|
|
|
/* O-R status is immutable in Mutter */
|
|
|
|
if (window.metaWindow.is_override_redirect()) {
|
|
|
|
window.disconnect(window._topActorPositionChangedId);
|
|
|
|
delete window._topActorPositionChangedId;
|
|
|
|
window.disconnect(window._topActorSizeChangedId);
|
|
|
|
delete window._topActorSizeChangedId;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
_disconnectTopWindow: function(metaWindow) {
|
|
|
|
metaWindow.disconnect(metaWindow._topActorUnmanagedId);
|
|
|
|
delete window._topActorUnmanagedId;
|
|
|
|
metaWindow.disconnect(metaWindow._topActorNotifyFullscreenId);
|
|
|
|
delete window._topActorNotifyFullscreenId;
|
|
|
|
},
|
|
|
|
|
|
|
|
_topActorUnmanaged: function(metaWindow, window) {
|
|
|
|
/* Actor is already destroyed, so don't disconnect it */
|
|
|
|
this._disconnectTopWindow(metaWindow);
|
|
|
|
|
|
|
|
let i = this._topActors.indexOf(window);
|
|
|
|
this._topActors.splice(i, 1);
|
|
|
|
},
|
|
|
|
|
|
|
|
_topActorChanged: function() {
|
|
|
|
this._windowsRestacked();
|
|
|
|
},
|
|
|
|
|
2011-07-25 13:56:51 +00:00
|
|
|
_updateFullscreen: function() {
|
2013-03-12 19:27:51 +00:00
|
|
|
// Ordinary chrome should be visible unless the top window in
|
|
|
|
// the stack is monitor sized. We allow override-redirect
|
|
|
|
// windows to be above this "top window" because there can be
|
|
|
|
// O-R windows that are offscreen, or otherwise have no
|
|
|
|
// semantic meaning to the user.
|
|
|
|
//
|
|
|
|
// If we wanted to be extra clever, we could figure out when
|
|
|
|
// an OVERRIDE_REDIRECT window was trying to partially overlap
|
|
|
|
// us, and then adjust the input region and our clip region
|
|
|
|
// accordingly...
|
|
|
|
|
|
|
|
// @windows is sorted bottom to top.
|
2013-01-14 17:43:24 +00:00
|
|
|
let windows = this._getWindowActorsForWorkspace(global.screen.get_active_workspace());
|
2011-07-25 13:56:51 +00:00
|
|
|
|
|
|
|
// Reset all monitors to not fullscreen
|
2013-01-28 04:34:33 +00:00
|
|
|
for (let i = 0; i < this.monitors.length; i++)
|
|
|
|
this.monitors[i].inFullscreen = false;
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-03-12 19:27:51 +00:00
|
|
|
let oldTopActors = this._topActors;
|
|
|
|
let newTopActors = [];
|
2011-07-25 13:56:51 +00:00
|
|
|
|
|
|
|
for (let i = windows.length - 1; i > -1; i--) {
|
|
|
|
let window = windows[i];
|
2012-12-16 19:57:54 +00:00
|
|
|
let metaWindow = window.meta_window;
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-03-12 19:27:51 +00:00
|
|
|
// Because we are working with the list of actors, not the list of
|
|
|
|
// windows, we have an uncomfortable corner case to deal with.
|
|
|
|
// If a window is being hidden, it's actor will be left on top
|
|
|
|
// of the actor stack until any animation is done. (See
|
|
|
|
// meta_compositor_sync_stack()). These windows are actually at
|
|
|
|
// the bottom of the window stack, so if they return and become
|
|
|
|
// relevant again, we'll get another ::restacked signal, so we
|
|
|
|
// can just ignore them. This check *DOES NOT* handle destroyed
|
|
|
|
// windows correctly, but we don't currently animate such windows.
|
|
|
|
// If bugs show up here, instead of making this more complex,
|
|
|
|
// add a function to get the window stack from MetaStackTracker.
|
|
|
|
if (!metaWindow.showing_on_its_workspace ())
|
2011-07-25 13:56:51 +00:00
|
|
|
continue;
|
|
|
|
|
2013-03-12 19:27:51 +00:00
|
|
|
newTopActors.push(window);
|
|
|
|
|
|
|
|
if (metaWindow.is_monitor_sized()) {
|
2013-02-18 12:14:42 +00:00
|
|
|
if (metaWindow.is_screen_sized()) {
|
|
|
|
for (let i = 0; i < this.monitors.length; i++)
|
|
|
|
this.monitors[i].inFullscreen = true;
|
|
|
|
} else {
|
2013-02-23 21:02:17 +00:00
|
|
|
let monitors = metaWindow.get_all_monitors();
|
2013-02-28 18:34:05 +00:00
|
|
|
for (let i = 0; i < monitors.length; i++) {
|
|
|
|
let index = monitors[i];
|
|
|
|
this.monitors[index].inFullscreen = true;
|
|
|
|
}
|
2013-02-18 12:14:42 +00:00
|
|
|
}
|
2013-03-12 19:27:51 +00:00
|
|
|
break;
|
2011-07-25 13:56:51 +00:00
|
|
|
}
|
2013-03-12 19:27:51 +00:00
|
|
|
|
|
|
|
if (!window.is_override_redirect())
|
|
|
|
break;
|
2011-07-25 13:56:51 +00:00
|
|
|
}
|
2013-03-12 19:27:51 +00:00
|
|
|
|
|
|
|
// Deal with windows being added or removed from the "top actors" set.
|
|
|
|
// These are the actors that a change to could cause a change in
|
|
|
|
// our computed fullscreen status without a change in the stack.
|
|
|
|
for (let i = 0; i < oldTopActors.length; i++) {
|
|
|
|
let window = oldTopActors[i];
|
|
|
|
if (newTopActors.indexOf(window) < 0) {
|
|
|
|
this._disconnectTopActor(window);
|
|
|
|
this._disconnectTopWindow(window.metaWindow);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (let i = 0; i < newTopActors.length; i++) {
|
|
|
|
let window = newTopActors[i];
|
|
|
|
|
|
|
|
if (oldTopActors.indexOf(window) < 0) {
|
|
|
|
window.metaWindow._topActorUnmanagedId =
|
|
|
|
window.metaWindow.connect('unmanaged',
|
|
|
|
Lang.bind(this, this._topActorUnmanaged, window));
|
|
|
|
window.metaWindow._topActorNotifyFullscreenId =
|
|
|
|
window.metaWindow.connect('notify::fullscreen',
|
|
|
|
Lang.bind(this, this._topActorChanged));
|
|
|
|
|
|
|
|
/* In almost all cases, meta_window_is_monitor_size() depends
|
|
|
|
* on position only for O-R windows. The remaining case is a non-OR,
|
|
|
|
* non-fullscreen window which is screen sized. That is highly
|
|
|
|
* unlikely and probably should be excluded in
|
|
|
|
* meta_window_is_monitor_size().
|
|
|
|
*/
|
|
|
|
if (window.metaWindow.is_override_redirect()) {
|
|
|
|
window._topActorPositionChangedId =
|
|
|
|
window.connect('position-changed',
|
|
|
|
Lang.bind(this, this._topActorChanged));
|
|
|
|
window._topActorSizeChangedId =
|
|
|
|
window.connect('size-changed',
|
|
|
|
Lang.bind(this, this._topActorChanged));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
this._topActors = newTopActors;
|
2011-07-25 13:56:51 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_windowsRestacked: function() {
|
|
|
|
let wasInFullscreen = [];
|
2013-01-28 04:34:33 +00:00
|
|
|
for (let i = 0; i < this.monitors.length; i++)
|
|
|
|
wasInFullscreen[i] = this.monitors[i].inFullscreen;
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
let primaryWasInFullscreen = this.primaryMonitor.inFullscreen;
|
2012-06-06 22:20:23 +00:00
|
|
|
|
2011-07-25 13:56:51 +00:00
|
|
|
this._updateFullscreen();
|
|
|
|
|
|
|
|
let changed = false;
|
|
|
|
for (let i = 0; i < wasInFullscreen.length; i++) {
|
2013-01-28 04:34:33 +00:00
|
|
|
if (wasInFullscreen[i] != this.monitors[i].inFullscreen) {
|
2011-07-25 13:56:51 +00:00
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-06-06 22:20:23 +00:00
|
|
|
|
2013-02-12 21:00:41 +00:00
|
|
|
if (!changed && (this._isPopupWindowVisible != global.top_window_group.get_children().some(isPopupMetaWindow)))
|
|
|
|
changed = true;
|
|
|
|
|
2011-07-25 13:56:51 +00:00
|
|
|
if (changed) {
|
|
|
|
this._updateVisibility();
|
|
|
|
this._queueUpdateRegions();
|
|
|
|
}
|
2012-06-06 22:20:23 +00:00
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
if (primaryWasInFullscreen != this.primaryMonitor.inFullscreen) {
|
2013-02-18 18:26:13 +00:00
|
|
|
let windows = this._getWindowActorsForWorkspace(global.screen.get_active_workspace());
|
2013-02-28 22:17:47 +00:00
|
|
|
for (let i = 0; i < windows.length; i++) {
|
2013-02-18 18:26:13 +00:00
|
|
|
let window = windows[i];
|
|
|
|
let metaWindow = window.meta_window;
|
|
|
|
|
|
|
|
// Skip minimized windows
|
|
|
|
if (!metaWindow.showing_on_its_workspace())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Skip windows that aren't on the primary monitor
|
|
|
|
if (!metaWindow.is_on_primary_monitor())
|
|
|
|
continue;
|
|
|
|
|
2013-02-28 22:17:47 +00:00
|
|
|
// Minimize monitor sized windows that are not focused
|
|
|
|
if (metaWindow.is_monitor_sized() &&
|
|
|
|
!metaWindow.appears_focused)
|
2013-02-18 18:26:13 +00:00
|
|
|
metaWindow.minimize();
|
|
|
|
}
|
2012-06-06 22:20:23 +00:00
|
|
|
}
|
2013-03-11 19:57:32 +00:00
|
|
|
|
|
|
|
this.emit('fullscreen-changed');
|
2011-07-25 13:56:51 +00:00
|
|
|
},
|
|
|
|
|
2013-01-28 04:34:33 +00:00
|
|
|
_updateRegions: function() {
|
2011-07-25 13:56:51 +00:00
|
|
|
let rects = [], struts = [], i;
|
|
|
|
|
2011-08-29 15:11:22 +00:00
|
|
|
if (this._updateRegionIdle) {
|
|
|
|
Mainloop.source_remove(this._updateRegionIdle);
|
|
|
|
delete this._updateRegionIdle;
|
|
|
|
}
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-02-12 21:00:41 +00:00
|
|
|
let isPopupMenuVisible = global.top_window_group.get_children().some(isPopupMetaWindow);
|
|
|
|
let wantsInputRegion = !isPopupMenuVisible;
|
|
|
|
|
2011-07-25 13:56:51 +00:00
|
|
|
for (i = 0; i < this._trackedActors.length; i++) {
|
|
|
|
let actorData = this._trackedActors[i];
|
2013-02-12 21:00:41 +00:00
|
|
|
if (!(actorData.affectsInputRegion && wantsInputRegion) && !actorData.affectsStruts)
|
2011-07-25 13:56:51 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
let [x, y] = actorData.actor.get_transformed_position();
|
|
|
|
let [w, h] = actorData.actor.get_transformed_size();
|
|
|
|
x = Math.round(x);
|
|
|
|
y = Math.round(y);
|
|
|
|
w = Math.round(w);
|
|
|
|
h = Math.round(h);
|
|
|
|
|
2013-02-12 21:00:41 +00:00
|
|
|
if (actorData.affectsInputRegion && wantsInputRegion) {
|
2013-02-12 20:57:08 +00:00
|
|
|
let rect = new Meta.Rectangle({ x: x, y: y, width: w, height: h});
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-02-12 20:57:08 +00:00
|
|
|
if (actorData.actor.get_paint_visibility() &&
|
|
|
|
!this.uiGroup.get_skip_paint(actorData.actor))
|
|
|
|
rects.push(rect);
|
|
|
|
}
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-02-12 20:57:08 +00:00
|
|
|
if (actorData.affectsStruts) {
|
|
|
|
// Limit struts to the size of the screen
|
|
|
|
let x1 = Math.max(x, 0);
|
|
|
|
let x2 = Math.min(x + w, global.screen_width);
|
|
|
|
let y1 = Math.max(y, 0);
|
|
|
|
let y2 = Math.min(y + h, global.screen_height);
|
|
|
|
|
|
|
|
// NetWM struts are not really powerful enought to handle
|
|
|
|
// a multi-monitor scenario, they only describe what happens
|
|
|
|
// around the outer sides of the full display region. However
|
|
|
|
// it can describe a partial region along each side, so
|
|
|
|
// we can support having the struts only affect the
|
|
|
|
// primary monitor. This should be enough as we only have
|
|
|
|
// chrome affecting the struts on the primary monitor so
|
|
|
|
// far.
|
|
|
|
//
|
|
|
|
// Metacity wants to know what side of the screen the
|
|
|
|
// strut is considered to be attached to. If the actor is
|
|
|
|
// only touching one edge, or is touching the entire
|
|
|
|
// border of the primary monitor, then it's obvious which
|
|
|
|
// side to call it. If it's in a corner, we pick a side
|
|
|
|
// arbitrarily. If it doesn't touch any edges, or it spans
|
|
|
|
// the width/height across the middle of the screen, then
|
|
|
|
// we don't create a strut for it at all.
|
|
|
|
let side;
|
|
|
|
let primary = this.primaryMonitor;
|
|
|
|
if (x1 <= primary.x && x2 >= primary.x + primary.width) {
|
|
|
|
if (y1 <= primary.y)
|
|
|
|
side = Meta.Side.TOP;
|
|
|
|
else if (y2 >= primary.y + primary.height)
|
|
|
|
side = Meta.Side.BOTTOM;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
} else if (y1 <= primary.y && y2 >= primary.y + primary.height) {
|
|
|
|
if (x1 <= 0)
|
|
|
|
side = Meta.Side.LEFT;
|
|
|
|
else if (x2 >= primary.x + primary.width)
|
|
|
|
side = Meta.Side.RIGHT;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
} else if (x1 <= 0)
|
2011-07-25 13:56:51 +00:00
|
|
|
side = Meta.Side.LEFT;
|
2013-02-12 20:57:08 +00:00
|
|
|
else if (y1 <= 0)
|
|
|
|
side = Meta.Side.TOP;
|
|
|
|
else if (x2 >= global.screen_width)
|
2011-07-25 13:56:51 +00:00
|
|
|
side = Meta.Side.RIGHT;
|
2013-02-12 20:57:08 +00:00
|
|
|
else if (y2 >= global.screen_height)
|
|
|
|
side = Meta.Side.BOTTOM;
|
2011-07-25 13:56:51 +00:00
|
|
|
else
|
|
|
|
continue;
|
|
|
|
|
2013-02-12 20:57:08 +00:00
|
|
|
// Ensure that the strut rects goes all the way to the screen edge,
|
|
|
|
// as this really what mutter expects.
|
|
|
|
switch (side) {
|
|
|
|
case Meta.Side.TOP:
|
|
|
|
y1 = 0;
|
|
|
|
break;
|
|
|
|
case Meta.Side.BOTTOM:
|
|
|
|
y2 = global.screen_height;
|
|
|
|
break;
|
|
|
|
case Meta.Side.LEFT:
|
|
|
|
x1 = 0;
|
|
|
|
break;
|
|
|
|
case Meta.Side.RIGHT:
|
|
|
|
x2 = global.screen_width;
|
|
|
|
break;
|
|
|
|
}
|
2011-07-25 13:56:51 +00:00
|
|
|
|
2013-02-12 20:57:08 +00:00
|
|
|
let strutRect = new Meta.Rectangle({ x: x1, y: y1, width: x2 - x1, height: y2 - y1});
|
|
|
|
let strut = new Meta.Strut({ rect: strutRect, side: side });
|
|
|
|
struts.push(strut);
|
|
|
|
}
|
2011-07-25 13:56:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
global.set_stage_input_region(rects);
|
2013-02-12 21:00:41 +00:00
|
|
|
this._isPopupWindowVisible = isPopupMenuVisible;
|
2011-07-25 13:56:51 +00:00
|
|
|
|
|
|
|
let screen = global.screen;
|
|
|
|
for (let w = 0; w < screen.n_workspaces; w++) {
|
|
|
|
let workspace = screen.get_workspace_by_index(w);
|
|
|
|
workspace.set_builtin_struts(struts);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2011-11-20 17:56:27 +00:00
|
|
|
});
|
2013-01-28 04:34:33 +00:00
|
|
|
Signals.addSignalMethods(LayoutManager.prototype);
|
2013-01-28 04:32:40 +00:00
|
|
|
|
|
|
|
|
|
|
|
// HotCorner:
|
|
|
|
//
|
|
|
|
// This class manages a "hot corner" that can toggle switching to
|
|
|
|
// overview.
|
|
|
|
const HotCorner = new Lang.Class({
|
|
|
|
Name: 'HotCorner',
|
|
|
|
|
2013-03-10 02:12:37 +00:00
|
|
|
_init : function(layoutManager, monitor, x, y) {
|
2013-01-28 04:32:40 +00:00
|
|
|
// We use this flag to mark the case where the user has entered the
|
|
|
|
// hot corner and has not left both the hot corner and a surrounding
|
|
|
|
// guard area (the "environs"). This avoids triggering the hot corner
|
|
|
|
// multiple times due to an accidental jitter.
|
|
|
|
this._entered = false;
|
|
|
|
|
2013-03-10 02:12:37 +00:00
|
|
|
this._monitor = monitor;
|
|
|
|
|
2013-03-01 20:07:11 +00:00
|
|
|
this._x = x;
|
|
|
|
this._y = y;
|
|
|
|
|
2013-03-05 06:49:35 +00:00
|
|
|
this._setupFallbackCornerIfNeeded(layoutManager);
|
2013-01-28 04:32:40 +00:00
|
|
|
|
2013-03-01 21:19:07 +00:00
|
|
|
this._pressureBarrier = new PressureBarrier(HOT_CORNER_PRESSURE_THRESHOLD,
|
|
|
|
HOT_CORNER_PRESSURE_TIMEOUT,
|
|
|
|
Shell.KeyBindingMode.NORMAL |
|
|
|
|
Shell.KeyBindingMode.OVERVIEW);
|
|
|
|
this._pressureBarrier.connect('trigger', Lang.bind(this, this._toggleOverview));
|
2013-01-28 04:32:40 +00:00
|
|
|
|
|
|
|
// Cache the three ripples instead of dynamically creating and destroying them.
|
|
|
|
this._ripple1 = new St.BoxLayout({ style_class: 'ripple-box', opacity: 0, visible: false });
|
|
|
|
this._ripple2 = new St.BoxLayout({ style_class: 'ripple-box', opacity: 0, visible: false });
|
|
|
|
this._ripple3 = new St.BoxLayout({ style_class: 'ripple-box', opacity: 0, visible: false });
|
|
|
|
|
2013-01-10 21:02:20 +00:00
|
|
|
layoutManager.uiGroup.add_actor(this._ripple1);
|
|
|
|
layoutManager.uiGroup.add_actor(this._ripple2);
|
|
|
|
layoutManager.uiGroup.add_actor(this._ripple3);
|
2013-01-28 04:32:40 +00:00
|
|
|
},
|
|
|
|
|
2013-03-01 20:07:11 +00:00
|
|
|
setBarrierSize: function(size) {
|
|
|
|
if (this._verticalBarrier) {
|
2013-03-01 21:19:07 +00:00
|
|
|
this._pressureBarrier.removeBarrier(this._verticalBarrier);
|
2013-03-01 20:07:11 +00:00
|
|
|
this._verticalBarrier.destroy();
|
|
|
|
this._verticalBarrier = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this._horizontalBarrier) {
|
2013-03-01 21:19:07 +00:00
|
|
|
this._pressureBarrier.removeBarrier(this._horizontalBarrier);
|
2013-03-01 20:07:11 +00:00
|
|
|
this._horizontalBarrier.destroy();
|
|
|
|
this._horizontalBarrier = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
this._verticalBarrier = new Meta.Barrier({ display: global.display,
|
|
|
|
x1: this._x, x2: this._x, y1: this._y, y2: this._y + size,
|
|
|
|
directions: Meta.BarrierDirection.POSITIVE_X });
|
|
|
|
this._horizontalBarrier = new Meta.Barrier({ display: global.display,
|
|
|
|
x1: this._x, x2: this._x + size, y1: this._y, y2: this._y,
|
|
|
|
directions: Meta.BarrierDirection.POSITIVE_Y });
|
2013-03-01 21:19:07 +00:00
|
|
|
|
|
|
|
this._pressureBarrier.addBarrier(this._verticalBarrier);
|
|
|
|
this._pressureBarrier.addBarrier(this._horizontalBarrier);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2013-03-05 06:49:35 +00:00
|
|
|
_setupFallbackCornerIfNeeded: function(layoutManager) {
|
2013-03-01 21:19:07 +00:00
|
|
|
if (!global.display.supports_extended_barriers()) {
|
|
|
|
this.actor = new Clutter.Actor({ name: 'hot-corner-environs',
|
2013-03-05 06:49:35 +00:00
|
|
|
x: this._x, y: this._y,
|
2013-03-01 21:19:07 +00:00
|
|
|
width: 3,
|
|
|
|
height: 3,
|
|
|
|
reactive: true });
|
|
|
|
|
|
|
|
this._corner = new Clutter.Rectangle({ name: 'hot-corner',
|
|
|
|
width: 1,
|
|
|
|
height: 1,
|
|
|
|
opacity: 0,
|
|
|
|
reactive: true });
|
|
|
|
this._corner._delegate = this;
|
|
|
|
|
|
|
|
this.actor.add_child(this._corner);
|
|
|
|
layoutManager.addChrome(this.actor);
|
|
|
|
|
|
|
|
if (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL) {
|
|
|
|
this._corner.set_position(this.actor.width - this._corner.width, 0);
|
|
|
|
this.actor.set_anchor_point_from_gravity(Clutter.Gravity.NORTH_EAST);
|
|
|
|
} else {
|
|
|
|
this._corner.set_position(0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
this.actor.connect('leave-event',
|
|
|
|
Lang.bind(this, this._onEnvironsLeft));
|
|
|
|
|
|
|
|
this._corner.connect('enter-event',
|
|
|
|
Lang.bind(this, this._onCornerEntered));
|
|
|
|
this._corner.connect('leave-event',
|
|
|
|
Lang.bind(this, this._onCornerLeft));
|
2013-03-01 20:07:11 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2013-01-28 04:32:40 +00:00
|
|
|
destroy: function() {
|
2013-03-01 20:07:11 +00:00
|
|
|
this.setBarrierSize(0);
|
2013-03-01 21:19:07 +00:00
|
|
|
this._pressureBarrier.destroy();
|
|
|
|
this._pressureBarrier = null;
|
|
|
|
|
|
|
|
if (this.actor)
|
|
|
|
this.actor.destroy();
|
2013-01-28 04:32:40 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_animRipple : function(ripple, delay, time, startScale, startOpacity, finalScale) {
|
|
|
|
// We draw a ripple by using a source image and animating it scaling
|
|
|
|
// outwards and fading away. We want the ripples to move linearly
|
|
|
|
// or it looks unrealistic, but if the opacity of the ripple goes
|
|
|
|
// linearly to zero it fades away too quickly, so we use Tweener's
|
|
|
|
// 'onUpdate' to give a non-linear curve to the fade-away and make
|
|
|
|
// it more visible in the middle section.
|
|
|
|
|
|
|
|
ripple._opacity = startOpacity;
|
|
|
|
|
|
|
|
if (ripple.get_text_direction() == Clutter.TextDirection.RTL)
|
|
|
|
ripple.set_anchor_point_from_gravity(Clutter.Gravity.NORTH_EAST);
|
|
|
|
|
|
|
|
ripple.visible = true;
|
|
|
|
ripple.opacity = 255 * Math.sqrt(startOpacity);
|
|
|
|
ripple.scale_x = ripple.scale_y = startScale;
|
|
|
|
|
2013-03-03 19:08:30 +00:00
|
|
|
ripple.x = this._x;
|
|
|
|
ripple.y = this._y;
|
2013-01-28 04:32:40 +00:00
|
|
|
|
|
|
|
Tweener.addTween(ripple, { _opacity: 0,
|
|
|
|
scale_x: finalScale,
|
|
|
|
scale_y: finalScale,
|
|
|
|
delay: delay,
|
|
|
|
time: time,
|
|
|
|
transition: 'linear',
|
|
|
|
onUpdate: function() { ripple.opacity = 255 * Math.sqrt(ripple._opacity); },
|
|
|
|
onComplete: function() { ripple.visible = false; } });
|
|
|
|
},
|
|
|
|
|
2013-03-01 21:19:07 +00:00
|
|
|
_rippleAnimation: function() {
|
2013-01-28 04:32:40 +00:00
|
|
|
// Show three concentric ripples expanding outwards; the exact
|
|
|
|
// parameters were found by trial and error, so don't look
|
|
|
|
// for them to make perfect sense mathematically
|
|
|
|
|
|
|
|
// delay time scale opacity => scale
|
|
|
|
this._animRipple(this._ripple1, 0.0, 0.83, 0.25, 1.0, 1.5);
|
|
|
|
this._animRipple(this._ripple2, 0.05, 1.0, 0.0, 0.7, 1.25);
|
|
|
|
this._animRipple(this._ripple3, 0.35, 1.0, 0.0, 0.3, 1);
|
|
|
|
},
|
|
|
|
|
2013-03-01 21:19:07 +00:00
|
|
|
_toggleOverview: function() {
|
2013-03-10 02:12:37 +00:00
|
|
|
if (this._monitor.inFullscreen)
|
|
|
|
return;
|
|
|
|
|
2013-03-04 22:02:02 +00:00
|
|
|
if (Main.overview.shouldToggleByCornerOrButton()) {
|
2013-03-01 21:19:07 +00:00
|
|
|
this._rippleAnimation();
|
2013-03-04 22:02:02 +00:00
|
|
|
Main.overview.toggle();
|
2013-01-28 04:32:40 +00:00
|
|
|
}
|
2013-03-01 21:19:07 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
handleDragOver: function(source, actor, x, y, time) {
|
|
|
|
if (source != Main.xdndHandler)
|
|
|
|
return DND.DragMotionResult.CONTINUE;
|
2013-01-28 04:32:40 +00:00
|
|
|
|
|
|
|
return DND.DragMotionResult.CONTINUE;
|
|
|
|
},
|
|
|
|
|
|
|
|
_onCornerEntered : function() {
|
|
|
|
if (!this._entered) {
|
|
|
|
this._entered = true;
|
2013-03-01 21:19:07 +00:00
|
|
|
this._toggleOverview();
|
2013-01-28 04:32:40 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
|
|
|
_onCornerLeft : function(actor, event) {
|
|
|
|
if (event.get_related() != this.actor)
|
|
|
|
this._entered = false;
|
|
|
|
// Consume event, otherwise this will confuse onEnvironsLeft
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
_onEnvironsLeft : function(actor, event) {
|
|
|
|
if (event.get_related() != this._corner)
|
|
|
|
this._entered = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
});
|
2012-07-30 19:25:07 +00:00
|
|
|
|
|
|
|
const PressureBarrier = new Lang.Class({
|
|
|
|
Name: 'PressureBarrier',
|
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
_init: function(threshold, timeout, keybindingMode) {
|
2012-07-30 19:25:07 +00:00
|
|
|
this._threshold = threshold;
|
|
|
|
this._timeout = timeout;
|
2013-03-01 20:45:56 +00:00
|
|
|
this._keybindingMode = keybindingMode;
|
2013-03-01 19:57:38 +00:00
|
|
|
this._barriers = [];
|
2013-03-01 20:33:39 +00:00
|
|
|
this._eventFilter = null;
|
2012-07-30 19:25:07 +00:00
|
|
|
|
2013-03-01 20:29:42 +00:00
|
|
|
this._isTriggered = false;
|
2012-07-30 19:25:07 +00:00
|
|
|
this._reset();
|
2013-03-01 19:57:38 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
addBarrier: function(barrier) {
|
|
|
|
barrier._pressureHitId = barrier.connect('hit', Lang.bind(this, this._onBarrierHit));
|
|
|
|
barrier._pressureLeftId = barrier.connect('left', Lang.bind(this, this._onBarrierLeft));
|
2012-07-30 19:25:07 +00:00
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
this._barriers.push(barrier);
|
|
|
|
},
|
|
|
|
|
|
|
|
_disconnectBarrier: function(barrier) {
|
|
|
|
barrier.disconnect(barrier._pressureHitId);
|
|
|
|
barrier.disconnect(barrier._pressureLeftId);
|
|
|
|
},
|
|
|
|
|
|
|
|
removeBarrier: function(barrier) {
|
|
|
|
this._disconnectBarrier(barrier);
|
|
|
|
this._barriers.splice(this._barriers.indexOf(barrier), 1);
|
2012-07-30 19:25:07 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
destroy: function() {
|
2013-03-01 19:57:38 +00:00
|
|
|
this._barriers.forEach(Lang.bind(this, this._disconnectBarrier));
|
|
|
|
this._barriers = [];
|
2012-07-30 19:25:07 +00:00
|
|
|
},
|
|
|
|
|
2013-03-01 20:33:39 +00:00
|
|
|
setEventFilter: function(filter) {
|
|
|
|
this._eventFilter = filter;
|
|
|
|
},
|
|
|
|
|
2012-07-30 19:25:07 +00:00
|
|
|
_reset: function() {
|
|
|
|
this._barrierEvents = [];
|
|
|
|
this._currentPressure = 0;
|
|
|
|
this._lastTime = 0;
|
|
|
|
},
|
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
_isHorizontal: function(barrier) {
|
|
|
|
return barrier.y1 == barrier.y2;
|
|
|
|
},
|
|
|
|
|
|
|
|
_getDistanceAcrossBarrier: function(barrier, event) {
|
|
|
|
if (this._isHorizontal(barrier))
|
2012-07-30 19:25:07 +00:00
|
|
|
return Math.abs(event.dy);
|
|
|
|
else
|
|
|
|
return Math.abs(event.dx);
|
|
|
|
},
|
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
_getDistanceAlongBarrier: function(barrier, event) {
|
|
|
|
if (this._isHorizontal(barrier))
|
2012-07-30 19:25:07 +00:00
|
|
|
return Math.abs(event.dx);
|
|
|
|
else
|
|
|
|
return Math.abs(event.dy);
|
|
|
|
},
|
|
|
|
|
|
|
|
_trimBarrierEvents: function() {
|
|
|
|
// Events are guaranteed to be sorted in time order from
|
|
|
|
// oldest to newest, so just look for the first old event,
|
|
|
|
// and then chop events after that off.
|
|
|
|
let i = 0;
|
2013-03-01 20:21:25 +00:00
|
|
|
let threshold = this._lastTime - this._timeout;
|
|
|
|
|
2012-07-30 19:25:07 +00:00
|
|
|
while (i < this._barrierEvents.length) {
|
2013-03-01 20:21:25 +00:00
|
|
|
let [time, distance] = this._barrierEvents[i];
|
|
|
|
if (time >= threshold)
|
2012-07-30 19:25:07 +00:00
|
|
|
break;
|
2013-02-15 02:21:20 +00:00
|
|
|
i++;
|
2012-07-30 19:25:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let firstNewEvent = i;
|
|
|
|
|
|
|
|
for (i = 0; i < firstNewEvent; i++) {
|
2013-03-01 20:21:25 +00:00
|
|
|
let [time, distance] = this._barrierEvents[i];
|
|
|
|
this._currentPressure -= distance;
|
2012-07-30 19:25:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
this._barrierEvents = this._barrierEvents.slice(firstNewEvent);
|
|
|
|
},
|
|
|
|
|
|
|
|
_onBarrierLeft: function(barrier, event) {
|
|
|
|
this._reset();
|
2013-03-01 20:29:42 +00:00
|
|
|
this._isTriggered = false;
|
2012-07-30 19:25:07 +00:00
|
|
|
},
|
|
|
|
|
2013-02-21 22:21:25 +00:00
|
|
|
_trigger: function() {
|
2013-03-01 20:29:42 +00:00
|
|
|
this._isTriggered = true;
|
2013-02-21 22:21:25 +00:00
|
|
|
this.emit('trigger');
|
|
|
|
this._reset();
|
|
|
|
},
|
|
|
|
|
2012-07-30 19:25:07 +00:00
|
|
|
_onBarrierHit: function(barrier, event) {
|
2013-03-01 20:29:42 +00:00
|
|
|
// If we've triggered the barrier, wait until the pointer has the
|
|
|
|
// left the barrier hitbox until we trigger it again.
|
|
|
|
if (this._isTriggered)
|
|
|
|
return;
|
|
|
|
|
2013-03-01 20:33:39 +00:00
|
|
|
if (this._eventFilter && this._eventFilter(event))
|
2013-02-16 21:17:11 +00:00
|
|
|
return;
|
|
|
|
|
2013-03-01 20:45:56 +00:00
|
|
|
// Throw out all events not in the proper keybinding mode
|
|
|
|
if (!(this._keybindingMode & Main.keybindingMode))
|
2012-07-30 19:25:07 +00:00
|
|
|
return;
|
|
|
|
|
2013-03-01 19:57:38 +00:00
|
|
|
let slide = this._getDistanceAlongBarrier(barrier, event);
|
|
|
|
let distance = this._getDistanceAcrossBarrier(barrier, event);
|
2012-07-30 19:25:07 +00:00
|
|
|
|
2013-02-21 22:21:25 +00:00
|
|
|
if (distance >= this._threshold) {
|
|
|
|
this._trigger();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-07-30 19:25:07 +00:00
|
|
|
// Throw out events where the cursor is move more
|
|
|
|
// along the axis of the barrier than moving with
|
|
|
|
// the barrier.
|
|
|
|
if (slide > distance)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this._lastTime = event.time;
|
|
|
|
|
|
|
|
this._trimBarrierEvents();
|
2013-03-01 20:21:25 +00:00
|
|
|
distance = Math.min(15, distance);
|
|
|
|
|
|
|
|
this._barrierEvents.push([event.time, distance]);
|
|
|
|
this._currentPressure += distance;
|
2012-07-30 19:25:07 +00:00
|
|
|
|
2013-02-21 22:21:25 +00:00
|
|
|
if (this._currentPressure >= this._threshold)
|
|
|
|
this._trigger();
|
2012-07-30 19:25:07 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
Signals.addSignalMethods(PressureBarrier.prototype);
|