5a0d8eca9f
The split between this.actor and this.nonOverlayActor in chrome.js is annoying, but aside from actually subclassing ClutterGroup (which would have to be done from C), all of the other possibilities are annoying too.
356 lines
12 KiB
JavaScript
356 lines
12 KiB
JavaScript
/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
|
|
const Clutter = imports.gi.Clutter;
|
|
const Lang = imports.lang;
|
|
const Mainloop = imports.mainloop;
|
|
const Meta = imports.gi.Meta;
|
|
const Shell = imports.gi.Shell;
|
|
|
|
const Main = imports.ui.main;
|
|
|
|
// This manages the shell "chrome"; the UI that's visible in the
|
|
// normal mode (ie, outside the overlay), that surrounds the main
|
|
// workspace content.
|
|
|
|
function Chrome() {
|
|
this._init();
|
|
}
|
|
|
|
Chrome.prototype = {
|
|
_init: function() {
|
|
let global = Shell.Global.get();
|
|
|
|
// The group itself has zero size so it doesn't interfere with DND
|
|
this.actor = new Clutter.Group({ width: 0, height: 0 });
|
|
global.stage.add_actor(this.actor);
|
|
this.nonOverlayActor = new Clutter.Group();
|
|
this.actor.add_actor(this.nonOverlayActor);
|
|
|
|
this._obscuredByFullscreen = false;
|
|
|
|
this._trackedActors = [];
|
|
|
|
global.screen.connect('restacked',
|
|
Lang.bind(this, this._windowsRestacked));
|
|
|
|
// Need to update struts on new workspaces when they are added
|
|
global.screen.connect('notify::n-workspaces',
|
|
Lang.bind(this, this._queueUpdateRegions));
|
|
|
|
Main.overlay.connect('showing',
|
|
Lang.bind(this, this._overlayShowing));
|
|
Main.overlay.connect('hidden',
|
|
Lang.bind(this, this._overlayHidden));
|
|
|
|
this._queueUpdateRegions();
|
|
},
|
|
|
|
_verifyAncestry: function(actor, ancestor) {
|
|
while (actor) {
|
|
if (actor == ancestor)
|
|
return true;
|
|
actor = actor.get_parent();
|
|
}
|
|
return false;
|
|
},
|
|
|
|
// addActor:
|
|
// @actor: an actor to add to the chrome layer
|
|
// @shapeActor: optional "shape actor".
|
|
//
|
|
// Adds @actor to the chrome layer and extends the input region
|
|
// and window manager struts to include it. (Window manager struts
|
|
// will only be affected if @actor is touching a screen edge.)
|
|
// Changes in @actor's size and position will automatically result
|
|
// in appropriate changes to the input region and struts. Changes
|
|
// in its visibility will affect the input region, but NOT the
|
|
// struts.
|
|
//
|
|
// If @shapeActor is provided, it will be used instead of @actor
|
|
// for the input region/strut shape. (This lets you have things like
|
|
// drop shadows in @actor that don't affect the struts.) It must
|
|
// be a child of @actor. Alternatively, you can pass %null for
|
|
// @shapeActor to indicate that @actor should not affect the input
|
|
// region or struts at all.
|
|
addActor: function(actor, shapeActor) {
|
|
if (shapeActor === undefined)
|
|
shapeActor = actor;
|
|
else if (shapeActor && !this._verifyAncestry(shapeActor, actor))
|
|
throw new Error('shapeActor is not a descendent of actor');
|
|
|
|
this.nonOverlayActor.add_actor(actor);
|
|
|
|
if (shapeActor)
|
|
this._trackActor(shapeActor, true, true);
|
|
},
|
|
|
|
// setVisibleInOverlay:
|
|
// @actor: an actor in the chrome layer
|
|
// @visible: overlay visibility
|
|
//
|
|
// By default, actors in the chrome layer are automatically hidden
|
|
// when the overlay is shown. This can be used to override that
|
|
// behavior
|
|
setVisibleInOverlay: function(actor, visible) {
|
|
if (!this._verifyAncestry(actor, this.actor))
|
|
throw new Error('actor is not a descendent of the chrome layer');
|
|
|
|
if (visible)
|
|
actor.reparent(this.actor);
|
|
else
|
|
actor.reparent(this.nonOverlayActor);
|
|
},
|
|
|
|
// addInputRegionActor:
|
|
// @actor: an actor to add to the stage input region
|
|
//
|
|
// Adds @actor to the stage input region, as with addActor(), but
|
|
// for actors that are already descendants of the chrome layer.
|
|
addInputRegionActor: function(actor) {
|
|
if (!this._verifyAncestry(actor, this.actor))
|
|
throw new Error('actor is not a descendent of the chrome layer');
|
|
|
|
this._trackActor(actor, true, false);
|
|
},
|
|
|
|
// removeInputRegionActor:
|
|
// @actor: an actor previously added to the stage input region
|
|
//
|
|
// Undoes the effect of addInputRegionActor()
|
|
removeInputRegionActor: function(actor) {
|
|
this._untrackActor(actor, true, false);
|
|
},
|
|
|
|
// removeActor:
|
|
// @actor: a child of the chrome layer
|
|
//
|
|
// Removes @actor from the chrome layer
|
|
removeActor: function(actor) {
|
|
if (actor.get_parent() == this.nonOverlayActor)
|
|
this.nonOverlayActor.remove_actor(actor);
|
|
else
|
|
this.actor.remove_actor(actor);
|
|
this._untrackActor(actor, true, true);
|
|
},
|
|
|
|
_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, inputRegion, strut) {
|
|
let actorData;
|
|
let i = this._findActor(actor);
|
|
|
|
if (i != -1) {
|
|
actorData = this._trackedActors[i];
|
|
if (inputRegion)
|
|
actorData.inputRegion++;
|
|
if (strut)
|
|
actorData.strut++;
|
|
if (!inputRegion && !strut)
|
|
actorData.children++;
|
|
return;
|
|
}
|
|
|
|
actorData = { actor: actor,
|
|
inputRegion: inputRegion ? 1 : 0,
|
|
strut: strut ? 1 : 0,
|
|
children: 0 };
|
|
|
|
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));
|
|
|
|
this._trackedActors.push(actorData);
|
|
|
|
actor = actor.get_parent();
|
|
if (actor != this.actor && actor != this.nonOverlayActor)
|
|
this._trackActor(actor, false, false);
|
|
|
|
if (inputRegion || strut)
|
|
this._queueUpdateRegions();
|
|
},
|
|
|
|
_untrackActor: function(actor, inputRegion, strut) {
|
|
let i = this._findActor(actor);
|
|
|
|
if (i == -1)
|
|
return;
|
|
let actorData = this._trackedActors[i];
|
|
|
|
if (inputRegion)
|
|
actorData.inputRegion--;
|
|
if (strut)
|
|
actorData.strut--;
|
|
if (!inputRegion && !strut)
|
|
actorData.children--;
|
|
|
|
if (actorData.inputRegion <= 0 && actorData.strut <= 0 && actorData.children <= 0) {
|
|
this._trackedActors.splice(i, 1);
|
|
actor.disconnect(actorData.visibleId);
|
|
actor.disconnect(actorData.allocationId);
|
|
actor.disconnect(actorData.parentSetId);
|
|
|
|
actor = actor.get_parent();
|
|
if (actor && actor != this.actor && actor != this.nonOverlayActor)
|
|
this._untrackActor(actor, false, false);
|
|
}
|
|
|
|
if (inputRegion || strut)
|
|
this._queueUpdateRegions();
|
|
},
|
|
|
|
_actorReparented: function(actor, oldParent) {
|
|
if (this._verifyAncestry(actor, this.actor)) {
|
|
let newParent = actor.get_parent();
|
|
if (newParent != this.actor && newParent != this.nonOverlayActor)
|
|
this._trackActor(newParent, false, false);
|
|
}
|
|
if (oldParent != this.actor && oldParent != this.nonOverlayActor)
|
|
this._untrackActor(oldParent, false, false);
|
|
},
|
|
|
|
_overlayShowing: function() {
|
|
this.actor.show();
|
|
this.nonOverlayActor.hide();
|
|
this._queueUpdateRegions();
|
|
},
|
|
|
|
_overlayHidden: function() {
|
|
if (this._obscuredByFullscreen)
|
|
this.actor.hide();
|
|
this.nonOverlayActor.show();
|
|
this._queueUpdateRegions();
|
|
},
|
|
|
|
_queueUpdateRegions: function() {
|
|
if (!this._updateRegionIdle)
|
|
this._updateRegionIdle = Mainloop.idle_add(Lang.bind(this, this._updateRegions),
|
|
Meta.PRIORITY_BEFORE_REDRAW);
|
|
},
|
|
|
|
_windowsRestacked: function() {
|
|
let global = Shell.Global.get();
|
|
let windows = global.get_windows();
|
|
|
|
// The chrome layer should be visible unless there is a window
|
|
// with layer FULLSCREEN, or a window with layer
|
|
// OVERRIDE_REDIRECT that covers the whole screen.
|
|
// ("override_redirect" is not actually a layer above all
|
|
// other windows, but this seems to be how mutter treats it
|
|
// currently...) 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.
|
|
|
|
this._obscuredByFullscreen = false;
|
|
for (let i = windows.length - 1; i > -1; i--) {
|
|
let layer = windows[i].get_meta_window().get_layer();
|
|
|
|
if (layer == Meta.StackLayer.OVERRIDE_REDIRECT) {
|
|
if (windows[i].x <= 0 &&
|
|
windows[i].x + windows[i].width >= global.screen_width &&
|
|
windows[i].y <= 0 &&
|
|
windows[i].y + windows[i].height >= global.screen_height) {
|
|
this._obscuredByFullscreen = true;
|
|
break;
|
|
}
|
|
} else if (layer == Meta.StackLayer.FULLSCREEN) {
|
|
this._obscuredByFullscreen = true;
|
|
break;
|
|
} else
|
|
break;
|
|
}
|
|
|
|
let shouldBeVisible = !this._obscuredByFullscreen || Main.overlay.visible;
|
|
if (this.actor.visible != shouldBeVisible) {
|
|
this.actor.visible = shouldBeVisible;
|
|
this._queueUpdateRegions();
|
|
}
|
|
},
|
|
|
|
_updateRegions: function() {
|
|
let global = Shell.Global.get();
|
|
let rects = [], struts = [], i;
|
|
|
|
delete this._updateRegionIdle;
|
|
|
|
for (i = 0; i < this._trackedActors.length; i++) {
|
|
let actorData = this._trackedActors[i];
|
|
if (!actorData.inputRegion && !actorData.strut)
|
|
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);
|
|
let rect = new Meta.Rectangle({ x: x, y: y, width: w, height: h});
|
|
|
|
if (actorData.inputRegion && actorData.actor.get_paint_visibility())
|
|
rects.push(rect);
|
|
|
|
if (!actorData.strut)
|
|
continue;
|
|
|
|
// 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
|
|
// width/height of one edge, 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;
|
|
if (w >= global.screen_width) {
|
|
if (y <= 0)
|
|
side = Meta.Side.TOP;
|
|
else if (y + h >= global.screen_height)
|
|
side = Meta.Side.BOTTOM;
|
|
else
|
|
continue;
|
|
} else if (h >= global.screen_height) {
|
|
if (x <= 0)
|
|
side = Meta.Side.LEFT;
|
|
else if (x + w >= global.screen_width)
|
|
side = Meta.Side.RIGHT;
|
|
else
|
|
continue;
|
|
} else if (x <= 0)
|
|
side = Meta.Side.LEFT;
|
|
else if (y <= 0)
|
|
side = Meta.Side.TOP;
|
|
else if (x + w >= global.screen_width)
|
|
side = Meta.Side.RIGHT;
|
|
else if (y + h >= global.screen_height)
|
|
side = Meta.Side.BOTTOM;
|
|
else
|
|
continue;
|
|
|
|
let strut = new Meta.Strut({ rect: rect, side: side });
|
|
struts.push(strut);
|
|
}
|
|
|
|
global.set_stage_input_region(rects);
|
|
|
|
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;
|
|
}
|
|
};
|