2008-12-01 19:51:43 +00:00
|
|
|
/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
|
2008-10-31 18:09:20 +00:00
|
|
|
|
|
|
|
const Clutter = imports.gi.Clutter;
|
2010-05-05 21:05:42 +00:00
|
|
|
const Gio = imports.gi.Gio;
|
2009-05-07 13:54:21 +00:00
|
|
|
const Lang = imports.lang;
|
2008-11-21 13:54:25 +00:00
|
|
|
const Mainloop = imports.mainloop;
|
2010-05-25 14:21:22 +00:00
|
|
|
const Pango = imports.gi.Pango;
|
2008-11-19 23:04:53 +00:00
|
|
|
const Shell = imports.gi.Shell;
|
2009-09-30 14:02:08 +00:00
|
|
|
const St = imports.gi.St;
|
2009-08-11 15:32:58 +00:00
|
|
|
const Signals = imports.signals;
|
2009-08-14 13:30:48 +00:00
|
|
|
const Gettext = imports.gettext.domain('gnome-shell');
|
|
|
|
const _ = Gettext.gettext;
|
2008-10-31 18:09:20 +00:00
|
|
|
|
2009-09-30 14:02:08 +00:00
|
|
|
const Calendar = imports.ui.calendar;
|
2010-07-24 11:57:53 +00:00
|
|
|
const Config = imports.misc.config;
|
2010-05-12 21:07:41 +00:00
|
|
|
const Overview = imports.ui.overview;
|
2010-05-20 15:18:46 +00:00
|
|
|
const PopupMenu = imports.ui.popupMenu;
|
2010-06-22 21:02:26 +00:00
|
|
|
const PanelMenu = imports.ui.panelMenu;
|
|
|
|
const StatusMenu = imports.ui.statusMenu;
|
2008-11-09 18:01:59 +00:00
|
|
|
const Main = imports.ui.main;
|
2010-05-20 15:18:46 +00:00
|
|
|
const Tweener = imports.ui.tweener;
|
2008-10-31 23:09:46 +00:00
|
|
|
|
2009-07-13 16:49:06 +00:00
|
|
|
const PANEL_HEIGHT = 26;
|
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
const PANEL_ICON_SIZE = 24;
|
|
|
|
|
2009-10-06 20:55:29 +00:00
|
|
|
const HOT_CORNER_ACTIVATION_TIMEOUT = 0.5;
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-06-10 12:07:33 +00:00
|
|
|
const ANIMATED_ICON_UPDATE_TIMEOUT = 100;
|
|
|
|
const SPINNER_UPDATE_TIMEOUT = 130;
|
|
|
|
const SPINNER_SPEED = 0.02;
|
|
|
|
|
2010-09-24 19:53:50 +00:00
|
|
|
const STANDARD_TRAY_ICON_ORDER = ['a11y', 'display', 'keyboard', 'volume', 'bluetooth', 'network', 'battery'];
|
2010-06-22 21:06:17 +00:00
|
|
|
const STANDARD_TRAY_ICON_SHELL_IMPLEMENTATION = {
|
2010-07-23 00:39:44 +00:00
|
|
|
'a11y': imports.ui.status.accessibility.ATIndicator,
|
|
|
|
'volume': imports.ui.status.volume.Indicator,
|
2010-11-15 21:45:17 +00:00
|
|
|
'battery': imports.ui.status.power.Indicator
|
2010-06-22 21:06:17 +00:00
|
|
|
};
|
|
|
|
|
2010-07-24 11:57:53 +00:00
|
|
|
if (Config.HAVE_BLUETOOTH)
|
|
|
|
STANDARD_TRAY_ICON_SHELL_IMPLEMENTATION['bluetooth'] = imports.ui.status.bluetooth.Indicator;
|
|
|
|
|
2010-05-05 21:05:42 +00:00
|
|
|
const CLOCK_FORMAT_KEY = 'format';
|
|
|
|
const CLOCK_CUSTOM_FORMAT_KEY = 'custom-format';
|
|
|
|
const CLOCK_SHOW_DATE_KEY = 'show-date';
|
|
|
|
const CLOCK_SHOW_SECONDS_KEY = 'show-seconds';
|
2010-02-25 19:30:23 +00:00
|
|
|
|
2010-06-10 12:07:33 +00:00
|
|
|
function AnimatedIcon(name, size) {
|
|
|
|
this._init(name, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
AnimatedIcon.prototype = {
|
|
|
|
_init: function(name, size) {
|
|
|
|
this.actor = new St.Bin({ visible: false });
|
|
|
|
this.actor.connect('destroy', Lang.bind(this, this._onDestroy));
|
|
|
|
this.actor.connect('notify::visible', Lang.bind(this, function() {
|
|
|
|
if (this.actor.visible) {
|
|
|
|
this._timeoutId = Mainloop.timeout_add(ANIMATED_ICON_UPDATE_TIMEOUT, Lang.bind(this, this._update));
|
|
|
|
} else {
|
|
|
|
if (this._timeoutId)
|
|
|
|
Mainloop.source_remove(this._timeoutId);
|
|
|
|
this._timeoutId = 0;
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
this._timeoutId = 0;
|
|
|
|
this._i = 0;
|
|
|
|
this._animations = St.TextureCache.get_default().load_sliced_image (global.datadir + '/theme/' + name, size, size);
|
|
|
|
this.actor.set_child(this._animations);
|
|
|
|
},
|
|
|
|
|
|
|
|
_update: function() {
|
|
|
|
this._animations.hide_all();
|
|
|
|
this._animations.show();
|
|
|
|
if (this._i && this._i < this._animations.get_n_children())
|
|
|
|
this._animations.get_nth_child(this._i++).show();
|
|
|
|
else {
|
|
|
|
this._i = 1;
|
|
|
|
if (this._animations.get_n_children())
|
|
|
|
this._animations.get_nth_child(0).show();
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
_onDestroy: function() {
|
|
|
|
if (this._timeoutId)
|
|
|
|
Mainloop.source_remove(this._timeoutId);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-12-26 17:00:36 +00:00
|
|
|
function TextShadower() {
|
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
|
|
|
TextShadower.prototype = {
|
|
|
|
_init: function() {
|
|
|
|
this.actor = new Shell.GenericContainer();
|
|
|
|
this.actor.connect('get-preferred-width', Lang.bind(this, this._getPreferredWidth));
|
|
|
|
this.actor.connect('get-preferred-height', Lang.bind(this, this._getPreferredHeight));
|
|
|
|
this.actor.connect('allocate', Lang.bind(this, this._allocate));
|
|
|
|
|
|
|
|
this._label = new St.Label();
|
|
|
|
this.actor.add_actor(this._label);
|
|
|
|
for (let i = 0; i < 4; i++) {
|
|
|
|
let actor = new St.Label({ style_class: 'label-shadow' });
|
2010-05-25 14:21:22 +00:00
|
|
|
actor.clutter_text.ellipsize = Pango.EllipsizeMode.END;
|
2009-12-26 17:00:36 +00:00
|
|
|
this.actor.add_actor(actor);
|
|
|
|
}
|
|
|
|
this._label.raise_top();
|
|
|
|
},
|
|
|
|
|
|
|
|
setText: function(text) {
|
|
|
|
let children = this.actor.get_children();
|
|
|
|
for (let i = 0; i < children.length; i++)
|
|
|
|
children[i].set_text(text);
|
|
|
|
},
|
|
|
|
|
|
|
|
_getPreferredWidth: function(actor, forHeight, alloc) {
|
|
|
|
let [minWidth, natWidth] = this._label.get_preferred_width(forHeight);
|
2010-05-25 13:34:01 +00:00
|
|
|
alloc.min_size = minWidth + 2;
|
|
|
|
alloc.natural_size = natWidth + 2;
|
2009-12-26 17:00:36 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_getPreferredHeight: function(actor, forWidth, alloc) {
|
|
|
|
let [minHeight, natHeight] = this._label.get_preferred_height(forWidth);
|
2010-05-25 13:34:01 +00:00
|
|
|
alloc.min_size = minHeight + 2;
|
|
|
|
alloc.natural_size = natHeight + 2;
|
2009-12-26 17:00:36 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_allocate: function(actor, box, flags) {
|
|
|
|
let children = this.actor.get_children();
|
|
|
|
|
|
|
|
let availWidth = box.x2 - box.x1;
|
|
|
|
let availHeight = box.y2 - box.y1;
|
|
|
|
|
|
|
|
let [minChildWidth, minChildHeight, natChildWidth, natChildHeight] =
|
|
|
|
this._label.get_preferred_size();
|
|
|
|
|
2010-05-25 13:34:01 +00:00
|
|
|
let childWidth = Math.min(natChildWidth, availWidth - 2);
|
|
|
|
let childHeight = Math.min(natChildHeight, availHeight - 2);
|
2009-12-26 17:00:36 +00:00
|
|
|
|
|
|
|
for (let i = 0; i < children.length; i++) {
|
|
|
|
let child = children[i];
|
|
|
|
let childBox = new Clutter.ActorBox();
|
|
|
|
// The order of the labels here is arbitrary, except
|
|
|
|
// we know the "real" label is at the end because Clutter.Group
|
|
|
|
// sorts by Z order
|
|
|
|
switch (i) {
|
|
|
|
case 0: // top
|
|
|
|
childBox.x1 = 1;
|
|
|
|
childBox.y1 = 0;
|
|
|
|
break;
|
|
|
|
case 1: // right
|
|
|
|
childBox.x1 = 2;
|
|
|
|
childBox.y1 = 1;
|
|
|
|
break;
|
|
|
|
case 2: // bottom
|
|
|
|
childBox.x1 = 1;
|
|
|
|
childBox.y1 = 2;
|
|
|
|
break;
|
|
|
|
case 3: // left
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.y1 = 1;
|
|
|
|
break;
|
|
|
|
case 4: // center
|
|
|
|
childBox.x1 = 1;
|
|
|
|
childBox.y1 = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
childBox.x2 = childBox.x1 + childWidth;
|
|
|
|
childBox.y2 = childBox.y1 + childHeight;
|
|
|
|
child.allocate(childBox, flags);
|
|
|
|
}
|
|
|
|
}
|
2010-03-15 13:50:05 +00:00
|
|
|
};
|
2009-12-26 17:00:36 +00:00
|
|
|
|
|
|
|
/**
|
2010-05-05 14:03:48 +00:00
|
|
|
* AppMenuButton:
|
2009-12-26 17:00:36 +00:00
|
|
|
*
|
|
|
|
* This class manages the "application menu" component. It tracks the
|
|
|
|
* currently focused application. However, when an app is launched,
|
|
|
|
* this menu also handles startup notification for it. So when we
|
|
|
|
* have an active startup notification, we switch modes to display that.
|
|
|
|
*/
|
2010-05-05 14:03:48 +00:00
|
|
|
function AppMenuButton() {
|
2009-08-11 15:32:58 +00:00
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
AppMenuButton.prototype = {
|
2010-06-22 21:02:26 +00:00
|
|
|
__proto__: PanelMenu.Button.prototype,
|
2010-05-05 14:03:48 +00:00
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
_init: function() {
|
2010-06-22 21:02:26 +00:00
|
|
|
PanelMenu.Button.prototype._init.call(this, St.Align.START);
|
2009-09-11 21:23:23 +00:00
|
|
|
this._metaDisplay = global.screen.get_display();
|
2010-10-06 21:31:22 +00:00
|
|
|
this._startingApps = [];
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-10-06 21:31:22 +00:00
|
|
|
this._targetApp = null;
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
let bin = new St.Bin({ name: 'appMenu' });
|
|
|
|
this.actor.set_child(bin);
|
2010-02-28 20:36:13 +00:00
|
|
|
this._container = new Shell.GenericContainer();
|
2010-05-05 14:03:48 +00:00
|
|
|
bin.set_child(this._container);
|
|
|
|
this._container.connect('get-preferred-width', Lang.bind(this, this._getContentPreferredWidth));
|
|
|
|
this._container.connect('get-preferred-height', Lang.bind(this, this._getContentPreferredHeight));
|
|
|
|
this._container.connect('allocate', Lang.bind(this, this._contentAllocate));
|
2010-03-12 20:57:01 +00:00
|
|
|
|
2009-12-26 17:00:36 +00:00
|
|
|
this._iconBox = new Shell.Slicer({ name: 'appMenuIcon' });
|
2010-02-28 20:36:13 +00:00
|
|
|
this._container.add_actor(this._iconBox);
|
2009-12-26 17:00:36 +00:00
|
|
|
this._label = new TextShadower();
|
2010-02-28 20:36:13 +00:00
|
|
|
this._container.add_actor(this._label.actor);
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
this._quitMenu = new PopupMenu.PopupMenuItem('');
|
2010-05-12 21:07:41 +00:00
|
|
|
this.menu.addMenuItem(this._quitMenu);
|
|
|
|
this._quitMenu.connect('activate', Lang.bind(this, this._onQuit));
|
2010-05-05 14:03:48 +00:00
|
|
|
|
2010-05-12 21:30:14 +00:00
|
|
|
this._visible = !Main.overview.visible;
|
|
|
|
if (!this._visible)
|
|
|
|
this.hide();
|
2009-08-11 15:32:58 +00:00
|
|
|
Main.overview.connect('hiding', Lang.bind(this, function () {
|
2010-05-12 21:30:14 +00:00
|
|
|
this.show();
|
2009-08-11 15:32:58 +00:00
|
|
|
}));
|
|
|
|
Main.overview.connect('showing', Lang.bind(this, function () {
|
2010-05-12 21:30:14 +00:00
|
|
|
this.hide();
|
2009-08-11 15:32:58 +00:00
|
|
|
}));
|
|
|
|
|
2010-06-10 12:07:33 +00:00
|
|
|
this._updateId = 0;
|
|
|
|
this._animationStep = 0;
|
2010-07-21 02:22:19 +00:00
|
|
|
this._clipWidth = PANEL_ICON_SIZE;
|
2010-06-10 12:07:33 +00:00
|
|
|
this._direction = SPINNER_SPEED;
|
|
|
|
|
2010-07-21 02:22:19 +00:00
|
|
|
this._spinner = new AnimatedIcon('process-working.png',
|
|
|
|
PANEL_ICON_SIZE);
|
2010-06-10 12:07:33 +00:00
|
|
|
this._container.add_actor(this._spinner.actor);
|
|
|
|
this._spinner.actor.lower_bottom();
|
|
|
|
|
|
|
|
this._shadow = new St.Bin({ style_class: 'label-real-shadow' });
|
|
|
|
this._shadow.hide();
|
|
|
|
this._container.add_actor(this._shadow);
|
|
|
|
|
2009-10-15 23:28:29 +00:00
|
|
|
let tracker = Shell.WindowTracker.get_default();
|
|
|
|
tracker.connect('notify::focus-app', Lang.bind(this, this._sync));
|
2010-06-10 12:07:33 +00:00
|
|
|
tracker.connect('app-state-changed', Lang.bind(this, this._onAppStateChanged));
|
2009-08-27 06:22:25 +00:00
|
|
|
|
2010-10-06 21:31:22 +00:00
|
|
|
global.window_manager.connect('switch-workspace', Lang.bind(this, this._sync));
|
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
this._sync();
|
2010-05-12 21:30:14 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
show: function() {
|
|
|
|
if (this._visible)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this.actor.show();
|
|
|
|
Tweener.addTween(this.actor,
|
|
|
|
{ opacity: 255,
|
|
|
|
time: Overview.ANIMATION_TIME,
|
|
|
|
transition: 'easeOutQuad',
|
|
|
|
onComplete: function() {
|
|
|
|
this._visible = true;
|
|
|
|
},
|
|
|
|
onCompleteScope: this });
|
|
|
|
},
|
|
|
|
|
|
|
|
hide: function() {
|
|
|
|
if (!this._visible)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Tweener.addTween(this.actor,
|
|
|
|
{ opacity: 0,
|
|
|
|
time: Overview.ANIMATION_TIME,
|
|
|
|
transition: 'easeOutQuad',
|
|
|
|
onComplete: function() {
|
|
|
|
this.actor.hide();
|
|
|
|
this._visible = false;
|
|
|
|
},
|
|
|
|
onCompleteScope: this });
|
2009-08-11 15:32:58 +00:00
|
|
|
},
|
|
|
|
|
2010-06-10 12:07:33 +00:00
|
|
|
_stopAnimation: function(animate) {
|
|
|
|
this._label.actor.remove_clip();
|
|
|
|
if (this._updateId) {
|
|
|
|
this._shadow.hide();
|
|
|
|
if (animate) {
|
|
|
|
Tweener.addTween(this._spinner.actor,
|
|
|
|
{ opacity: 0,
|
|
|
|
time: 0.2,
|
|
|
|
transition: "easeOutQuad",
|
|
|
|
onCompleteScope: this,
|
|
|
|
onComplete: function() {
|
|
|
|
this._spinner.actor.opacity = 255;
|
|
|
|
this._spinner.actor.hide();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
Mainloop.source_remove(this._updateId);
|
|
|
|
this._updateId = 0;
|
|
|
|
}
|
|
|
|
if (!animate)
|
|
|
|
this._spinner.actor.hide();
|
|
|
|
},
|
|
|
|
|
|
|
|
stopAnimation: function() {
|
|
|
|
this._direction = SPINNER_SPEED * 3;
|
|
|
|
this._stop = true;
|
|
|
|
},
|
|
|
|
|
|
|
|
_update: function() {
|
|
|
|
this._animationStep += this._direction;
|
|
|
|
if (this._animationStep > 1 && this._stop) {
|
|
|
|
this._animationStep = 1;
|
|
|
|
this._stopAnimation(true);
|
|
|
|
return false;
|
|
|
|
}
|
2010-07-06 17:56:40 +00:00
|
|
|
if (this._animationStep > 1)
|
|
|
|
this._animationStep = 1;
|
2010-07-21 02:22:19 +00:00
|
|
|
this._clipWidth = this._label.actor.width - (this._label.actor.width - PANEL_ICON_SIZE) * (1 - this._animationStep);
|
2010-06-10 12:07:33 +00:00
|
|
|
if (this.actor.get_direction() == St.TextDirection.LTR) {
|
|
|
|
this._label.actor.set_clip(0, 0, this._clipWidth + this._shadow.width, this.actor.height);
|
|
|
|
} else {
|
|
|
|
this._label.actor.set_clip(this._label.actor.width - this._clipWidth, 0, this._clipWidth, this.actor.height);
|
|
|
|
}
|
|
|
|
this._container.queue_relayout();
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
startAnimation: function() {
|
|
|
|
this._direction = SPINNER_SPEED;
|
|
|
|
this._stopAnimation(false);
|
|
|
|
this._animationStep = 0;
|
|
|
|
this._update();
|
|
|
|
this._stop = false;
|
|
|
|
this._updateId = Mainloop.timeout_add(SPINNER_UPDATE_TIMEOUT, Lang.bind(this, this._update));
|
|
|
|
this._spinner.actor.show();
|
|
|
|
this._shadow.show();
|
|
|
|
},
|
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
_getContentPreferredWidth: function(actor, forHeight, alloc) {
|
2010-02-28 20:36:13 +00:00
|
|
|
let [minSize, naturalSize] = this._iconBox.get_preferred_width(forHeight);
|
2010-03-01 16:30:31 +00:00
|
|
|
alloc.min_size = minSize;
|
|
|
|
alloc.natural_size = naturalSize;
|
2010-02-28 20:36:13 +00:00
|
|
|
[minSize, naturalSize] = this._label.actor.get_preferred_width(forHeight);
|
2010-03-01 16:30:31 +00:00
|
|
|
alloc.min_size = alloc.min_size + Math.max(0, minSize - Math.floor(alloc.min_size / 2));
|
|
|
|
alloc.natural_size = alloc.natural_size + Math.max(0, naturalSize - Math.floor(alloc.natural_size / 2));
|
2010-02-28 20:36:13 +00:00
|
|
|
},
|
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
_getContentPreferredHeight: function(actor, forWidth, alloc) {
|
2010-02-28 20:36:13 +00:00
|
|
|
let [minSize, naturalSize] = this._iconBox.get_preferred_height(forWidth);
|
|
|
|
alloc.min_size = minSize;
|
|
|
|
alloc.natural_size = naturalSize;
|
2010-05-05 14:03:48 +00:00
|
|
|
[minSizfe, naturalSize] = this._label.actor.get_preferred_height(forWidth);
|
2010-02-28 20:36:13 +00:00
|
|
|
if (minSize > alloc.min_size)
|
|
|
|
alloc.min_size = minSize;
|
|
|
|
if (naturalSize > alloc.natural_size)
|
|
|
|
alloc.natural_size = naturalSize;
|
|
|
|
},
|
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
_contentAllocate: function(actor, box, flags) {
|
2010-02-28 20:36:13 +00:00
|
|
|
let allocWidth = box.x2 - box.x1;
|
|
|
|
let allocHeight = box.y2 - box.y1;
|
|
|
|
let childBox = new Clutter.ActorBox();
|
|
|
|
|
|
|
|
let [minWidth, minHeight, naturalWidth, naturalHeight] = this._iconBox.get_preferred_size();
|
|
|
|
|
2010-03-01 16:30:31 +00:00
|
|
|
let direction = this.actor.get_direction();
|
|
|
|
|
2010-02-28 20:36:13 +00:00
|
|
|
let yPadding = Math.floor(Math.max(0, allocHeight - naturalHeight) / 2);
|
|
|
|
childBox.y1 = yPadding;
|
2010-03-01 16:30:31 +00:00
|
|
|
childBox.y2 = childBox.y1 + Math.min(naturalHeight, allocHeight);
|
|
|
|
if (direction == St.TextDirection.LTR) {
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = childBox.x1 + Math.min(naturalWidth, allocWidth);
|
|
|
|
} else {
|
|
|
|
childBox.x1 = Math.max(0, allocWidth - naturalWidth);
|
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
}
|
2010-02-28 20:36:13 +00:00
|
|
|
this._iconBox.allocate(childBox, flags);
|
|
|
|
|
2010-03-01 16:30:31 +00:00
|
|
|
let iconWidth = childBox.x2 - childBox.x1;
|
|
|
|
|
2010-03-16 14:51:05 +00:00
|
|
|
[minWidth, minHeight, naturalWidth, naturalHeight] = this._label.actor.get_preferred_size();
|
2010-02-28 20:36:13 +00:00
|
|
|
|
|
|
|
yPadding = Math.floor(Math.max(0, allocHeight - naturalHeight) / 2);
|
|
|
|
childBox.y1 = yPadding;
|
2010-03-01 16:30:31 +00:00
|
|
|
childBox.y2 = childBox.y1 + Math.min(naturalHeight, allocHeight);
|
|
|
|
|
|
|
|
if (direction == St.TextDirection.LTR) {
|
|
|
|
childBox.x1 = Math.floor(iconWidth / 2);
|
|
|
|
childBox.x2 = Math.min(childBox.x1 + naturalWidth, allocWidth);
|
|
|
|
} else {
|
|
|
|
childBox.x2 = allocWidth - Math.floor(iconWidth / 2);
|
|
|
|
childBox.x1 = Math.max(0, childBox.x2 - naturalWidth);
|
|
|
|
}
|
2010-02-28 20:36:13 +00:00
|
|
|
this._label.actor.allocate(childBox, flags);
|
2010-06-10 12:07:33 +00:00
|
|
|
|
|
|
|
if (direction == St.TextDirection.LTR) {
|
|
|
|
childBox.x1 = Math.floor(iconWidth / 2) + this._clipWidth + this._shadow.width;
|
|
|
|
childBox.x2 = childBox.x1 + this._spinner.actor.width;
|
|
|
|
childBox.y1 = box.y1;
|
|
|
|
childBox.y2 = box.y2 - 1;
|
|
|
|
this._spinner.actor.allocate(childBox, flags);
|
|
|
|
childBox.x1 = Math.floor(iconWidth / 2) + this._clipWidth + 2;
|
|
|
|
childBox.x2 = childBox.x1 + this._shadow.width;
|
|
|
|
childBox.y1 = box.y1;
|
|
|
|
childBox.y2 = box.y2 - 1;
|
|
|
|
this._shadow.allocate(childBox, flags);
|
|
|
|
} else {
|
|
|
|
childBox.x1 = this._label.actor.width - this._clipWidth - this._spinner.actor.width;
|
|
|
|
childBox.x2 = childBox.x1 + this._spinner.actor.width;
|
|
|
|
childBox.y1 = box.y1;
|
|
|
|
childBox.y2 = box.y2 - 1;
|
|
|
|
this._spinner.actor.allocate(childBox, flags);
|
|
|
|
}
|
2009-12-26 17:00:36 +00:00
|
|
|
},
|
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
_onQuit: function() {
|
2010-11-05 17:48:04 +00:00
|
|
|
if (this._targetApp == null)
|
2010-05-05 14:03:48 +00:00
|
|
|
return;
|
2010-11-05 17:48:04 +00:00
|
|
|
this._targetApp.request_quit();
|
2010-05-05 14:03:48 +00:00
|
|
|
},
|
|
|
|
|
2010-06-10 12:07:33 +00:00
|
|
|
_onAppStateChanged: function(tracker, app) {
|
|
|
|
let state = app.state;
|
2010-10-06 21:31:22 +00:00
|
|
|
if (state != Shell.AppState.STARTING) {
|
|
|
|
this._startingApps = this._startingApps.filter(function(a) {
|
|
|
|
return a != app;
|
|
|
|
});
|
2010-06-10 12:07:33 +00:00
|
|
|
} else if (state == Shell.AppState.STARTING) {
|
2010-10-06 21:31:22 +00:00
|
|
|
this._startingApps.push(app);
|
2010-06-10 12:07:33 +00:00
|
|
|
}
|
|
|
|
// For now just resync on all running state changes; this is mainly to handle
|
|
|
|
// cases where the focused window's application changes without the focus
|
|
|
|
// changing. An example case is how we map OpenOffice.org based on the window
|
|
|
|
// title which is a dynamic property.
|
|
|
|
this._sync();
|
|
|
|
},
|
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
_sync: function() {
|
2009-10-15 23:28:29 +00:00
|
|
|
let tracker = Shell.WindowTracker.get_default();
|
2010-10-06 21:31:22 +00:00
|
|
|
let lastStartedApp = null;
|
|
|
|
let workspace = global.screen.get_active_workspace();
|
|
|
|
for (let i = 0; i < this._startingApps.length; i++)
|
|
|
|
if (this._startingApps[i].is_on_workspace(workspace))
|
|
|
|
lastStartedApp = this._startingApps[i];
|
2009-10-15 23:28:29 +00:00
|
|
|
|
|
|
|
let focusedApp = tracker.focus_app;
|
2010-10-06 21:31:22 +00:00
|
|
|
let targetApp = focusedApp != null ? focusedApp : lastStartedApp;
|
|
|
|
if (targetApp == this._targetApp) {
|
|
|
|
if (targetApp && targetApp.get_state() != Shell.AppState.STARTING)
|
2010-06-10 12:07:33 +00:00
|
|
|
this.stopAnimation();
|
|
|
|
return;
|
|
|
|
}
|
2010-10-06 21:31:22 +00:00
|
|
|
this._stopAnimation();
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-07-02 19:36:56 +00:00
|
|
|
if (!focusedApp) {
|
|
|
|
// If the app has just lost focus to the panel, pretend
|
|
|
|
// nothing happened; otherwise you can't keynav to the
|
|
|
|
// app menu.
|
|
|
|
if (global.stage_input_mode == Shell.StageInputMode.FOCUSED)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-17 22:46:20 +00:00
|
|
|
if (this._iconBox.child != null)
|
|
|
|
this._iconBox.child.destroy();
|
2009-08-11 15:32:58 +00:00
|
|
|
this._iconBox.hide();
|
2009-12-26 17:00:36 +00:00
|
|
|
this._label.setText('');
|
2010-06-10 12:07:33 +00:00
|
|
|
this.actor.reactive = false;
|
2010-02-24 16:29:44 +00:00
|
|
|
|
2010-10-06 21:31:22 +00:00
|
|
|
this._targetApp = targetApp;
|
2010-06-10 12:07:33 +00:00
|
|
|
if (targetApp != null) {
|
2010-07-21 02:22:19 +00:00
|
|
|
let icon = targetApp.get_faded_icon(2 * PANEL_ICON_SIZE);
|
2010-06-10 12:07:33 +00:00
|
|
|
|
|
|
|
this._label.setText(targetApp.get_name());
|
|
|
|
// TODO - _quit() doesn't really work on apps in state STARTING yet
|
2010-07-18 17:33:10 +00:00
|
|
|
this._quitMenu.label.set_text(_("Quit %s").format(targetApp.get_name()));
|
2010-06-10 12:07:33 +00:00
|
|
|
|
|
|
|
this.actor.reactive = true;
|
2010-03-12 20:57:01 +00:00
|
|
|
this._iconBox.set_child(icon);
|
2009-08-11 15:32:58 +00:00
|
|
|
this._iconBox.show();
|
2010-06-10 12:07:33 +00:00
|
|
|
|
|
|
|
if (targetApp.get_state() == Shell.AppState.STARTING)
|
|
|
|
this.startAnimation();
|
2009-08-11 15:32:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
this.emit('changed');
|
|
|
|
}
|
2010-03-15 13:50:05 +00:00
|
|
|
};
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
Signals.addSignalMethods(AppMenuButton.prototype);
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-05-08 22:25:49 +00:00
|
|
|
function ClockButton() {
|
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
|
|
|
ClockButton.prototype = {
|
2010-06-22 21:02:26 +00:00
|
|
|
__proto__: PanelMenu.Button.prototype,
|
2010-05-08 22:25:49 +00:00
|
|
|
|
|
|
|
_init: function() {
|
2010-06-22 21:02:26 +00:00
|
|
|
PanelMenu.Button.prototype._init.call(this, St.Align.START);
|
2010-06-08 15:11:15 +00:00
|
|
|
this.menu.addAction(_("Preferences"), Lang.bind(this, this._onPrefs));
|
2010-05-08 22:25:49 +00:00
|
|
|
|
|
|
|
this._clock = new St.Label();
|
|
|
|
this.actor.set_child(this._clock);
|
|
|
|
|
|
|
|
this._calendarPopup = null;
|
|
|
|
|
2010-05-05 21:05:42 +00:00
|
|
|
this._clockSettings = new Gio.Settings({ schema: 'org.gnome.shell.clock' });
|
|
|
|
this._clockSettings.connect('changed', Lang.bind(this, this._updateClock));
|
2010-05-08 22:25:49 +00:00
|
|
|
|
|
|
|
// Start the clock
|
|
|
|
this._updateClock();
|
|
|
|
},
|
|
|
|
|
|
|
|
_onButtonPress: function(actor, event) {
|
|
|
|
let button = event.get_button();
|
2010-11-19 18:00:59 +00:00
|
|
|
let menuShowing = this.menu.isOpen;
|
|
|
|
let calendarShowing = this._calendarPopup && this._calendarPopup.isOpen;
|
|
|
|
|
|
|
|
if (menuShowing || (button == 3 && !calendarShowing))
|
2010-05-20 15:18:46 +00:00
|
|
|
this.menu.toggle();
|
2010-05-08 22:25:49 +00:00
|
|
|
else
|
|
|
|
this._toggleCalendar();
|
2010-11-19 18:00:59 +00:00
|
|
|
return true;
|
2010-05-08 22:25:49 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
closeCalendar: function() {
|
2010-05-20 15:18:46 +00:00
|
|
|
if (!this._calendarPopup || !this._calendarPopup.isOpen)
|
2010-05-08 22:25:49 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
this._calendarPopup.hide();
|
|
|
|
|
|
|
|
this.actor.remove_style_pseudo_class('pressed');
|
|
|
|
},
|
|
|
|
|
|
|
|
openCalendar: function() {
|
|
|
|
this._calendarPopup.show();
|
|
|
|
|
|
|
|
this.actor.add_style_pseudo_class('pressed');
|
|
|
|
},
|
|
|
|
|
|
|
|
_onPrefs: function() {
|
|
|
|
let args = ['gnome-shell-clock-preferences'];
|
|
|
|
let p = new Shell.Process({ args: args });
|
|
|
|
|
|
|
|
p.run();
|
|
|
|
},
|
|
|
|
|
|
|
|
_toggleCalendar: function() {
|
|
|
|
if (this._calendarPopup == null) {
|
|
|
|
this._calendarPopup = new CalendarPopup();
|
|
|
|
this._calendarPopup.actor.hide();
|
|
|
|
}
|
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
if (this.menu.isOpen && !this._calendarPopup.isOpen) {
|
|
|
|
this.menu.close();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!this._calendarPopup.isOpen)
|
2010-05-08 22:25:49 +00:00
|
|
|
this.openCalendar();
|
2010-05-20 15:18:46 +00:00
|
|
|
else
|
2010-05-08 22:25:49 +00:00
|
|
|
this.closeCalendar();
|
|
|
|
},
|
|
|
|
|
|
|
|
_updateClock: function() {
|
2010-05-05 21:05:42 +00:00
|
|
|
let format = this._clockSettings.get_string(CLOCK_FORMAT_KEY);
|
|
|
|
let showDate = this._clockSettings.get_boolean(CLOCK_SHOW_DATE_KEY);
|
|
|
|
let showSeconds = this._clockSettings.get_boolean(CLOCK_SHOW_SECONDS_KEY);
|
2010-05-08 22:25:49 +00:00
|
|
|
|
|
|
|
let clockFormat;
|
|
|
|
switch (format) {
|
|
|
|
case 'unix':
|
|
|
|
// force updates every second
|
|
|
|
showSeconds = true;
|
|
|
|
clockFormat = '%s';
|
|
|
|
break;
|
|
|
|
case 'custom':
|
|
|
|
// force updates every second
|
|
|
|
showSeconds = true;
|
2010-05-05 21:05:42 +00:00
|
|
|
clockFormat = this._clockSettings.get_string(CLOCK_CUSTOM_FORMAT_KEY);
|
2010-05-08 22:25:49 +00:00
|
|
|
break;
|
|
|
|
case '24-hour':
|
|
|
|
if (showDate)
|
|
|
|
/* Translators: This is the time format with date used
|
|
|
|
in 24-hour mode. */
|
|
|
|
clockFormat = showSeconds ? _("%a %b %e, %R:%S")
|
|
|
|
: _("%a %b %e, %R");
|
|
|
|
else
|
|
|
|
/* Translators: This is the time format without date used
|
|
|
|
in 24-hour mode. */
|
|
|
|
clockFormat = showSeconds ? _("%a %R:%S")
|
|
|
|
: _("%a %R");
|
|
|
|
break;
|
|
|
|
case '12-hour':
|
|
|
|
default:
|
|
|
|
if (showDate)
|
|
|
|
/* Translators: This is a time format with date used
|
|
|
|
for AM/PM. */
|
|
|
|
clockFormat = showSeconds ? _("%a %b %e, %l:%M:%S %p")
|
|
|
|
: _("%a %b %e, %l:%M %p");
|
|
|
|
else
|
|
|
|
/* Translators: This is a time format without date used
|
|
|
|
for AM/PM. */
|
|
|
|
clockFormat = showSeconds ? _("%a %l:%M:%S %p")
|
|
|
|
: _("%a %l:%M %p");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
let displayDate = new Date();
|
|
|
|
let msecRemaining;
|
|
|
|
if (showSeconds) {
|
|
|
|
msecRemaining = 1000 - displayDate.getMilliseconds();
|
|
|
|
if (msecRemaining < 50) {
|
|
|
|
displayDate.setSeconds(displayDate.getSeconds() + 1);
|
|
|
|
msecRemaining += 1000;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
msecRemaining = 60000 - (1000 * displayDate.getSeconds() +
|
|
|
|
displayDate.getMilliseconds());
|
|
|
|
if (msecRemaining < 500) {
|
|
|
|
displayDate.setMinutes(displayDate.getMinutes() + 1);
|
|
|
|
msecRemaining += 60000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
this._clock.set_text(displayDate.toLocaleFormat(clockFormat));
|
|
|
|
Mainloop.timeout_add(msecRemaining, Lang.bind(this, this._updateClock));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-10-31 18:09:20 +00:00
|
|
|
function Panel() {
|
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
|
|
|
Panel.prototype = {
|
2010-05-05 14:03:48 +00:00
|
|
|
_init : function() {
|
2010-05-20 15:18:46 +00:00
|
|
|
this.actor = new St.BoxLayout({ style_class: 'menu-bar',
|
|
|
|
name: 'panel',
|
|
|
|
reactive: true });
|
2009-11-10 17:13:58 +00:00
|
|
|
this.actor._delegate = this;
|
|
|
|
|
2010-07-16 11:48:05 +00:00
|
|
|
Main.overview.connect('shown', Lang.bind(this, function () {
|
|
|
|
this.actor.add_style_class_name('in-overview');
|
|
|
|
}));
|
|
|
|
Main.overview.connect('hiding', Lang.bind(this, function () {
|
|
|
|
this.actor.remove_style_class_name('in-overview');
|
|
|
|
}));
|
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
this._menus = new PopupMenu.PopupMenuManager(this);
|
|
|
|
|
2009-11-17 22:46:20 +00:00
|
|
|
this._leftBox = new St.BoxLayout({ name: 'panelLeft' });
|
|
|
|
this._centerBox = new St.BoxLayout({ name: 'panelCenter' });
|
|
|
|
this._rightBox = new St.BoxLayout({ name: 'panelRight' });
|
2009-08-11 15:16:25 +00:00
|
|
|
|
|
|
|
/* This box container ensures that the centerBox is positioned in the *absolute*
|
|
|
|
* center, but can be pushed aside if necessary. */
|
|
|
|
this._boxContainer = new Shell.GenericContainer();
|
2009-11-17 22:46:20 +00:00
|
|
|
this.actor.add(this._boxContainer, { expand: true });
|
2009-08-11 15:16:25 +00:00
|
|
|
this._boxContainer.add_actor(this._leftBox);
|
|
|
|
this._boxContainer.add_actor(this._centerBox);
|
|
|
|
this._boxContainer.add_actor(this._rightBox);
|
|
|
|
this._boxContainer.connect('get-preferred-width', Lang.bind(this, function(box, forHeight, alloc) {
|
|
|
|
let children = box.get_children();
|
|
|
|
for (let i = 0; i < children.length; i++) {
|
|
|
|
let [childMin, childNatural] = children[i].get_preferred_width(forHeight);
|
|
|
|
alloc.min_size += childMin;
|
|
|
|
alloc.natural_size += childNatural;
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
this._boxContainer.connect('get-preferred-height', Lang.bind(this, function(box, forWidth, alloc) {
|
|
|
|
let children = box.get_children();
|
|
|
|
for (let i = 0; i < children.length; i++) {
|
|
|
|
let [childMin, childNatural] = children[i].get_preferred_height(forWidth);
|
|
|
|
if (childMin > alloc.min_size)
|
|
|
|
alloc.min_size = childMin;
|
|
|
|
if (childNatural > alloc.natural_size)
|
|
|
|
alloc.natural_size = childNatural;
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
this._boxContainer.connect('allocate', Lang.bind(this, function(container, box, flags) {
|
|
|
|
let allocWidth = box.x2 - box.x1;
|
|
|
|
let allocHeight = box.y2 - box.y1;
|
|
|
|
let [leftMinWidth, leftNaturalWidth] = this._leftBox.get_preferred_width(-1);
|
|
|
|
let [centerMinWidth, centerNaturalWidth] = this._centerBox.get_preferred_width(-1);
|
|
|
|
let [rightMinWidth, rightNaturalWidth] = this._rightBox.get_preferred_width(-1);
|
|
|
|
|
2010-05-25 14:21:22 +00:00
|
|
|
let sideWidth, centerWidth;
|
|
|
|
centerWidth = centerNaturalWidth;
|
|
|
|
sideWidth = (allocWidth - centerWidth) / 2;
|
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
let childBox = new Clutter.ActorBox();
|
2010-04-27 13:46:19 +00:00
|
|
|
childBox.y1 = 0;
|
2010-06-18 23:02:50 +00:00
|
|
|
childBox.y2 = this._hotCornerEnvirons.height;
|
|
|
|
if (this.actor.get_direction() == St.TextDirection.RTL) {
|
|
|
|
childBox.x1 = allocWidth - this._hotCornerEnvirons.width;
|
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
} else {
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = this._hotCornerEnvirons.width;
|
|
|
|
}
|
|
|
|
this._hotCornerEnvirons.allocate(childBox, flags);
|
|
|
|
|
|
|
|
childBox.y1 = 0;
|
|
|
|
childBox.y2 = this._hotCorner.height;
|
|
|
|
if (this.actor.get_direction() == St.TextDirection.RTL) {
|
|
|
|
childBox.x1 = allocWidth - this._hotCorner.width;
|
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
} else {
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = this._hotCorner.width;
|
|
|
|
}
|
|
|
|
this._hotCorner.allocate(childBox, flags);
|
|
|
|
|
|
|
|
childBox.y1 = 0;
|
2010-04-27 13:46:19 +00:00
|
|
|
childBox.y2 = allocHeight;
|
2010-06-18 23:02:50 +00:00
|
|
|
if (this.actor.get_direction() == St.TextDirection.RTL) {
|
|
|
|
childBox.x1 = allocWidth - Math.min(Math.floor(sideWidth),
|
|
|
|
leftNaturalWidth);
|
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
} else {
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = Math.min(Math.floor(sideWidth),
|
|
|
|
leftNaturalWidth);
|
|
|
|
}
|
2009-08-11 15:16:25 +00:00
|
|
|
this._leftBox.allocate(childBox, flags);
|
|
|
|
|
2010-05-25 14:21:22 +00:00
|
|
|
childBox.x1 = Math.ceil(sideWidth);
|
2010-04-27 13:46:19 +00:00
|
|
|
childBox.y1 = 0;
|
2010-05-25 14:21:22 +00:00
|
|
|
childBox.x2 = childBox.x1 + centerWidth;
|
2010-04-27 13:46:19 +00:00
|
|
|
childBox.y2 = allocHeight;
|
2009-08-11 15:16:25 +00:00
|
|
|
this._centerBox.allocate(childBox, flags);
|
|
|
|
|
2010-04-27 13:46:19 +00:00
|
|
|
childBox.y1 = 0;
|
|
|
|
childBox.y2 = allocHeight;
|
2010-06-18 23:02:50 +00:00
|
|
|
if (this.actor.get_direction() == St.TextDirection.RTL) {
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = Math.min(Math.floor(sideWidth),
|
|
|
|
rightNaturalWidth);
|
|
|
|
} else {
|
|
|
|
childBox.x1 = allocWidth - Math.min(Math.floor(sideWidth),
|
|
|
|
rightNaturalWidth);
|
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
}
|
2009-08-11 15:16:25 +00:00
|
|
|
this._rightBox.allocate(childBox, flags);
|
|
|
|
}));
|
|
|
|
|
2009-10-09 04:30:10 +00:00
|
|
|
/* Button on the left side of the panel. */
|
|
|
|
/* Translators: If there is no suitable word for "Activities" in your language, you can use the word for "Overview". */
|
2009-11-16 19:16:22 +00:00
|
|
|
let label = new St.Label({ text: _("Activities") });
|
2009-11-17 22:46:20 +00:00
|
|
|
this.button = new St.Clickable({ name: 'panelActivities',
|
2010-10-07 18:15:51 +00:00
|
|
|
style_class: 'panel-button',
|
|
|
|
reactive: true,
|
|
|
|
can_focus: true });
|
2009-11-16 19:16:22 +00:00
|
|
|
this.button.set_child(label);
|
2009-08-11 15:16:25 +00:00
|
|
|
|
2009-11-17 22:46:20 +00:00
|
|
|
this._leftBox.add(this.button);
|
2008-12-01 19:51:43 +00:00
|
|
|
|
2009-08-18 18:59:53 +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._hotCornerEntered = false;
|
|
|
|
|
2010-06-18 23:02:50 +00:00
|
|
|
this._hotCornerEnvirons = new Clutter.Rectangle({ width: 3,
|
2009-08-18 18:59:53 +00:00
|
|
|
height: 3,
|
|
|
|
opacity: 0,
|
|
|
|
reactive: true });
|
|
|
|
|
2010-06-18 23:02:50 +00:00
|
|
|
this._hotCorner = new Clutter.Rectangle({ width: 1,
|
2009-08-21 19:56:07 +00:00
|
|
|
height: 1,
|
|
|
|
opacity: 0,
|
|
|
|
reactive: true });
|
2009-08-07 20:45:35 +00:00
|
|
|
|
2009-10-06 20:55:29 +00:00
|
|
|
this._hotCornerActivationTime = 0;
|
|
|
|
|
2009-08-18 18:59:53 +00:00
|
|
|
this._hotCornerEnvirons.connect('leave-event',
|
|
|
|
Lang.bind(this, this._onHotCornerEnvironsLeft));
|
|
|
|
// Clicking on the hot corner environs should result in the same bahavior
|
|
|
|
// as clicking on the hot corner.
|
|
|
|
this._hotCornerEnvirons.connect('button-release-event',
|
|
|
|
Lang.bind(this, this._onHotCornerClicked));
|
|
|
|
|
2009-08-07 20:45:35 +00:00
|
|
|
// In addition to being triggered by the mouse enter event, the hot corner
|
2010-06-10 12:07:33 +00:00
|
|
|
// can be triggered by clicking on it. This is useful if the user wants to
|
2009-08-07 22:22:05 +00:00
|
|
|
// undo the effect of triggering the hot corner once in the hot corner.
|
2009-08-21 19:56:07 +00:00
|
|
|
this._hotCorner.connect('enter-event',
|
|
|
|
Lang.bind(this, this._onHotCornerEntered));
|
|
|
|
this._hotCorner.connect('button-release-event',
|
|
|
|
Lang.bind(this, this._onHotCornerClicked));
|
|
|
|
this._hotCorner.connect('leave-event',
|
|
|
|
Lang.bind(this, this._onHotCornerLeft));
|
2009-08-07 20:45:35 +00:00
|
|
|
|
2010-06-18 23:02:50 +00:00
|
|
|
this._boxContainer.add_actor(this._hotCornerEnvirons);
|
|
|
|
this._boxContainer.add_actor(this._hotCorner);
|
2009-08-07 20:45:35 +00:00
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
let appMenuButton = new AppMenuButton();
|
|
|
|
this._leftBox.add(appMenuButton.actor);
|
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
this._menus.addMenu(appMenuButton.menu);
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
/* center */
|
2009-02-04 18:45:38 +00:00
|
|
|
|
2010-05-08 22:25:49 +00:00
|
|
|
this._clockButton = new ClockButton();
|
|
|
|
this._centerBox.add(this._clockButton.actor, { y_fill: true });
|
2009-09-30 14:02:08 +00:00
|
|
|
|
2010-11-19 18:00:59 +00:00
|
|
|
let clockMenuManager = new PopupMenu.PopupMenuManager(this);
|
|
|
|
clockMenuManager.addMenu(this._clockButton.menu);
|
2009-08-11 15:16:25 +00:00
|
|
|
|
|
|
|
/* right */
|
2008-12-01 19:51:43 +00:00
|
|
|
|
2010-06-22 21:06:17 +00:00
|
|
|
// System status applets live in statusBox, while legacy tray icons
|
|
|
|
// live in trayBox
|
2009-03-24 18:25:07 +00:00
|
|
|
// The trayBox is hidden when there are no tray icons.
|
2010-06-22 21:06:17 +00:00
|
|
|
let statusBox = new St.BoxLayout({ name: 'statusTray' });
|
|
|
|
let trayBox = new St.BoxLayout({ name: 'legacyTray' });
|
2009-08-02 02:11:37 +00:00
|
|
|
this._trayBox = trayBox;
|
2010-06-22 21:06:17 +00:00
|
|
|
this._statusBox = statusBox;
|
2009-05-13 15:54:09 +00:00
|
|
|
|
2009-03-24 18:25:07 +00:00
|
|
|
trayBox.hide();
|
2010-06-22 21:06:17 +00:00
|
|
|
this._rightBox.add(trayBox);
|
|
|
|
this._rightBox.add(statusBox);
|
|
|
|
|
2010-08-09 16:33:34 +00:00
|
|
|
Main.statusIconDispatcher.connect('status-icon-added', Lang.bind(this, this._onTrayIconAdded));
|
|
|
|
Main.statusIconDispatcher.connect('status-icon-removed', Lang.bind(this, this._onTrayIconRemoved));
|
2008-12-01 19:51:43 +00:00
|
|
|
|
2009-08-11 11:46:10 +00:00
|
|
|
// TODO: decide what to do with the rest of the panel in the Overview mode (make it fade-out, become non-reactive, etc.)
|
|
|
|
// We get into the Overview mode on button-press-event as opposed to button-release-event because eventually we'll probably
|
|
|
|
// have the Overview act like a menu that allows the user to release the mouse on the activity the user wants
|
2008-12-01 19:51:43 +00:00
|
|
|
// to switch to.
|
2009-11-17 22:46:20 +00:00
|
|
|
this.button.connect('clicked', Lang.bind(this, function(b, event) {
|
2009-11-16 19:16:22 +00:00
|
|
|
if (!Main.overview.animationInProgress) {
|
2009-10-06 20:55:29 +00:00
|
|
|
this._maybeToggleOverviewOnClick();
|
2009-08-29 11:23:28 +00:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
2009-10-06 20:55:29 +00:00
|
|
|
}));
|
2009-08-11 11:46:10 +00:00
|
|
|
// In addition to pressing the button, the Overview can be entered and exited by other means, such as
|
|
|
|
// pressing the System key, Alt+F1 or Esc. We want the button to be pressed in when the Overview is entered
|
2009-05-08 20:27:14 +00:00
|
|
|
// and to be released when it is exited regardless of how it was triggered.
|
2009-08-29 11:23:28 +00:00
|
|
|
Main.overview.connect('showing', Lang.bind(this, function() {
|
2009-11-16 19:16:22 +00:00
|
|
|
this.button.active = true;
|
2009-08-29 11:23:28 +00:00
|
|
|
}));
|
|
|
|
Main.overview.connect('hiding', Lang.bind(this, function() {
|
2009-11-16 19:16:22 +00:00
|
|
|
this.button.active = false;
|
2009-08-29 11:23:28 +00:00
|
|
|
}));
|
2008-11-28 20:12:20 +00:00
|
|
|
|
2009-11-11 18:11:34 +00:00
|
|
|
Main.chrome.addActor(this.actor, { visibleInOverview: true });
|
2008-12-01 19:51:43 +00:00
|
|
|
},
|
|
|
|
|
2010-07-24 11:57:53 +00:00
|
|
|
startStatusArea: function() {
|
|
|
|
for (let i = 0; i < STANDARD_TRAY_ICON_ORDER.length; i++) {
|
|
|
|
let role = STANDARD_TRAY_ICON_ORDER[i];
|
|
|
|
let constructor = STANDARD_TRAY_ICON_SHELL_IMPLEMENTATION[role];
|
|
|
|
if (!constructor) {
|
|
|
|
// This icon is not implemented (this is a bug)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
let indicator = new constructor();
|
|
|
|
this._statusBox.add(indicator.actor);
|
|
|
|
this._menus.addMenu(indicator.menu);
|
|
|
|
}
|
|
|
|
|
|
|
|
this._statusmenu = new StatusMenu.StatusMenuButton();
|
|
|
|
this._menus.addMenu(this._statusmenu.menu);
|
|
|
|
this._rightBox.add(this._statusmenu.actor);
|
|
|
|
},
|
|
|
|
|
2010-01-19 17:59:29 +00:00
|
|
|
hideCalendar: function() {
|
2010-05-08 22:25:49 +00:00
|
|
|
this._clockButton.closeCalendar();
|
2010-01-19 17:59:29 +00:00
|
|
|
},
|
|
|
|
|
2009-07-02 04:52:21 +00:00
|
|
|
startupAnimation: function() {
|
|
|
|
this.actor.y = -this.actor.height;
|
|
|
|
Tweener.addTween(this.actor,
|
|
|
|
{ y: 0,
|
|
|
|
time: 0.2,
|
2010-05-13 19:46:04 +00:00
|
|
|
transition: 'easeOutQuad'
|
2009-07-02 04:52:21 +00:00
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2010-08-09 16:33:34 +00:00
|
|
|
_onTrayIconAdded: function(o, icon, role) {
|
2010-03-31 20:40:32 +00:00
|
|
|
icon.height = PANEL_ICON_SIZE;
|
|
|
|
|
2010-08-09 16:33:34 +00:00
|
|
|
if (STANDARD_TRAY_ICON_SHELL_IMPLEMENTATION[role]) {
|
|
|
|
// This icon is legacy, and replaced by a Shell version
|
|
|
|
// Hide it
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Figure out the index in our well-known order for this icon
|
|
|
|
let position = STANDARD_TRAY_ICON_ORDER.indexOf(role);
|
|
|
|
icon._rolePosition = position;
|
|
|
|
let children = this._trayBox.get_children();
|
|
|
|
let i;
|
|
|
|
// Walk children backwards, until we find one that isn't
|
|
|
|
// well-known, or one where we should follow
|
|
|
|
for (i = children.length - 1; i >= 0; i--) {
|
|
|
|
let rolePosition = children[i]._rolePosition;
|
|
|
|
if (!rolePosition || position > rolePosition) {
|
|
|
|
this._trayBox.insert_actor(icon, i + 1);
|
|
|
|
break;
|
2009-10-15 13:44:09 +00:00
|
|
|
}
|
|
|
|
}
|
2010-08-09 16:33:34 +00:00
|
|
|
if (i == -1) {
|
|
|
|
// If we didn't find a position, we must be first
|
|
|
|
this._trayBox.insert_actor(icon, 0);
|
|
|
|
}
|
2009-10-15 13:44:09 +00:00
|
|
|
|
|
|
|
// Make sure the trayBox is shown.
|
|
|
|
this._trayBox.show();
|
|
|
|
},
|
|
|
|
|
2010-08-09 16:33:34 +00:00
|
|
|
_onTrayIconRemoved: function(o, icon) {
|
2010-10-28 20:25:33 +00:00
|
|
|
if (icon.get_parent() != null)
|
|
|
|
this._trayBox.remove_actor(icon);
|
2009-08-02 02:11:37 +00:00
|
|
|
},
|
|
|
|
|
2010-01-14 02:48:12 +00:00
|
|
|
_addRipple : function(delay, time, startScale, startOpacity, finalScale, finalOpacity) {
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
let [x, y] = this._hotCorner.get_transformed_position();
|
|
|
|
let ripple = new St.BoxLayout({ style_class: 'ripple-box',
|
|
|
|
opacity: 255 * Math.sqrt(startOpacity),
|
|
|
|
scale_x: startScale,
|
|
|
|
scale_y: startScale,
|
|
|
|
x: x,
|
|
|
|
y: y });
|
|
|
|
ripple._opacity = startOpacity;
|
|
|
|
Tweener.addTween(ripple, { _opacity: finalOpacity,
|
|
|
|
scale_x: finalScale,
|
|
|
|
scale_y: finalScale,
|
|
|
|
delay: delay,
|
|
|
|
time: time,
|
|
|
|
transition: 'linear',
|
|
|
|
onUpdate: function() { ripple.opacity = 255 * Math.sqrt(ripple._opacity); },
|
|
|
|
onComplete: function() { ripple.destroy(); } });
|
2010-05-06 21:18:10 +00:00
|
|
|
Main.uiGroup.add_actor(ripple);
|
2010-01-14 02:48:12 +00:00
|
|
|
},
|
|
|
|
|
2009-08-18 18:59:53 +00:00
|
|
|
_onHotCornerEntered : function() {
|
2010-05-20 15:18:46 +00:00
|
|
|
if (this._menus.grabbed)
|
2010-05-05 14:03:48 +00:00
|
|
|
return false;
|
2009-08-18 18:59:53 +00:00
|
|
|
if (!this._hotCornerEntered) {
|
|
|
|
this._hotCornerEntered = true;
|
|
|
|
if (!Main.overview.animationInProgress) {
|
2009-10-06 20:55:29 +00:00
|
|
|
this._hotCornerActivationTime = Date.now() / 1000;
|
2010-01-14 02:48:12 +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 opacity
|
|
|
|
this._addRipple(0.0, 0.83, 0.25, 1.0, 1.5, 0.0);
|
|
|
|
this._addRipple(0.05, 1.0, 0.0, 0.7, 1.25, 0.0);
|
|
|
|
this._addRipple(0.35, 1.0, 0.0, 0.3, 1, 0.0);
|
2009-08-18 18:59:53 +00:00
|
|
|
Main.overview.toggle();
|
|
|
|
}
|
2009-08-07 22:22:05 +00:00
|
|
|
}
|
2009-08-07 20:45:35 +00:00
|
|
|
return false;
|
2009-08-18 18:59:53 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_onHotCornerClicked : function() {
|
2010-05-20 15:18:46 +00:00
|
|
|
if (this._menus.grabbed)
|
2010-05-05 14:03:48 +00:00
|
|
|
return false;
|
2009-08-18 18:59:53 +00:00
|
|
|
if (!Main.overview.animationInProgress) {
|
2009-10-06 20:55:29 +00:00
|
|
|
this._maybeToggleOverviewOnClick();
|
2009-08-18 18:59:53 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
|
|
|
_onHotCornerLeft : function(actor, event) {
|
2009-09-08 20:58:57 +00:00
|
|
|
if (event.get_related() != this._hotCornerEnvirons) {
|
2009-08-18 18:59:53 +00:00
|
|
|
this._hotCornerEntered = false;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
|
|
|
_onHotCornerEnvironsLeft : function(actor, event) {
|
2009-09-08 20:58:57 +00:00
|
|
|
if (event.get_related() != this._hotCorner) {
|
2009-08-18 18:59:53 +00:00
|
|
|
this._hotCornerEntered = false;
|
|
|
|
}
|
|
|
|
return false;
|
2009-10-06 20:55:29 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
// Toggles the overview unless this is the first click on the Activities button within the HOT_CORNER_ACTIVATION_TIMEOUT time
|
|
|
|
// of the hot corner being triggered. This check avoids opening and closing the overview if the user both triggered the hot corner
|
|
|
|
// and clicked the Activities button.
|
|
|
|
_maybeToggleOverviewOnClick: function() {
|
|
|
|
if (this._hotCornerActivationTime == 0 || Date.now() / 1000 - this._hotCornerActivationTime > HOT_CORNER_ACTIVATION_TIMEOUT)
|
|
|
|
Main.overview.toggle();
|
|
|
|
this._hotCornerActivationTime = 0;
|
2009-08-18 18:59:53 +00:00
|
|
|
}
|
2008-10-31 18:09:20 +00:00
|
|
|
};
|
2009-09-30 14:02:08 +00:00
|
|
|
|
|
|
|
function CalendarPopup() {
|
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
|
|
|
CalendarPopup.prototype = {
|
|
|
|
_init: function() {
|
|
|
|
let panelActor = Main.panel.actor;
|
|
|
|
|
2010-05-08 16:16:54 +00:00
|
|
|
this.actor = new St.Bin({ name: 'calendarPopup' });
|
2009-09-30 14:02:08 +00:00
|
|
|
|
|
|
|
this.calendar = new Calendar.Calendar();
|
2010-05-08 16:16:54 +00:00
|
|
|
this.actor.set_child(this.calendar.actor);
|
2009-09-30 14:02:08 +00:00
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
this.isOpen = false;
|
|
|
|
|
2009-11-11 18:11:34 +00:00
|
|
|
Main.chrome.addActor(this.actor, { visibleInOverview: true,
|
|
|
|
affectsStruts: false });
|
2009-09-30 14:02:08 +00:00
|
|
|
this.actor.y = (panelActor.y + panelActor.height - this.actor.height);
|
2010-05-27 07:31:46 +00:00
|
|
|
this.calendar.actor.connect('notify::width', Lang.bind(this, this._centerPopup));
|
2009-09-30 14:02:08 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
show: function() {
|
|
|
|
let panelActor = Main.panel.actor;
|
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
if (this.isOpen)
|
|
|
|
return;
|
|
|
|
this.isOpen = true;
|
|
|
|
|
2009-09-30 14:02:08 +00:00
|
|
|
// Reset the calendar to today's date
|
|
|
|
this.calendar.setDate(new Date());
|
|
|
|
|
2010-05-27 07:31:46 +00:00
|
|
|
this._centerPopup();
|
2009-09-30 14:02:08 +00:00
|
|
|
this.actor.lower(panelActor);
|
|
|
|
this.actor.show();
|
|
|
|
Tweener.addTween(this.actor,
|
|
|
|
{ y: panelActor.y + panelActor.height,
|
|
|
|
time: 0.2,
|
2010-05-13 19:46:04 +00:00
|
|
|
transition: 'easeOutQuad'
|
2009-09-30 14:02:08 +00:00
|
|
|
});
|
|
|
|
},
|
|
|
|
|
|
|
|
hide: function() {
|
|
|
|
let panelActor = Main.panel.actor;
|
|
|
|
|
2010-05-20 15:18:46 +00:00
|
|
|
if (!this.isOpen)
|
|
|
|
return;
|
|
|
|
this.isOpen = false;
|
|
|
|
|
2009-09-30 14:02:08 +00:00
|
|
|
Tweener.addTween(this.actor,
|
|
|
|
{ y: panelActor.y + panelActor.height - this.actor.height,
|
|
|
|
time: 0.2,
|
2010-05-13 19:46:04 +00:00
|
|
|
transition: 'easeOutQuad',
|
2009-09-30 14:02:08 +00:00
|
|
|
onComplete: function() { this.actor.hide(); },
|
|
|
|
onCompleteScope: this
|
|
|
|
});
|
2010-05-27 07:31:46 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_centerPopup: function() {
|
|
|
|
let panelActor = Main.panel.actor;
|
|
|
|
this.actor.x = Math.round(panelActor.x + (panelActor.width - this.actor.width) / 2);
|
2009-09-30 14:02:08 +00:00
|
|
|
}
|
|
|
|
};
|