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
|
|
|
|
2009-02-02 23:02:16 +00:00
|
|
|
const Big = imports.gi.Big;
|
2008-10-31 18:09:20 +00:00
|
|
|
const Clutter = imports.gi.Clutter;
|
2009-05-13 15:54:09 +00:00
|
|
|
const Gtk = imports.gi.Gtk;
|
2009-05-07 13:54:21 +00:00
|
|
|
const Lang = imports.lang;
|
2008-11-21 13:54:25 +00:00
|
|
|
const Mainloop = imports.mainloop;
|
2008-11-19 23:04:53 +00:00
|
|
|
const Meta = imports.gi.Meta;
|
|
|
|
const Shell = imports.gi.Shell;
|
2009-09-30 14:02:08 +00:00
|
|
|
const St = imports.gi.St;
|
2009-07-02 04:52:21 +00:00
|
|
|
const Tweener = imports.ui.tweener;
|
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
|
|
|
|
2008-11-19 23:04:53 +00:00
|
|
|
const Button = imports.ui.button;
|
2009-09-30 14:02:08 +00:00
|
|
|
const Calendar = imports.ui.calendar;
|
2008-11-09 18:01:59 +00:00
|
|
|
const Main = imports.ui.main;
|
2008-10-31 23:09:46 +00:00
|
|
|
|
2009-07-13 16:49:06 +00:00
|
|
|
const PANEL_HEIGHT = 26;
|
2009-06-04 02:24:59 +00:00
|
|
|
const TRAY_HEIGHT = PANEL_HEIGHT - 1;
|
2009-07-13 16:49:06 +00:00
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
const DEFAULT_PADDING = 4;
|
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
const PANEL_ICON_SIZE = 24;
|
|
|
|
|
2009-08-09 23:48:54 +00:00
|
|
|
const BACKGROUND_TOP = new Clutter.Color();
|
2009-08-28 15:47:19 +00:00
|
|
|
BACKGROUND_TOP.from_pixel(0x161616ff);
|
2009-08-09 23:48:54 +00:00
|
|
|
const BACKGROUND_BOTTOM = new Clutter.Color();
|
|
|
|
BACKGROUND_BOTTOM.from_pixel(0x000000ff);
|
|
|
|
|
2009-07-13 16:49:06 +00:00
|
|
|
const PANEL_FOREGROUND_COLOR = new Clutter.Color();
|
|
|
|
PANEL_FOREGROUND_COLOR.from_pixel(0xffffffff);
|
2009-08-11 15:32:58 +00:00
|
|
|
const SN_BACKGROUND_COLOR = new Clutter.Color();
|
|
|
|
SN_BACKGROUND_COLOR.from_pixel(0xffff00a0);
|
2009-07-13 16:49:06 +00:00
|
|
|
|
2009-03-24 18:25:07 +00:00
|
|
|
const TRANSPARENT_COLOR = new Clutter.Color();
|
|
|
|
TRANSPARENT_COLOR.from_pixel(0x00000000);
|
|
|
|
|
2009-07-13 16:49:06 +00:00
|
|
|
// Don't make the mouse hover effect visible to the user for a menu feel.
|
2009-02-04 18:45:38 +00:00
|
|
|
const PANEL_BUTTON_COLOR = new Clutter.Color();
|
2009-07-13 16:49:06 +00:00
|
|
|
PANEL_BUTTON_COLOR.from_pixel(0x00000000);
|
|
|
|
|
|
|
|
// Lighten pressed buttons; darkening has no effect on a black background.
|
2008-11-15 00:44:11 +00:00
|
|
|
const PRESSED_BUTTON_BACKGROUND_COLOR = new Clutter.Color();
|
2009-07-13 16:49:06 +00:00
|
|
|
PRESSED_BUTTON_BACKGROUND_COLOR.from_pixel(0x324c6ffa);
|
|
|
|
|
|
|
|
const DEFAULT_FONT = 'Sans 16px';
|
2009-03-24 18:25:07 +00:00
|
|
|
|
2009-06-04 02:24:59 +00:00
|
|
|
const TRAY_PADDING = 0;
|
2009-08-02 02:11:37 +00:00
|
|
|
// See comments around _recomputeTraySize
|
2009-07-13 16:49:06 +00:00
|
|
|
const TRAY_SPACING = 14;
|
2009-08-02 02:11:37 +00:00
|
|
|
const TRAY_SPACING_MIN = 8;
|
2009-05-13 15:54:09 +00:00
|
|
|
|
|
|
|
// Used for the tray icon container with gtk pre-2.16, which doesn't
|
|
|
|
// fully support tray icon transparency
|
2009-03-24 18:25:07 +00:00
|
|
|
const TRAY_BACKGROUND_COLOR = new Clutter.Color();
|
2009-10-02 19:36:46 +00:00
|
|
|
TRAY_BACKGROUND_COLOR.from_pixel(0x0b0b0bff);
|
2009-03-24 18:25:07 +00:00
|
|
|
const TRAY_BORDER_COLOR = new Clutter.Color();
|
|
|
|
TRAY_BORDER_COLOR.from_pixel(0x00000033);
|
|
|
|
const TRAY_CORNER_RADIUS = 5;
|
2009-06-04 02:24:59 +00:00
|
|
|
const TRAY_BORDER_WIDTH = 0;
|
2008-10-31 18:09:20 +00:00
|
|
|
|
2009-10-06 20:55:29 +00:00
|
|
|
const HOT_CORNER_ACTIVATION_TIMEOUT = 0.5;
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2009-10-15 13:44:09 +00:00
|
|
|
const STANDARD_TRAY_ICON_ORDER = ['keyboard', 'volume', 'bluetooth', 'network', 'battery']
|
|
|
|
const STANDARD_TRAY_ICON_IMPLEMENTATIONS = {
|
|
|
|
'bluetooth-applet': 'bluetooth',
|
|
|
|
'gnome-volume-control-applet': 'volume',
|
|
|
|
'nm-applet': 'network',
|
|
|
|
'gnome-power-manager': 'battery'
|
|
|
|
};
|
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
function AppPanelMenu() {
|
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
|
|
|
AppPanelMenu.prototype = {
|
|
|
|
_init: function() {
|
2009-09-11 21:23:23 +00:00
|
|
|
this._metaDisplay = global.screen.get_display();
|
2009-08-11 15:32:58 +00:00
|
|
|
|
|
|
|
this._focusedApp = null;
|
|
|
|
this._activeSequence = null;
|
|
|
|
this._startupSequences = {};
|
|
|
|
|
|
|
|
this.actor = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
|
|
spacing: DEFAULT_PADDING,
|
|
|
|
y_align: Big.BoxAlignment.CENTER });
|
|
|
|
this._iconBox = new Big.Box({ width: PANEL_ICON_SIZE, height: PANEL_ICON_SIZE,
|
|
|
|
x_align: Big.BoxAlignment.CENTER,
|
|
|
|
y_align: Big.BoxAlignment.CENTER });
|
|
|
|
this.actor.append(this._iconBox, Big.BoxPackFlags.NONE);
|
|
|
|
let labelBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
|
|
|
|
y_align: Big.BoxAlignment.CENTER });
|
|
|
|
this._label = new Clutter.Text({ font_name: DEFAULT_FONT,
|
|
|
|
color: PANEL_FOREGROUND_COLOR,
|
|
|
|
text: "" });
|
|
|
|
labelBox.append(this._label, Big.BoxPackFlags.EXPAND);
|
|
|
|
this.actor.append(labelBox, Big.BoxPackFlags.NONE);
|
|
|
|
|
|
|
|
this._startupBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
2009-08-09 23:48:54 +00:00
|
|
|
y_align: Big.BoxAlignment.CENTER });
|
2009-08-11 15:32:58 +00:00
|
|
|
this.actor.append(this._startupBox, Big.BoxPackFlags.NONE);
|
|
|
|
|
|
|
|
Main.overview.connect('hiding', Lang.bind(this, function () {
|
|
|
|
this.actor.opacity = 255;
|
|
|
|
}));
|
|
|
|
Main.overview.connect('showing', Lang.bind(this, function () {
|
|
|
|
this.actor.opacity = 192;
|
|
|
|
}));
|
|
|
|
|
2009-08-27 06:22:25 +00:00
|
|
|
this._metaDisplay.connect('notify::focus-window', Lang.bind(this, this._sync));
|
|
|
|
|
|
|
|
let appMonitor = Shell.AppMonitor.get_default();
|
|
|
|
appMonitor.connect('startup-sequence-changed', Lang.bind(this, this._sync));
|
|
|
|
// For now just resync on application add/remove; this is mainly to handle
|
|
|
|
// cases where the focused window's application changes without the focus
|
|
|
|
// changing. An example case is how we map Firefox based on the window
|
|
|
|
// title which is a dynamic property.
|
|
|
|
appMonitor.connect('app-added', Lang.bind(this, this._sync));
|
|
|
|
appMonitor.connect('app-removed', Lang.bind(this, this._sync));
|
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
this._sync();
|
|
|
|
},
|
|
|
|
|
|
|
|
_sync: function() {
|
|
|
|
let appMonitor = Shell.AppMonitor.get_default();
|
|
|
|
|
|
|
|
let focusWindow = this._metaDisplay.get_focus_window();
|
|
|
|
let focusedApp;
|
|
|
|
if (focusWindow == null) {
|
|
|
|
focusedApp = null;
|
|
|
|
} else {
|
|
|
|
focusedApp = appMonitor.get_window_app(focusWindow);
|
|
|
|
}
|
|
|
|
|
|
|
|
let lastSequence = null;
|
|
|
|
if (focusedApp == null) {
|
|
|
|
let sequences = appMonitor.get_startup_sequences();
|
|
|
|
if (sequences.length > 0)
|
|
|
|
lastSequence = sequences[sequences.length - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the currently focused app hasn't changed and the current
|
|
|
|
// startup sequence hasn't changed, we have nothing to do
|
|
|
|
if (focusedApp == this._focusedApp
|
|
|
|
&& ((lastSequence == null && this._activeSequence == null)
|
|
|
|
|| (lastSequence != null && this._activeSequence != null
|
|
|
|
&& lastSequence.get_id() == this._activeSequence.get_id())))
|
|
|
|
return;
|
|
|
|
|
|
|
|
this._focusedApp = focusedApp;
|
|
|
|
this._activeSequence = lastSequence;
|
|
|
|
|
|
|
|
this._iconBox.remove_all();
|
|
|
|
this._iconBox.hide();
|
|
|
|
this._label.text = '';
|
|
|
|
if (this._focusedApp != null) {
|
Create ShellApp, rebase things on it
Previously, we had ShellAppInfo, which contains fundamental
information about an application, and methods on ShellAppMonitor
to retrieve "live" information like the window list.
AppIcon ended up being used as the "App" class which was painful
for various reasons; among them that we need to handle window
list changes, and some consumers weren't ready for that.
Clean things up a bit by introducing a new ShellApp class in C,
which currently wraps a ShellAppInfo.
AppIcon then is more like the display actor for a ShellApp. Notably,
the ".windows" property moves out of it. The altTab code which
won't handle dynamic changes instead is changed to maintain a
cached version.
ShellAppMonitor gains some more methods related to ShellApp now.
In the future, we might consider changing ShellApp to be a GInterface,
which could be implemented by ShellDesktopFileApp, ShellWindowApp.
Then we could axe ShellAppInfo from the "public" API and it would
return to being an internal loss mitigation layer for GMenu.
https://bugzilla.gnome.org/show_bug.cgi?id=598227
2009-10-11 20:40:00 +00:00
|
|
|
let info = focusedApp.get_info();
|
|
|
|
let icon = info.create_icon_texture(PANEL_ICON_SIZE);
|
2009-08-11 15:32:58 +00:00
|
|
|
this._iconBox.append(icon, Big.BoxPackFlags.NONE);
|
|
|
|
this._iconBox.show();
|
Create ShellApp, rebase things on it
Previously, we had ShellAppInfo, which contains fundamental
information about an application, and methods on ShellAppMonitor
to retrieve "live" information like the window list.
AppIcon ended up being used as the "App" class which was painful
for various reasons; among them that we need to handle window
list changes, and some consumers weren't ready for that.
Clean things up a bit by introducing a new ShellApp class in C,
which currently wraps a ShellAppInfo.
AppIcon then is more like the display actor for a ShellApp. Notably,
the ".windows" property moves out of it. The altTab code which
won't handle dynamic changes instead is changed to maintain a
cached version.
ShellAppMonitor gains some more methods related to ShellApp now.
In the future, we might consider changing ShellApp to be a GInterface,
which could be implemented by ShellDesktopFileApp, ShellWindowApp.
Then we could axe ShellAppInfo from the "public" API and it would
return to being an internal loss mitigation layer for GMenu.
https://bugzilla.gnome.org/show_bug.cgi?id=598227
2009-10-11 20:40:00 +00:00
|
|
|
this._label.text = info.get_name();
|
2009-08-11 15:32:58 +00:00
|
|
|
} else if (this._activeSequence != null) {
|
|
|
|
let icon = this._activeSequence.create_icon(PANEL_ICON_SIZE);
|
|
|
|
this._iconBox.append(icon, Big.BoxPackFlags.NONE);
|
|
|
|
this._iconBox.show();
|
|
|
|
this._label.text = this._activeSequence.get_name();
|
|
|
|
}
|
|
|
|
|
|
|
|
this.emit('changed');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Signals.addSignalMethods(AppPanelMenu.prototype);
|
|
|
|
|
2008-10-31 18:09:20 +00:00
|
|
|
function Panel() {
|
|
|
|
this._init();
|
|
|
|
}
|
|
|
|
|
|
|
|
Panel.prototype = {
|
2008-12-01 19:51:43 +00:00
|
|
|
_init : function() {
|
2009-08-09 23:48:54 +00:00
|
|
|
|
|
|
|
this.actor = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL
|
2009-08-11 15:16:25 +00:00
|
|
|
});
|
2009-08-09 23:48:54 +00:00
|
|
|
let backgroundGradient = Shell.create_vertical_gradient(BACKGROUND_TOP,
|
|
|
|
BACKGROUND_BOTTOM);
|
|
|
|
this.actor.connect('notify::allocation', Lang.bind(this, function () {
|
|
|
|
let [width, height] = this.actor.get_size();
|
|
|
|
backgroundGradient.set_size(width, height);
|
|
|
|
}));
|
|
|
|
this.actor.add_actor(backgroundGradient);
|
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
this._leftBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
|
|
y_align: Big.BoxAlignment.CENTER,
|
2009-08-11 15:32:58 +00:00
|
|
|
spacing: DEFAULT_PADDING,
|
2009-08-11 15:16:25 +00:00
|
|
|
padding_right: DEFAULT_PADDING });
|
|
|
|
this._centerBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
|
|
y_align: Big.BoxAlignment.CENTER });
|
|
|
|
this._rightBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
|
|
y_align: Big.BoxAlignment.CENTER,
|
|
|
|
padding_left: DEFAULT_PADDING });
|
|
|
|
|
|
|
|
/* 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();
|
|
|
|
this.actor.append(this._boxContainer, Big.BoxPackFlags.EXPAND);
|
|
|
|
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);
|
|
|
|
let leftWidth, centerWidth, rightWidth;
|
|
|
|
if (allocWidth < (leftNaturalWidth + centerNaturalWidth + rightNaturalWidth)) {
|
|
|
|
leftWidth = leftMinWidth;
|
|
|
|
centerWidth = centerMinWidth;
|
|
|
|
rightWidth = rightMinWidth;
|
|
|
|
} else {
|
|
|
|
leftWidth = leftNaturalWidth;
|
|
|
|
centerWidth = centerNaturalWidth;
|
|
|
|
rightWidth = rightNaturalWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
let x;
|
|
|
|
let childBox = new Clutter.ActorBox();
|
|
|
|
childBox.x1 = box.x1;
|
|
|
|
childBox.y1 = box.y1;
|
|
|
|
childBox.x2 = x = childBox.x1 + leftWidth;
|
|
|
|
childBox.y2 = box.y2;
|
|
|
|
this._leftBox.allocate(childBox, flags);
|
|
|
|
|
|
|
|
let centerNaturalX = Math.floor((box.x2 - box.x1) / 2 - (centerWidth / 2));
|
|
|
|
/* Check left side */
|
|
|
|
if (x < centerNaturalX) {
|
|
|
|
/* We didn't overflow the left, use the natural. */
|
|
|
|
x = centerNaturalX;
|
|
|
|
}
|
|
|
|
/* Check right side */
|
|
|
|
if (x + centerWidth > (box.x2 - rightWidth)) {
|
|
|
|
x = box.x2 - rightWidth - centerWidth;
|
|
|
|
}
|
|
|
|
childBox = new Clutter.ActorBox();
|
|
|
|
childBox.x1 = x;
|
|
|
|
childBox.y1 = box.y1;
|
|
|
|
childBox.x2 = x = childBox.x1 + centerWidth;
|
|
|
|
childBox.y2 = box.y2;
|
|
|
|
this._centerBox.allocate(childBox, flags);
|
|
|
|
|
|
|
|
childBox = new Clutter.ActorBox();
|
|
|
|
childBox.x1 = box.x2 - rightWidth;
|
|
|
|
childBox.y1 = box.y1;
|
|
|
|
childBox.x2 = box.x2;
|
|
|
|
childBox.y2 = box.y2;
|
|
|
|
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-08-14 13:30:48 +00:00
|
|
|
this.button = new Button.Button(_("Activities"), PANEL_BUTTON_COLOR, PRESSED_BUTTON_BACKGROUND_COLOR,
|
2009-08-29 11:23:28 +00:00
|
|
|
PANEL_FOREGROUND_COLOR, DEFAULT_FONT);
|
|
|
|
this.button.actor.height = PANEL_HEIGHT;
|
2009-08-11 15:16:25 +00:00
|
|
|
|
2009-08-29 11:23:28 +00:00
|
|
|
this._leftBox.append(this.button.actor, Big.BoxPackFlags.NONE);
|
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;
|
|
|
|
|
|
|
|
this._hotCornerEnvirons = new Clutter.Rectangle({ width: 3,
|
|
|
|
height: 3,
|
|
|
|
opacity: 0,
|
|
|
|
reactive: true });
|
|
|
|
|
2009-08-21 19:56:07 +00:00
|
|
|
this._hotCorner = new Clutter.Rectangle({ width: 1,
|
|
|
|
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
|
|
|
|
// 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
|
|
|
|
2009-08-18 18:59:53 +00:00
|
|
|
this._leftBox.append(this._hotCornerEnvirons, Big.BoxPackFlags.FIXED);
|
2009-08-21 19:56:07 +00:00
|
|
|
this._leftBox.append(this._hotCorner, Big.BoxPackFlags.FIXED);
|
2009-08-07 20:45:35 +00:00
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
let appMenu = new AppPanelMenu();
|
|
|
|
this._leftBox.append(appMenu.actor, Big.BoxPackFlags.NONE);
|
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
/* center */
|
2009-02-04 18:45:38 +00:00
|
|
|
|
2009-09-30 14:02:08 +00:00
|
|
|
let clockButton = new St.Button({ style_class: "panel-button",
|
|
|
|
toggle_mode: true });
|
|
|
|
this._centerBox.append(clockButton, Big.BoxPackFlags.NONE);
|
|
|
|
clockButton.connect('clicked', Lang.bind(this, this._toggleCalendar));
|
|
|
|
|
2009-07-13 16:49:06 +00:00
|
|
|
this._clock = new Clutter.Text({ font_name: DEFAULT_FONT,
|
|
|
|
color: PANEL_FOREGROUND_COLOR,
|
2009-02-23 19:42:00 +00:00
|
|
|
text: "" });
|
2009-09-30 14:02:08 +00:00
|
|
|
clockButton.add_actor(this._clock);
|
|
|
|
|
|
|
|
this._calendarPopup = null;
|
2009-08-11 15:16:25 +00:00
|
|
|
|
|
|
|
/* right */
|
2008-12-01 19:51:43 +00:00
|
|
|
|
2009-03-24 18:25:07 +00:00
|
|
|
// The tray icons live in trayBox within trayContainer.
|
|
|
|
// The trayBox is hidden when there are no tray icons.
|
|
|
|
let trayContainer = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
|
2009-06-04 02:24:59 +00:00
|
|
|
y_align: Big.BoxAlignment.START });
|
2009-08-11 15:16:25 +00:00
|
|
|
this._rightBox.append(trayContainer, Big.BoxPackFlags.NONE);
|
2009-03-24 18:25:07 +00:00
|
|
|
let trayBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
|
|
|
|
height: TRAY_HEIGHT,
|
|
|
|
padding: TRAY_PADDING,
|
|
|
|
spacing: TRAY_SPACING });
|
2009-08-02 02:11:37 +00:00
|
|
|
this._trayBox = trayBox;
|
2009-05-13 15:54:09 +00:00
|
|
|
|
|
|
|
// gtk+ < 2.16 doesn't have fully-working icon transparency,
|
|
|
|
// so we want trayBox to be opaque in that case (the icons
|
|
|
|
// will at least pick up its background color).
|
|
|
|
if (Gtk.MAJOR_VERSION == 2 && Gtk.MINOR_VERSION < 16) {
|
|
|
|
trayBox.background_color = TRAY_BACKGROUND_COLOR;
|
|
|
|
trayBox.corner_radius = TRAY_CORNER_RADIUS;
|
|
|
|
trayBox.border = TRAY_BORDER_WIDTH;
|
|
|
|
trayBox.border_color = TRAY_BORDER_COLOR;
|
|
|
|
}
|
|
|
|
|
2009-03-24 18:25:07 +00:00
|
|
|
trayBox.hide();
|
|
|
|
trayContainer.append(trayBox, Big.BoxPackFlags.NONE);
|
|
|
|
|
|
|
|
this._traymanager = new Shell.TrayManager({ bg_color: TRAY_BACKGROUND_COLOR });
|
2009-10-15 13:44:09 +00:00
|
|
|
this._traymanager.connect('tray-icon-added', Lang.bind(this, this._onTrayIconAdded));
|
2008-12-01 19:51:43 +00:00
|
|
|
this._traymanager.connect('tray-icon-removed',
|
2009-08-02 02:11:37 +00:00
|
|
|
Lang.bind(this, function(o, icon) {
|
2009-03-24 18:25:07 +00:00
|
|
|
trayBox.remove_actor(icon);
|
|
|
|
|
|
|
|
if (trayBox.get_children().length == 0)
|
|
|
|
trayBox.hide();
|
2009-08-02 02:11:37 +00:00
|
|
|
this._recomputeTraySize();
|
|
|
|
}));
|
2008-12-01 19:51:43 +00:00
|
|
|
this._traymanager.manage_stage(global.stage);
|
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
let statusbox = new Big.Box();
|
|
|
|
let statusmenu = this._statusmenu = new Shell.StatusMenu();
|
|
|
|
statusmenu.get_icon().hide();
|
|
|
|
statusmenu.get_name().fontName = DEFAULT_FONT;
|
|
|
|
statusmenu.get_name().color = PANEL_FOREGROUND_COLOR;
|
|
|
|
statusbox.append(this._statusmenu, Big.BoxPackFlags.NONE);
|
|
|
|
let statusbutton = new Button.Button(statusbox,
|
|
|
|
PANEL_BUTTON_COLOR,
|
|
|
|
PRESSED_BUTTON_BACKGROUND_COLOR,
|
2009-08-29 11:23:28 +00:00
|
|
|
PANEL_FOREGROUND_COLOR);
|
|
|
|
statusbutton.actor.height = PANEL_HEIGHT;
|
|
|
|
statusbutton.actor.connect('button-press-event', function (b, e) {
|
|
|
|
if (e.get_button() == 1 && e.get_click_count() == 1) {
|
|
|
|
statusmenu.toggle(e);
|
|
|
|
// The statusmenu might not pop up if it couldn't get a pointer grab
|
|
|
|
if (statusmenu.is_active())
|
|
|
|
statusbutton.actor.active = true;
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
2009-08-28 15:27:39 +00:00
|
|
|
});
|
2009-08-29 11:23:28 +00:00
|
|
|
this._rightBox.append(statusbutton.actor, Big.BoxPackFlags.NONE);
|
2009-08-11 15:16:25 +00:00
|
|
|
// We get a deactivated event when the popup disappears
|
|
|
|
this._statusmenu.connect('deactivated', function (sm) {
|
2009-08-29 11:23:28 +00:00
|
|
|
statusbutton.actor.active = false;
|
2009-08-11 15:16:25 +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-10-06 20:55:29 +00:00
|
|
|
this.button.actor.connect('button-press-event', Lang.bind(this, function(b, e) {
|
|
|
|
if (e.get_button() == 1 && e.get_click_count() == 1 && !Main.overview.animationInProgress) {
|
|
|
|
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() {
|
|
|
|
this.button.actor.active = true;
|
|
|
|
}));
|
|
|
|
Main.overview.connect('hiding', Lang.bind(this, function() {
|
|
|
|
this.button.actor.active = false;
|
|
|
|
}));
|
2008-11-28 20:12:20 +00:00
|
|
|
|
2009-08-11 15:16:25 +00:00
|
|
|
Main.chrome.addActor(this.actor);
|
2009-08-11 11:46:10 +00:00
|
|
|
Main.chrome.setVisibleInOverview(this.actor, true);
|
2008-12-01 19:51:43 +00:00
|
|
|
|
2008-12-01 19:59:59 +00:00
|
|
|
// Start the clock
|
2008-12-01 19:51:43 +00:00
|
|
|
this._updateClock();
|
|
|
|
},
|
|
|
|
|
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,
|
|
|
|
transition: "easeOutQuad"
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2009-10-15 13:44:09 +00:00
|
|
|
_onTrayIconAdded: function(o, icon, wmClass) {
|
|
|
|
let role = STANDARD_TRAY_ICON_IMPLEMENTATIONS[wmClass];
|
|
|
|
if (!role) {
|
|
|
|
// Unknown icons go first in undefined order
|
|
|
|
this._trayBox.prepend(icon, Big.BoxPackFlags.NONE);
|
|
|
|
} else {
|
|
|
|
icon._role = role;
|
|
|
|
// 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_after(icon, children[i], Big.BoxPackFlags.NONE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i == -1) {
|
|
|
|
// If we didn't find a position, we must be first
|
|
|
|
this._trayBox.prepend(icon, Big.BoxPackFlags.NONE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure the trayBox is shown.
|
|
|
|
this._trayBox.show();
|
|
|
|
this._recomputeTraySize();
|
|
|
|
},
|
|
|
|
|
2009-08-02 02:11:37 +00:00
|
|
|
// By default, tray icons have a spacing of TRAY_SPACING. However this
|
|
|
|
// starts to fail if we have too many as can sadly happen; just jump down
|
|
|
|
// to a spacing of 8 if we're over 6.
|
|
|
|
// http://bugzilla.gnome.org/show_bug.cgi?id=590495
|
|
|
|
_recomputeTraySize: function () {
|
|
|
|
if (this._trayBox.get_children().length > 6)
|
|
|
|
this._trayBox.spacing = TRAY_SPACING_MIN;
|
|
|
|
else
|
|
|
|
this._trayBox.spacing = TRAY_SPACING;
|
|
|
|
},
|
|
|
|
|
2008-12-01 19:51:43 +00:00
|
|
|
_updateClock: function() {
|
2009-05-02 22:33:13 +00:00
|
|
|
let displayDate = new Date();
|
|
|
|
let msecRemaining = 60000 - (1000 * displayDate.getSeconds() +
|
|
|
|
displayDate.getMilliseconds());
|
|
|
|
if (msecRemaining < 500) {
|
|
|
|
displayDate.setMinutes(displayDate.getMinutes() + 1);
|
|
|
|
msecRemaining += 60000;
|
2008-12-01 19:59:59 +00:00
|
|
|
}
|
2009-08-14 13:30:48 +00:00
|
|
|
/* Translators: This is a time format. */
|
|
|
|
this._clock.set_text(displayDate.toLocaleFormat(_("%a %l:%M %p")));
|
2009-05-07 13:54:21 +00:00
|
|
|
Mainloop.timeout_add(msecRemaining, Lang.bind(this, this._updateClock));
|
|
|
|
return false;
|
2009-08-07 20:45:35 +00:00
|
|
|
},
|
|
|
|
|
2009-09-30 14:02:08 +00:00
|
|
|
_toggleCalendar: function(clockButton) {
|
|
|
|
if (clockButton.checked) {
|
|
|
|
if (this._calendarPopup == null)
|
|
|
|
this._calendarPopup = new CalendarPopup();
|
|
|
|
this._calendarPopup.show();
|
|
|
|
} else {
|
|
|
|
this._calendarPopup.hide();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2009-08-18 18:59:53 +00:00
|
|
|
_onHotCornerEntered : function() {
|
|
|
|
if (!this._hotCornerEntered) {
|
|
|
|
this._hotCornerEntered = true;
|
|
|
|
if (!Main.overview.animationInProgress) {
|
2009-10-06 20:55:29 +00:00
|
|
|
this._hotCornerActivationTime = Date.now() / 1000;
|
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() {
|
|
|
|
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;
|
|
|
|
|
|
|
|
this.actor = new St.BoxLayout({ name: 'calendarPopup' });
|
|
|
|
|
|
|
|
this.calendar = new Calendar.Calendar();
|
|
|
|
this.actor.add(this.calendar.actor);
|
|
|
|
|
2009-10-01 20:14:50 +00:00
|
|
|
// Directly adding the actor to Main.chrome.actor is a hack to
|
|
|
|
// work around the fact that there is no way to add an actor that
|
|
|
|
// affects the input region but not the shape.
|
|
|
|
// See: https://bugzilla.gnome.org/show_bug.cgi?id=597044
|
2009-09-30 14:02:08 +00:00
|
|
|
Main.chrome.actor.add_actor(this.actor);
|
|
|
|
Main.chrome.addInputRegionActor(this.actor);
|
|
|
|
this.actor.y = (panelActor.y + panelActor.height - this.actor.height);
|
|
|
|
},
|
|
|
|
|
|
|
|
show: function() {
|
|
|
|
let panelActor = Main.panel.actor;
|
|
|
|
|
|
|
|
// Reset the calendar to today's date
|
|
|
|
this.calendar.setDate(new Date());
|
|
|
|
|
2009-10-07 18:52:18 +00:00
|
|
|
this.actor.x = Math.round(panelActor.x + (panelActor.width - this.actor.width) / 2);
|
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,
|
|
|
|
transition: "easeOutQuad"
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
|
|
|
hide: function() {
|
|
|
|
let panelActor = Main.panel.actor;
|
|
|
|
|
|
|
|
Tweener.addTween(this.actor,
|
|
|
|
{ y: panelActor.y + panelActor.height - this.actor.height,
|
|
|
|
time: 0.2,
|
|
|
|
transition: "easeOutQuad",
|
|
|
|
onComplete: function() { this.actor.hide(); },
|
|
|
|
onCompleteScope: this
|
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|