2011-09-28 13:16:26 +00:00
|
|
|
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
2010-01-13 20:05:20 +00:00
|
|
|
|
|
|
|
const Clutter = imports.gi.Clutter;
|
2010-11-23 23:27:47 +00:00
|
|
|
const GLib = imports.gi.GLib;
|
|
|
|
const Gio = imports.gi.Gio;
|
2015-02-25 16:43:54 +00:00
|
|
|
const GObject = imports.gi.GObject;
|
2010-02-22 19:23:36 +00:00
|
|
|
const Gtk = imports.gi.Gtk;
|
2012-02-20 19:27:27 +00:00
|
|
|
const Atk = imports.gi.Atk;
|
2010-01-13 20:05:20 +00:00
|
|
|
const Lang = imports.lang;
|
|
|
|
const Mainloop = imports.mainloop;
|
2010-09-09 20:18:07 +00:00
|
|
|
const Meta = imports.gi.Meta;
|
2010-02-01 17:10:38 +00:00
|
|
|
const Pango = imports.gi.Pango;
|
2010-01-28 17:04:26 +00:00
|
|
|
const Shell = imports.gi.Shell;
|
2010-01-13 20:05:20 +00:00
|
|
|
const Signals = imports.signals;
|
2010-01-28 17:04:26 +00:00
|
|
|
const St = imports.gi.St;
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2015-02-17 00:13:48 +00:00
|
|
|
const Calendar = imports.ui.calendar;
|
2011-02-19 15:49:56 +00:00
|
|
|
const GnomeSession = imports.misc.gnomeSession;
|
2015-02-25 16:43:54 +00:00
|
|
|
const Layout = imports.ui.layout;
|
2011-02-19 15:49:56 +00:00
|
|
|
const Main = imports.ui.main;
|
2010-08-18 20:01:33 +00:00
|
|
|
const Params = imports.misc.params;
|
2011-02-19 15:49:56 +00:00
|
|
|
const Tweener = imports.ui.tweener;
|
2010-11-30 16:16:10 +00:00
|
|
|
const Util = imports.misc.util;
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2012-07-14 11:07:24 +00:00
|
|
|
const SHELL_KEYBINDINGS_SCHEMA = 'org.gnome.shell.keybindings';
|
|
|
|
|
2010-01-13 20:05:20 +00:00
|
|
|
const ANIMATION_TIME = 0.2;
|
|
|
|
const NOTIFICATION_TIMEOUT = 4;
|
|
|
|
|
2010-02-25 19:42:18 +00:00
|
|
|
const HIDE_TIMEOUT = 0.2;
|
2010-08-31 19:50:18 +00:00
|
|
|
const LONGER_HIDE_TIMEOUT = 0.6;
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2015-02-14 02:18:52 +00:00
|
|
|
const MAX_NOTIFICATIONS_IN_QUEUE = 3;
|
2015-02-13 23:06:11 +00:00
|
|
|
const MAX_NOTIFICATIONS_PER_SOURCE = 3;
|
2015-02-17 02:53:00 +00:00
|
|
|
const MAX_NOTIFICATION_BUTTONS = 3;
|
2015-02-14 02:18:52 +00:00
|
|
|
|
2010-10-30 19:54:43 +00:00
|
|
|
// We delay hiding of the tray if the mouse is within MOUSE_LEFT_ACTOR_THRESHOLD
|
|
|
|
// range from the point where it left the tray.
|
|
|
|
const MOUSE_LEFT_ACTOR_THRESHOLD = 20;
|
|
|
|
|
2012-08-10 21:54:33 +00:00
|
|
|
const IDLE_TIME = 1000;
|
|
|
|
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
const State = {
|
|
|
|
HIDDEN: 0,
|
|
|
|
SHOWING: 1,
|
|
|
|
SHOWN: 2,
|
|
|
|
HIDING: 3
|
2010-01-28 18:39:00 +00:00
|
|
|
};
|
|
|
|
|
2011-01-27 23:26:53 +00:00
|
|
|
// These reasons are useful when we destroy the notifications received through
|
2015-02-13 23:06:11 +00:00
|
|
|
// the notification daemon. We use EXPIRED for notifications that we dismiss
|
|
|
|
// and the user did not interact with, DISMISSED for all other notifications
|
|
|
|
// that were destroyed as a result of a user action, and SOURCE_CLOSED for the
|
|
|
|
// notifications that were requested to be destroyed by the associated source.
|
2011-01-27 23:26:53 +00:00
|
|
|
const NotificationDestroyedReason = {
|
|
|
|
EXPIRED: 1,
|
|
|
|
DISMISSED: 2,
|
2011-01-28 18:31:16 +00:00
|
|
|
SOURCE_CLOSED: 3
|
2011-01-27 23:26:53 +00:00
|
|
|
};
|
|
|
|
|
2011-01-04 09:34:57 +00:00
|
|
|
// Message tray has its custom Urgency enumeration. LOW, NORMAL and CRITICAL
|
|
|
|
// urgency values map to the corresponding values for the notifications received
|
|
|
|
// through the notification daemon. HIGH urgency value is used for chats received
|
|
|
|
// through the Telepathy client.
|
|
|
|
const Urgency = {
|
|
|
|
LOW: 0,
|
|
|
|
NORMAL: 1,
|
|
|
|
HIGH: 2,
|
|
|
|
CRITICAL: 3
|
2013-12-04 16:22:25 +00:00
|
|
|
};
|
2011-01-04 09:34:57 +00:00
|
|
|
|
2010-11-23 23:31:55 +00:00
|
|
|
function _fixMarkup(text, allowMarkup) {
|
|
|
|
if (allowMarkup) {
|
|
|
|
// Support &, ", ', < and >, escape all other
|
|
|
|
// occurrences of '&'.
|
|
|
|
let _text = text.replace(/&(?!amp;|quot;|apos;|lt;|gt;)/g, '&');
|
2011-05-04 15:15:45 +00:00
|
|
|
|
2010-11-23 23:31:55 +00:00
|
|
|
// Support <b>, <i>, and <u>, escape anything else
|
|
|
|
// so it displays as raw markup.
|
2011-05-04 15:15:45 +00:00
|
|
|
_text = _text.replace(/<(?!\/?[biu]>)/g, '<');
|
|
|
|
|
|
|
|
try {
|
|
|
|
Pango.parse_markup(_text, -1, '');
|
|
|
|
return _text;
|
|
|
|
} catch (e) {}
|
2010-11-23 23:31:55 +00:00
|
|
|
}
|
2011-05-04 15:15:45 +00:00
|
|
|
|
|
|
|
// !allowMarkup, or invalid markup
|
|
|
|
return GLib.markup_escape_text(text, -1);
|
2010-02-01 20:23:49 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 21:11:40 +00:00
|
|
|
const FocusGrabber = new Lang.Class({
|
|
|
|
Name: 'FocusGrabber',
|
|
|
|
|
|
|
|
_init: function(actor) {
|
|
|
|
this._actor = actor;
|
|
|
|
this._prevKeyFocusActor = null;
|
|
|
|
this._focusActorChangedId = 0;
|
|
|
|
this._focused = false;
|
|
|
|
},
|
|
|
|
|
|
|
|
grabFocus: function() {
|
|
|
|
if (this._focused)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this._prevKeyFocusActor = global.stage.get_key_focus();
|
|
|
|
|
|
|
|
this._focusActorChangedId = global.stage.connect('notify::key-focus', Lang.bind(this, this._focusActorChanged));
|
|
|
|
|
|
|
|
if (!this._actor.navigate_focus(null, Gtk.DirectionType.TAB_FORWARD, false))
|
|
|
|
this._actor.grab_key_focus();
|
|
|
|
|
|
|
|
this._focused = true;
|
|
|
|
},
|
|
|
|
|
|
|
|
_focusUngrabbed: function() {
|
|
|
|
if (!this._focused)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (this._focusActorChangedId > 0) {
|
|
|
|
global.stage.disconnect(this._focusActorChangedId);
|
|
|
|
this._focusActorChangedId = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
this._focused = false;
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
_focusActorChanged: function() {
|
|
|
|
let focusedActor = global.stage.get_key_focus();
|
|
|
|
if (!focusedActor || !this._actor.contains(focusedActor))
|
|
|
|
this._focusUngrabbed();
|
|
|
|
},
|
|
|
|
|
|
|
|
ungrabFocus: function() {
|
|
|
|
if (!this._focusUngrabbed())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (this._prevKeyFocusActor) {
|
|
|
|
global.stage.set_key_focus(this._prevKeyFocusActor);
|
|
|
|
this._prevKeyFocusActor = null;
|
|
|
|
} else {
|
|
|
|
let focusedActor = global.stage.get_key_focus();
|
|
|
|
if (focusedActor && this._actor.contains(focusedActor))
|
|
|
|
global.stage.set_key_focus(null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2012-10-16 15:08:54 +00:00
|
|
|
// NotificationPolicy:
|
|
|
|
// An object that holds all bits of configurable policy related to a notification
|
|
|
|
// source, such as whether to play sound or honour the critical bit.
|
|
|
|
//
|
|
|
|
// A notification without a policy object will inherit the default one.
|
|
|
|
const NotificationPolicy = new Lang.Class({
|
|
|
|
Name: 'NotificationPolicy',
|
|
|
|
|
|
|
|
_init: function(params) {
|
|
|
|
params = Params.parse(params, { enable: true,
|
|
|
|
enableSound: true,
|
|
|
|
showBanners: true,
|
|
|
|
forceExpanded: false,
|
|
|
|
showInLockScreen: true,
|
|
|
|
detailsInLockScreen: false
|
|
|
|
});
|
|
|
|
Lang.copyProperties(params, this);
|
|
|
|
},
|
|
|
|
|
|
|
|
// Do nothing for the default policy. These methods are only useful for the
|
|
|
|
// GSettings policy.
|
|
|
|
store: function() { },
|
|
|
|
destroy: function() { }
|
|
|
|
});
|
|
|
|
Signals.addSignalMethods(NotificationPolicy.prototype);
|
|
|
|
|
2013-10-13 20:01:56 +00:00
|
|
|
const NotificationGenericPolicy = new Lang.Class({
|
|
|
|
Name: 'NotificationGenericPolicy',
|
|
|
|
Extends: NotificationPolicy,
|
|
|
|
|
|
|
|
_init: function() {
|
|
|
|
// Don't chain to parent, it would try setting
|
|
|
|
// our properties to the defaults
|
|
|
|
|
|
|
|
this.id = 'generic';
|
|
|
|
|
2014-06-24 19:17:09 +00:00
|
|
|
this._masterSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications' });
|
2013-10-13 20:01:56 +00:00
|
|
|
this._masterSettings.connect('changed', Lang.bind(this, this._changed));
|
|
|
|
},
|
|
|
|
|
|
|
|
store: function() { },
|
|
|
|
|
|
|
|
destroy: function() {
|
|
|
|
this._masterSettings.run_dispose();
|
|
|
|
},
|
|
|
|
|
|
|
|
_changed: function(settings, key) {
|
|
|
|
this.emit('policy-changed', key);
|
|
|
|
},
|
|
|
|
|
|
|
|
get enable() {
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
get enableSound() {
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
get showBanners() {
|
|
|
|
return this._masterSettings.get_boolean('show-banners');
|
|
|
|
},
|
|
|
|
|
|
|
|
get forceExpanded() {
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
|
|
|
get showInLockScreen() {
|
|
|
|
return this._masterSettings.get_boolean('show-in-lock-screen');
|
|
|
|
},
|
|
|
|
|
|
|
|
get detailsInLockScreen() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
const NotificationApplicationPolicy = new Lang.Class({
|
|
|
|
Name: 'NotificationApplicationPolicy',
|
|
|
|
Extends: NotificationPolicy,
|
|
|
|
|
|
|
|
_init: function(id) {
|
|
|
|
// Don't chain to parent, it would try setting
|
|
|
|
// our properties to the defaults
|
|
|
|
|
|
|
|
this.id = id;
|
|
|
|
this._canonicalId = this._canonicalizeId(id);
|
|
|
|
|
2014-06-24 19:17:09 +00:00
|
|
|
this._masterSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications' });
|
|
|
|
this._settings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications.application',
|
2013-10-13 20:01:56 +00:00
|
|
|
path: '/org/gnome/desktop/notifications/application/' + this._canonicalId + '/' });
|
|
|
|
|
|
|
|
this._masterSettings.connect('changed', Lang.bind(this, this._changed));
|
|
|
|
this._settings.connect('changed', Lang.bind(this, this._changed));
|
|
|
|
},
|
|
|
|
|
|
|
|
store: function() {
|
|
|
|
this._settings.set_string('application-id', this.id + '.desktop');
|
|
|
|
|
|
|
|
let apps = this._masterSettings.get_strv('application-children');
|
|
|
|
if (apps.indexOf(this._canonicalId) < 0) {
|
|
|
|
apps.push(this._canonicalId);
|
|
|
|
this._masterSettings.set_strv('application-children', apps);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
destroy: function() {
|
|
|
|
this._masterSettings.run_dispose();
|
|
|
|
this._settings.run_dispose();
|
|
|
|
},
|
|
|
|
|
|
|
|
_changed: function(settings, key) {
|
|
|
|
this.emit('policy-changed', key);
|
|
|
|
},
|
|
|
|
|
|
|
|
_canonicalizeId: function(id) {
|
|
|
|
// Keys are restricted to lowercase alphanumeric characters and dash,
|
|
|
|
// and two dashes cannot be in succession
|
|
|
|
return id.toLowerCase().replace(/[^a-z0-9\-]/g, '-').replace(/--+/g, '-');
|
|
|
|
},
|
|
|
|
|
|
|
|
get enable() {
|
|
|
|
return this._settings.get_boolean('enable');
|
|
|
|
},
|
|
|
|
|
|
|
|
get enableSound() {
|
|
|
|
return this._settings.get_boolean('enable-sound-alerts');
|
|
|
|
},
|
|
|
|
|
|
|
|
get showBanners() {
|
|
|
|
return this._masterSettings.get_boolean('show-banners') &&
|
|
|
|
this._settings.get_boolean('show-banners');
|
|
|
|
},
|
|
|
|
|
|
|
|
get forceExpanded() {
|
|
|
|
return this._settings.get_boolean('force-expanded');
|
|
|
|
},
|
|
|
|
|
|
|
|
get showInLockScreen() {
|
|
|
|
return this._masterSettings.get_boolean('show-in-lock-screen') &&
|
|
|
|
this._settings.get_boolean('show-in-lock-screen');
|
|
|
|
},
|
|
|
|
|
|
|
|
get detailsInLockScreen() {
|
|
|
|
return this._settings.get_boolean('details-in-lock-screen');
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2010-02-01 17:10:38 +00:00
|
|
|
// Notification:
|
|
|
|
// @source: the notification's Source
|
|
|
|
// @title: the title
|
|
|
|
// @banner: the banner text
|
2010-08-18 20:01:33 +00:00
|
|
|
// @params: optional additional params
|
2010-02-01 17:10:38 +00:00
|
|
|
//
|
2010-08-30 20:03:08 +00:00
|
|
|
// Creates a notification. In the banner mode, the notification
|
|
|
|
// will show an icon, @title (in bold) and @banner, all on a single
|
|
|
|
// line (with @banner ellipsized if necessary).
|
2010-02-09 16:25:10 +00:00
|
|
|
//
|
2010-08-30 20:03:08 +00:00
|
|
|
// The notification will be expandable if either it has additional
|
|
|
|
// elements that were added to it or if the @banner text did not
|
|
|
|
// fit fully in the banner mode. When the notification is expanded,
|
|
|
|
// the @banner text from the top line is always removed. The complete
|
|
|
|
// @banner text is added as the first element in the content section,
|
|
|
|
// unless 'customContent' parameter with the value 'true' is specified
|
|
|
|
// in @params.
|
2010-08-05 17:09:27 +00:00
|
|
|
//
|
2010-08-30 20:03:08 +00:00
|
|
|
// Additional notification content can be added with addActor() and
|
|
|
|
// addBody() methods. The notification content is put inside a
|
2010-02-22 19:23:36 +00:00
|
|
|
// scrollview, so if it gets too tall, the notification will scroll
|
2010-08-30 20:03:08 +00:00
|
|
|
// rather than continue to grow. In addition to this main content
|
|
|
|
// area, there is also a single-row action area, which is not
|
|
|
|
// scrolled and can contain a single actor. The action area can
|
|
|
|
// be set by calling setActionArea() method. There is also a
|
|
|
|
// convenience method addButton() for adding a button to the action
|
|
|
|
// area.
|
|
|
|
//
|
|
|
|
// If @params contains a 'customContent' parameter with the value %true,
|
|
|
|
// then @banner will not be shown in the body of the notification when the
|
|
|
|
// notification is expanded and calls to update() will not clear the content
|
|
|
|
// unless 'clear' parameter with value %true is explicitly specified.
|
|
|
|
//
|
2012-09-14 14:33:52 +00:00
|
|
|
// By default, the icon shown is the same as the source's.
|
|
|
|
// However, if @params contains a 'gicon' parameter, the passed in gicon
|
|
|
|
// will be used.
|
|
|
|
//
|
|
|
|
// You can add a secondary icon to the banner with 'secondaryGIcon'. There
|
|
|
|
// is no fallback for this icon.
|
2010-08-30 20:03:08 +00:00
|
|
|
//
|
2013-07-03 21:43:33 +00:00
|
|
|
// If @params contains 'bannerMarkup', with the value %true, then
|
|
|
|
// the corresponding element is assumed to use pango markup. If the
|
|
|
|
// parameter is not present for an element, then anything that looks
|
|
|
|
// like markup in that element will appear literally in the output.
|
2010-11-23 23:31:55 +00:00
|
|
|
//
|
2010-08-30 20:03:08 +00:00
|
|
|
// If @params contains a 'clear' parameter with the value %true, then
|
|
|
|
// the content and the action area of the notification will be cleared.
|
|
|
|
// The content area is also always cleared if 'customContent' is false
|
|
|
|
// because it might contain the @banner that didn't fit in the banner mode.
|
2012-11-05 17:10:24 +00:00
|
|
|
//
|
|
|
|
// If @params contains 'soundName' or 'soundFile', the corresponding
|
|
|
|
// event sound is played when the notification is shown (if the policy for
|
|
|
|
// @source allows playing sounds).
|
2011-11-20 15:12:02 +00:00
|
|
|
const Notification = new Lang.Class({
|
|
|
|
Name: 'Notification',
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2010-08-18 20:01:33 +00:00
|
|
|
_init: function(source, title, banner, params) {
|
2010-01-28 18:39:00 +00:00
|
|
|
this.source = source;
|
2011-09-21 20:46:08 +00:00
|
|
|
this.title = title;
|
2011-01-04 09:34:57 +00:00
|
|
|
this.urgency = Urgency.NORMAL;
|
2010-12-16 20:49:47 +00:00
|
|
|
this.resident = false;
|
2010-12-15 21:30:50 +00:00
|
|
|
// 'transient' is a reserved keyword in JS, so we have to use an alternate variable name
|
|
|
|
this.isTransient = false;
|
2012-11-02 17:06:40 +00:00
|
|
|
this.forFeedback = false;
|
2015-02-14 01:33:54 +00:00
|
|
|
this._acknowledged = false;
|
2013-01-30 18:47:55 +00:00
|
|
|
this.bannerBodyText = null;
|
|
|
|
this.bannerBodyMarkup = false;
|
2012-11-05 17:10:24 +00:00
|
|
|
this._soundName = null;
|
|
|
|
this._soundFile = null;
|
|
|
|
this._soundPlayed = false;
|
2015-02-19 12:45:31 +00:00
|
|
|
this.actions = [];
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2013-10-12 16:50:49 +00:00
|
|
|
// If called with only one argument we assume the caller
|
|
|
|
// will call .update() later on. This is the case of
|
|
|
|
// NotificationDaemon, which wants to use the same code
|
|
|
|
// for new and updated notifications
|
|
|
|
if (arguments.length != 1)
|
|
|
|
this.update(title, banner, params);
|
2010-02-09 16:25:10 +00:00
|
|
|
},
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2010-02-09 16:25:10 +00:00
|
|
|
// update:
|
|
|
|
// @title: the new title
|
|
|
|
// @banner: the new banner
|
2010-08-18 20:01:33 +00:00
|
|
|
// @params: as in the Notification constructor
|
2010-02-09 16:25:10 +00:00
|
|
|
//
|
|
|
|
// Updates the notification by regenerating its icon and updating
|
2010-08-18 20:01:33 +00:00
|
|
|
// the title/banner. If @params.clear is %true, it will also
|
|
|
|
// remove any additional actors/action buttons previously added.
|
|
|
|
update: function(title, banner, params) {
|
2015-02-11 19:20:03 +00:00
|
|
|
params = Params.parse(params, { gicon: null,
|
2012-09-14 14:33:52 +00:00
|
|
|
secondaryGIcon: null,
|
2010-11-23 23:31:55 +00:00
|
|
|
bannerMarkup: false,
|
2012-11-05 17:10:24 +00:00
|
|
|
clear: false,
|
|
|
|
soundName: null,
|
|
|
|
soundFile: null });
|
2010-08-18 20:01:33 +00:00
|
|
|
|
2011-09-21 20:46:08 +00:00
|
|
|
this.title = title;
|
2015-02-11 19:20:03 +00:00
|
|
|
this.bannerBodyText = banner;
|
2013-01-30 18:47:55 +00:00
|
|
|
this.bannerBodyMarkup = params.bannerMarkup;
|
2010-02-09 16:25:10 +00:00
|
|
|
|
2015-02-11 19:20:03 +00:00
|
|
|
if (params.gicon || params.clear)
|
|
|
|
this.gicon = params.gicon;
|
2010-11-23 23:27:47 +00:00
|
|
|
|
2015-02-11 19:20:03 +00:00
|
|
|
if (params.secondaryGIcon || params.clear)
|
|
|
|
this.secondaryGIcon = params.secondaryGIcon;
|
2010-04-29 14:54:05 +00:00
|
|
|
|
2015-02-11 19:20:03 +00:00
|
|
|
if (params.clear)
|
|
|
|
this.actions = [];
|
2010-08-30 20:03:08 +00:00
|
|
|
|
2012-11-05 17:10:24 +00:00
|
|
|
if (this._soundName != params.soundName ||
|
|
|
|
this._soundFile != params.soundFile) {
|
|
|
|
this._soundName = params.soundName;
|
|
|
|
this._soundFile = params.soundFile;
|
|
|
|
this._soundPlayed = false;
|
|
|
|
}
|
|
|
|
|
2015-02-19 18:23:14 +00:00
|
|
|
this.emit('updated', params.clear);
|
2010-02-09 16:25:10 +00:00
|
|
|
},
|
2010-02-01 17:10:38 +00:00
|
|
|
|
2013-10-14 03:08:16 +00:00
|
|
|
// addAction:
|
|
|
|
// @label: the label for the action's button
|
2013-10-14 03:06:09 +00:00
|
|
|
// @callback: the callback for the action
|
|
|
|
addAction: function(label, callback) {
|
2015-02-19 12:45:31 +00:00
|
|
|
this.actions.push({ label: label, callback: callback });
|
2012-05-17 19:05:36 +00:00
|
|
|
},
|
|
|
|
|
2015-02-14 01:33:54 +00:00
|
|
|
get acknowledged() {
|
|
|
|
return this._acknowledged;
|
|
|
|
},
|
|
|
|
|
|
|
|
set acknowledged(v) {
|
|
|
|
if (this._acknowledged == v)
|
|
|
|
return;
|
|
|
|
this._acknowledged = v;
|
|
|
|
this.emit('acknowledged-changed');
|
|
|
|
},
|
|
|
|
|
2011-01-04 09:34:57 +00:00
|
|
|
setUrgency: function(urgency) {
|
|
|
|
this.urgency = urgency;
|
2010-04-28 19:34:27 +00:00
|
|
|
},
|
|
|
|
|
2010-12-16 20:49:47 +00:00
|
|
|
setResident: function(resident) {
|
|
|
|
this.resident = resident;
|
|
|
|
},
|
|
|
|
|
2010-12-15 21:30:50 +00:00
|
|
|
setTransient: function(isTransient) {
|
|
|
|
this.isTransient = isTransient;
|
|
|
|
},
|
|
|
|
|
2012-11-02 17:06:40 +00:00
|
|
|
setForFeedback: function(forFeedback) {
|
|
|
|
this.forFeedback = forFeedback;
|
|
|
|
},
|
|
|
|
|
2012-11-05 17:10:24 +00:00
|
|
|
playSound: function() {
|
|
|
|
if (this._soundPlayed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!this.source.policy.enableSound) {
|
|
|
|
this._soundPlayed = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this._soundName) {
|
|
|
|
if (this.source.app) {
|
|
|
|
let app = this.source.app;
|
|
|
|
|
|
|
|
global.play_theme_sound_full(0, this._soundName,
|
|
|
|
this.title, null,
|
|
|
|
app.get_id(), app.get_name());
|
|
|
|
} else {
|
|
|
|
global.play_theme_sound(0, this._soundName, this.title, null);
|
|
|
|
}
|
|
|
|
} else if (this._soundFile) {
|
|
|
|
if (this.source.app) {
|
|
|
|
let app = this.source.app;
|
|
|
|
|
|
|
|
global.play_sound_file_full(0, this._soundFile,
|
|
|
|
this.title, null,
|
|
|
|
app.get_id(), app.get_name());
|
|
|
|
} else {
|
|
|
|
global.play_sound_file(0, this._soundFile, this.title, null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2015-02-17 02:27:11 +00:00
|
|
|
// Allow customizing the banner UI:
|
|
|
|
// the default implementation defers the creation to
|
|
|
|
// the source (which will create a NotificationBanner),
|
|
|
|
// so customization can be done by subclassing either
|
|
|
|
// Notification or Source
|
|
|
|
createBanner: function() {
|
|
|
|
return this.source.createBanner(this);
|
|
|
|
},
|
|
|
|
|
2015-02-18 23:00:25 +00:00
|
|
|
activate: function() {
|
|
|
|
this.emit('activated');
|
2010-12-16 20:49:47 +00:00
|
|
|
if (!this.resident)
|
|
|
|
this.destroy();
|
|
|
|
},
|
|
|
|
|
2011-03-03 00:47:58 +00:00
|
|
|
destroy: function(reason) {
|
2015-02-11 19:20:03 +00:00
|
|
|
if (!reason)
|
|
|
|
reason = NotificationDestroyedReason.DISMISSED;
|
|
|
|
this.emit('destroy', reason);
|
2010-01-13 20:05:20 +00:00
|
|
|
}
|
2011-11-20 15:12:02 +00:00
|
|
|
});
|
2010-02-01 20:41:22 +00:00
|
|
|
Signals.addSignalMethods(Notification.prototype);
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2015-02-17 00:13:48 +00:00
|
|
|
const NotificationBanner = new Lang.Class({
|
|
|
|
Name: 'NotificationBanner',
|
|
|
|
Extends: Calendar.NotificationMessage,
|
|
|
|
|
|
|
|
_init: function(notification) {
|
|
|
|
this.parent(notification);
|
|
|
|
|
|
|
|
this.actor.add_style_class_name('notification-banner');
|
|
|
|
|
|
|
|
this._buttonBox = null;
|
|
|
|
|
|
|
|
this._addActions();
|
|
|
|
this._addSecondaryIcon();
|
|
|
|
|
|
|
|
this._activatedId = this.notification.connect('activated',
|
|
|
|
Lang.bind(this, function() {
|
|
|
|
// We hide all types of notifications once the user clicks on
|
|
|
|
// them because the common outcome of clicking should be the
|
|
|
|
// relevant window being brought forward and the user's
|
|
|
|
// attention switching to the window.
|
|
|
|
this.emit('done-displaying');
|
|
|
|
}));
|
|
|
|
},
|
|
|
|
|
2015-03-17 04:31:02 +00:00
|
|
|
_onDestroy: function() {
|
|
|
|
this.parent();
|
2015-02-17 00:13:48 +00:00
|
|
|
this.notification.disconnect(this._activatedId);
|
|
|
|
},
|
|
|
|
|
|
|
|
_onUpdated: function(n, clear) {
|
|
|
|
this.parent(n, clear);
|
|
|
|
|
|
|
|
if (clear) {
|
|
|
|
this.setSecondaryActor(null);
|
|
|
|
this.setActionArea(null);
|
|
|
|
this._buttonBox = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
this._addActions();
|
|
|
|
this._addSecondaryIcon();
|
|
|
|
},
|
|
|
|
|
|
|
|
_addActions: function() {
|
|
|
|
this.notification.actions.forEach(Lang.bind(this,
|
|
|
|
function(action) {
|
|
|
|
this.addAction(action.label, action.callback);
|
|
|
|
}));
|
|
|
|
},
|
|
|
|
|
|
|
|
_addSecondaryIcon: function() {
|
|
|
|
if (this.notification.secondaryGIcon) {
|
|
|
|
let icon = new St.Icon({ gicon: this.notification.secondaryGIcon });
|
|
|
|
this.setSecondaryActor(icon);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
addButton: function(button, callback) {
|
|
|
|
if (!this._buttonBox) {
|
|
|
|
this._buttonBox = new St.BoxLayout({ style_class: 'notification-actions',
|
|
|
|
x_expand: true });
|
|
|
|
this.setActionArea(this._buttonBox);
|
|
|
|
global.focus_manager.add_group(this._buttonBox);
|
|
|
|
}
|
|
|
|
|
2015-02-17 02:53:00 +00:00
|
|
|
if (this._buttonBox.get_n_children() >= MAX_NOTIFICATION_BUTTONS)
|
|
|
|
return null;
|
|
|
|
|
2015-02-17 00:13:48 +00:00
|
|
|
this._buttonBox.add(button);
|
|
|
|
button.connect('clicked', Lang.bind(this, function() {
|
|
|
|
callback();
|
|
|
|
|
|
|
|
if (!this.notification.resident) {
|
|
|
|
// We don't hide a resident notification when the user invokes one of its actions,
|
|
|
|
// because it is common for such notifications to update themselves with new
|
|
|
|
// information based on the action. We'd like to display the updated information
|
|
|
|
// in place, rather than pop-up a new notification.
|
|
|
|
this.emit('done-displaying');
|
|
|
|
this.notification.destroy();
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
return button;
|
|
|
|
},
|
|
|
|
|
|
|
|
addAction: function(label, callback) {
|
|
|
|
let button = new St.Button({ style_class: 'notification-button',
|
|
|
|
label: label,
|
|
|
|
x_expand: true,
|
|
|
|
can_focus: true });
|
|
|
|
|
|
|
|
return this.addButton(button, callback);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2012-07-19 13:05:17 +00:00
|
|
|
const SourceActor = new Lang.Class({
|
|
|
|
Name: 'SourceActor',
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2012-07-19 13:05:17 +00:00
|
|
|
_init: function(source, size) {
|
|
|
|
this._source = source;
|
2012-07-23 04:07:51 +00:00
|
|
|
this._size = size;
|
2011-06-24 19:46:55 +00:00
|
|
|
|
|
|
|
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));
|
2012-07-19 13:05:17 +00:00
|
|
|
this.actor.connect('destroy', Lang.bind(this, function() {
|
2014-10-09 18:31:04 +00:00
|
|
|
this._source.disconnect(this._iconUpdatedId);
|
2012-07-19 13:05:17 +00:00
|
|
|
this._actorDestroyed = true;
|
|
|
|
}));
|
2011-07-12 23:18:58 +00:00
|
|
|
this._actorDestroyed = false;
|
2011-06-24 19:46:55 +00:00
|
|
|
|
2014-02-26 17:09:45 +00:00
|
|
|
let scale_factor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
|
2014-02-18 05:03:09 +00:00
|
|
|
this._iconBin = new St.Bin({ x_fill: true,
|
2014-02-26 17:09:45 +00:00
|
|
|
height: size * scale_factor,
|
|
|
|
width: size * scale_factor });
|
2011-06-24 19:46:55 +00:00
|
|
|
|
|
|
|
this.actor.add_actor(this._iconBin);
|
2012-07-23 04:07:51 +00:00
|
|
|
|
2014-10-09 18:31:04 +00:00
|
|
|
this._iconUpdatedId = this._source.connect('icon-updated', Lang.bind(this, this._updateIcon));
|
2012-07-23 04:07:51 +00:00
|
|
|
this._updateIcon();
|
2012-07-19 13:05:17 +00:00
|
|
|
},
|
2011-10-07 22:31:26 +00:00
|
|
|
|
2012-07-19 13:05:17 +00:00
|
|
|
setIcon: function(icon) {
|
|
|
|
this._iconBin.child = icon;
|
2012-07-23 04:07:51 +00:00
|
|
|
this._iconSet = true;
|
2010-12-15 21:30:50 +00:00
|
|
|
},
|
|
|
|
|
2011-06-24 19:46:55 +00:00
|
|
|
_getPreferredWidth: function (actor, forHeight, alloc) {
|
|
|
|
let [min, nat] = this._iconBin.get_preferred_width(forHeight);
|
|
|
|
alloc.min_size = min; alloc.nat_size = nat;
|
|
|
|
},
|
|
|
|
|
|
|
|
_getPreferredHeight: function (actor, forWidth, alloc) {
|
|
|
|
let [min, nat] = this._iconBin.get_preferred_height(forWidth);
|
|
|
|
alloc.min_size = min; alloc.nat_size = nat;
|
|
|
|
},
|
|
|
|
|
|
|
|
_allocate: function(actor, box, flags) {
|
|
|
|
// the iconBin should fill our entire box
|
|
|
|
this._iconBin.allocate(box, flags);
|
2014-02-14 17:39:32 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_updateIcon: function() {
|
|
|
|
if (this._actorDestroyed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!this._iconSet)
|
|
|
|
this._iconBin.child = this._source.createIcon(this._size);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
const SourceActorWithLabel = new Lang.Class({
|
|
|
|
Name: 'SourceActorWithLabel',
|
|
|
|
Extends: SourceActor,
|
|
|
|
|
|
|
|
_init: function(source, size) {
|
|
|
|
this.parent(source, size);
|
|
|
|
|
|
|
|
this._counterLabel = new St.Label({ x_align: Clutter.ActorAlign.CENTER,
|
|
|
|
x_expand: true,
|
|
|
|
y_align: Clutter.ActorAlign.CENTER,
|
|
|
|
y_expand: true });
|
|
|
|
|
|
|
|
this._counterBin = new St.Bin({ style_class: 'summary-source-counter',
|
|
|
|
child: this._counterLabel,
|
|
|
|
layout_manager: new Clutter.BinLayout() });
|
|
|
|
this._counterBin.hide();
|
|
|
|
|
|
|
|
this._counterBin.connect('style-changed', Lang.bind(this, function() {
|
|
|
|
let themeNode = this._counterBin.get_theme_node();
|
|
|
|
this._counterBin.translation_x = themeNode.get_length('-shell-counter-overlap-x');
|
|
|
|
this._counterBin.translation_y = themeNode.get_length('-shell-counter-overlap-y');
|
|
|
|
}));
|
|
|
|
|
|
|
|
this.actor.add_actor(this._counterBin);
|
|
|
|
|
2014-10-09 18:31:04 +00:00
|
|
|
this._countUpdatedId = this._source.connect('count-updated', Lang.bind(this, this._updateCount));
|
2014-02-14 17:39:32 +00:00
|
|
|
this._updateCount();
|
2014-10-09 18:31:04 +00:00
|
|
|
|
|
|
|
this.actor.connect('destroy', function() {
|
|
|
|
this._source.disconnect(this._countUpdatedId);
|
|
|
|
});
|
2014-02-14 17:39:32 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_allocate: function(actor, box, flags) {
|
|
|
|
this.parent(actor, box, flags);
|
2011-06-24 19:46:55 +00:00
|
|
|
|
|
|
|
let childBox = new Clutter.ActorBox();
|
|
|
|
|
|
|
|
let [minWidth, minHeight, naturalWidth, naturalHeight] = this._counterBin.get_preferred_size();
|
2012-02-14 01:37:28 +00:00
|
|
|
let direction = this.actor.get_text_direction();
|
2011-06-24 19:46:55 +00:00
|
|
|
|
2012-02-14 01:37:28 +00:00
|
|
|
if (direction == Clutter.TextDirection.LTR) {
|
2011-06-24 19:46:55 +00:00
|
|
|
// allocate on the right in LTR
|
|
|
|
childBox.x1 = box.x2 - naturalWidth;
|
|
|
|
childBox.x2 = box.x2;
|
|
|
|
} else {
|
|
|
|
// allocate on the left in RTL
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = naturalWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
childBox.y1 = box.y2 - naturalHeight;
|
|
|
|
childBox.y2 = box.y2;
|
|
|
|
|
|
|
|
this._counterBin.allocate(childBox, flags);
|
|
|
|
},
|
|
|
|
|
2012-07-19 13:05:17 +00:00
|
|
|
_updateCount: function() {
|
|
|
|
if (this._actorDestroyed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this._counterBin.visible = this._source.countVisible;
|
2012-09-10 15:41:30 +00:00
|
|
|
|
|
|
|
let text;
|
|
|
|
if (this._source.count < 100)
|
|
|
|
text = this._source.count.toString();
|
|
|
|
else
|
|
|
|
text = String.fromCharCode(0x22EF); // midline horizontal ellipsis
|
|
|
|
|
|
|
|
this._counterLabel.set_text(text);
|
2012-07-23 04:07:51 +00:00
|
|
|
}
|
2012-07-19 13:05:17 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
const Source = new Lang.Class({
|
|
|
|
Name: 'MessageTraySource',
|
|
|
|
|
2012-08-12 10:35:41 +00:00
|
|
|
SOURCE_ICON_SIZE: 48,
|
2012-07-19 13:05:17 +00:00
|
|
|
|
2012-05-30 13:58:37 +00:00
|
|
|
_init: function(title, iconName) {
|
2012-07-19 13:05:17 +00:00
|
|
|
this.title = title;
|
|
|
|
this.iconName = iconName;
|
|
|
|
|
|
|
|
this.isChat = false;
|
|
|
|
|
|
|
|
this.notifications = [];
|
2012-10-16 15:08:54 +00:00
|
|
|
|
|
|
|
this.policy = this._createPolicy();
|
2012-07-19 13:05:17 +00:00
|
|
|
},
|
|
|
|
|
2012-08-06 15:28:55 +00:00
|
|
|
get count() {
|
|
|
|
return this.notifications.length;
|
|
|
|
},
|
2011-06-24 19:46:55 +00:00
|
|
|
|
2012-08-06 15:28:55 +00:00
|
|
|
get unseenCount() {
|
|
|
|
return this.notifications.filter(function(n) { return !n.acknowledged; }).length;
|
2011-06-24 19:46:55 +00:00
|
|
|
},
|
|
|
|
|
2012-08-06 15:28:55 +00:00
|
|
|
get countVisible() {
|
|
|
|
return this.count > 1;
|
|
|
|
},
|
|
|
|
|
|
|
|
countUpdated: function() {
|
|
|
|
this.emit('count-updated');
|
2011-06-24 19:47:24 +00:00
|
|
|
},
|
|
|
|
|
2012-10-16 15:08:54 +00:00
|
|
|
_createPolicy: function() {
|
|
|
|
return new NotificationPolicy();
|
|
|
|
},
|
|
|
|
|
2011-06-08 06:27:57 +00:00
|
|
|
setTitle: function(newTitle) {
|
|
|
|
this.title = newTitle;
|
|
|
|
this.emit('title-changed');
|
|
|
|
},
|
|
|
|
|
2015-02-17 02:27:11 +00:00
|
|
|
createBanner: function(notification) {
|
|
|
|
return new NotificationBanner(notification);
|
|
|
|
},
|
|
|
|
|
2012-07-19 13:05:17 +00:00
|
|
|
// Called to create a new icon actor.
|
2011-10-07 22:31:26 +00:00
|
|
|
// Provides a sane default implementation, override if you need
|
|
|
|
// something more fancy.
|
2012-07-19 13:05:17 +00:00
|
|
|
createIcon: function(size) {
|
2012-09-15 06:10:15 +00:00
|
|
|
return new St.Icon({ gicon: this.getIcon(),
|
2012-07-19 13:05:17 +00:00
|
|
|
icon_size: size });
|
2010-01-13 20:05:20 +00:00
|
|
|
},
|
|
|
|
|
2012-09-15 06:10:15 +00:00
|
|
|
getIcon: function() {
|
|
|
|
return new Gio.ThemedIcon({ name: this.iconName });
|
|
|
|
},
|
|
|
|
|
2013-10-14 01:52:44 +00:00
|
|
|
_onNotificationDestroy: function(notification) {
|
|
|
|
let index = this.notifications.indexOf(notification);
|
|
|
|
if (index < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this.notifications.splice(index, 1);
|
|
|
|
if (this.notifications.length == 0)
|
2015-02-15 19:19:03 +00:00
|
|
|
this.destroy();
|
2013-10-14 01:52:44 +00:00
|
|
|
|
|
|
|
this.countUpdated();
|
|
|
|
},
|
|
|
|
|
2011-02-28 18:13:32 +00:00
|
|
|
pushNotification: function(notification) {
|
2013-10-14 01:51:30 +00:00
|
|
|
if (this.notifications.indexOf(notification) >= 0)
|
|
|
|
return;
|
2010-02-25 19:42:18 +00:00
|
|
|
|
2015-02-13 23:06:11 +00:00
|
|
|
while (this.notifications.length >= MAX_NOTIFICATIONS_PER_SOURCE)
|
|
|
|
this.notifications.shift().destroy(NotificationDestroyedReason.EXPIRED);
|
|
|
|
|
2013-10-14 01:52:44 +00:00
|
|
|
notification.connect('destroy', Lang.bind(this, this._onNotificationDestroy));
|
2015-02-14 01:33:54 +00:00
|
|
|
notification.connect('acknowledged-changed', Lang.bind(this, this.countUpdated));
|
2013-10-14 01:51:30 +00:00
|
|
|
this.notifications.push(notification);
|
|
|
|
this.emit('notification-added', notification);
|
|
|
|
|
2012-08-06 15:28:55 +00:00
|
|
|
this.countUpdated();
|
2011-02-28 18:13:32 +00:00
|
|
|
},
|
2010-02-25 19:42:18 +00:00
|
|
|
|
2011-02-28 18:13:32 +00:00
|
|
|
notify: function(notification) {
|
2012-08-06 15:28:55 +00:00
|
|
|
notification.acknowledged = false;
|
2011-02-28 18:13:32 +00:00
|
|
|
this.pushNotification(notification);
|
2012-10-16 15:08:54 +00:00
|
|
|
|
2015-02-17 02:49:24 +00:00
|
|
|
if (this.policy.showBanners) {
|
|
|
|
this.emit('notify', notification);
|
|
|
|
} else {
|
|
|
|
notification.playSound();
|
2012-11-05 17:10:24 +00:00
|
|
|
}
|
2010-01-13 20:05:20 +00:00
|
|
|
},
|
|
|
|
|
2011-03-21 21:43:34 +00:00
|
|
|
destroy: function(reason) {
|
2012-10-16 15:08:54 +00:00
|
|
|
this.policy.destroy();
|
2012-10-25 16:30:27 +00:00
|
|
|
|
|
|
|
let notifications = this.notifications;
|
|
|
|
this.notifications = [];
|
|
|
|
|
|
|
|
for (let i = 0; i < notifications.length; i++)
|
|
|
|
notifications[i].destroy(reason);
|
|
|
|
|
2011-03-21 21:43:34 +00:00
|
|
|
this.emit('destroy', reason);
|
2010-08-05 17:09:27 +00:00
|
|
|
},
|
|
|
|
|
2012-07-23 04:07:51 +00:00
|
|
|
iconUpdated: function() {
|
|
|
|
this.emit('icon-updated');
|
|
|
|
},
|
|
|
|
|
2013-08-02 04:08:33 +00:00
|
|
|
// To be overridden by subclasses
|
|
|
|
open: function() {
|
2010-12-16 20:49:47 +00:00
|
|
|
},
|
|
|
|
|
2011-03-21 21:43:34 +00:00
|
|
|
destroyNonResidentNotifications: function() {
|
|
|
|
for (let i = this.notifications.length - 1; i >= 0; i--)
|
|
|
|
if (!this.notifications[i].resident)
|
|
|
|
this.notifications[i].destroy();
|
2011-06-24 19:47:24 +00:00
|
|
|
|
2012-08-06 15:28:55 +00:00
|
|
|
this.countUpdated();
|
2015-02-11 16:01:11 +00:00
|
|
|
}
|
2011-11-20 15:12:02 +00:00
|
|
|
});
|
2010-01-13 20:05:20 +00:00
|
|
|
Signals.addSignalMethods(Source.prototype);
|
|
|
|
|
2011-11-20 17:56:27 +00:00
|
|
|
const MessageTray = new Lang.Class({
|
|
|
|
Name: 'MessageTray',
|
2010-01-13 20:05:20 +00:00
|
|
|
|
|
|
|
_init: function() {
|
2011-08-16 12:24:39 +00:00
|
|
|
this._presence = new GnomeSession.Presence(Lang.bind(this, function(proxy, error) {
|
|
|
|
this._onStatusChanged(proxy.status);
|
|
|
|
}));
|
2011-02-19 15:49:56 +00:00
|
|
|
this._busy = false;
|
2015-02-13 22:53:18 +00:00
|
|
|
this._bannerBlocked = false;
|
2011-08-16 12:24:39 +00:00
|
|
|
this._presence.connectSignal('StatusChanged', Lang.bind(this, function(proxy, senderName, [status]) {
|
|
|
|
this._onStatusChanged(status);
|
|
|
|
}));
|
2011-02-19 15:49:56 +00:00
|
|
|
|
2015-02-13 20:12:53 +00:00
|
|
|
global.stage.connect('enter-event', Lang.bind(this,
|
|
|
|
function(a, ev) {
|
|
|
|
// HACK: St uses ClutterInputDevice for hover tracking, which
|
|
|
|
// misses relevant X11 events when untracked actors are
|
|
|
|
// involved (read: the notification banner in normal mode),
|
|
|
|
// so fix up Clutter's view of the pointer position in
|
|
|
|
// that case.
|
|
|
|
let related = ev.get_related();
|
|
|
|
if (!related || this.actor.contains(related))
|
|
|
|
global.sync_pointer();
|
|
|
|
}));
|
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
this.actor = new St.Widget({ visible: false,
|
|
|
|
clip_to_allocation: true,
|
2015-02-11 17:04:22 +00:00
|
|
|
layout_manager: new Clutter.BinLayout() });
|
2015-02-25 16:43:54 +00:00
|
|
|
let constraint = new Layout.MonitorConstraint({ primary: true });
|
|
|
|
Main.layoutManager.panelBox.bind_property('visible',
|
|
|
|
constraint, 'work-area',
|
|
|
|
GObject.BindingFlags.SYNC_CREATE);
|
|
|
|
this.actor.add_constraint(constraint);
|
|
|
|
|
|
|
|
this._bannerBin = new St.Widget({ name: 'notification-container',
|
|
|
|
reactive: true,
|
|
|
|
track_hover: true,
|
|
|
|
y_align: Clutter.ActorAlign.START,
|
|
|
|
x_align: Clutter.ActorAlign.CENTER,
|
|
|
|
y_expand: true,
|
|
|
|
x_expand: true,
|
|
|
|
layout_manager: new Clutter.BinLayout() });
|
|
|
|
this._bannerBin.connect('key-release-event',
|
|
|
|
Lang.bind(this, this._onNotificationKeyRelease));
|
|
|
|
this._bannerBin.connect('notify::hover',
|
|
|
|
Lang.bind(this, this._onNotificationHoverChanged));
|
|
|
|
this.actor.add_actor(this._bannerBin);
|
|
|
|
|
|
|
|
this._notificationFocusGrabber = new FocusGrabber(this._bannerBin);
|
2010-01-13 20:05:20 +00:00
|
|
|
this._notificationQueue = [];
|
2010-02-01 20:23:49 +00:00
|
|
|
this._notification = null;
|
2015-02-17 02:13:56 +00:00
|
|
|
this._banner = null;
|
|
|
|
this._bannerClickedId = 0;
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2012-07-30 23:14:49 +00:00
|
|
|
this._userActiveWhileNotificationShown = false;
|
2012-03-15 02:50:58 +00:00
|
|
|
|
2013-08-14 13:47:27 +00:00
|
|
|
this.idleMonitor = Meta.IdleMonitor.get_core();
|
2012-03-15 02:50:58 +00:00
|
|
|
|
2013-03-13 20:14:53 +00:00
|
|
|
this._useLongerNotificationLeftTimeout = false;
|
2013-03-11 19:36:56 +00:00
|
|
|
|
2013-03-13 20:14:53 +00:00
|
|
|
// pointerInNotification is sort of a misnomer -- it tracks whether
|
2013-03-11 19:36:56 +00:00
|
|
|
// a message tray notification should expand. The value is
|
2013-03-13 20:14:53 +00:00
|
|
|
// partially driven by the hover state of the notification, but has
|
2013-03-11 19:36:56 +00:00
|
|
|
// a lot of complex state related to timeouts and the current
|
|
|
|
// state of the pointer when a notification pops up.
|
2013-03-13 20:14:53 +00:00
|
|
|
this._pointerInNotification = false;
|
2013-03-11 19:36:56 +00:00
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
// This tracks this._bannerBin.hover and is used to fizzle
|
2013-03-13 20:14:53 +00:00
|
|
|
// out non-changing hover notifications in onNotificationHoverChanged.
|
|
|
|
this._notificationHovered = false;
|
2013-03-11 19:36:56 +00:00
|
|
|
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
this._notificationState = State.HIDDEN;
|
|
|
|
this._notificationTimeoutId = 0;
|
2010-02-22 22:19:32 +00:00
|
|
|
this._notificationRemoved = false;
|
2010-02-09 18:31:39 +00:00
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
Main.layoutManager.addChrome(this.actor, { affectsInputRegion: false });
|
|
|
|
Main.layoutManager.trackChrome(this._bannerBin, { affectsInputRegion: true });
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2013-03-18 19:02:05 +00:00
|
|
|
global.screen.connect('in-fullscreen-changed', Lang.bind(this, this._updateState));
|
2010-02-12 17:33:00 +00:00
|
|
|
|
2012-10-10 20:17:39 +00:00
|
|
|
Main.sessionMode.connect('updated', Lang.bind(this, this._sessionUpdated));
|
2012-05-22 22:02:00 +00:00
|
|
|
|
2015-02-21 08:05:58 +00:00
|
|
|
Main.overview.connect('window-drag-begin',
|
|
|
|
Lang.bind(this, this._onDragBegin));
|
|
|
|
Main.overview.connect('window-drag-cancelled',
|
|
|
|
Lang.bind(this, this._onDragEnd));
|
|
|
|
Main.overview.connect('window-drag-end',
|
|
|
|
Lang.bind(this, this._onDragEnd));
|
|
|
|
|
|
|
|
Main.overview.connect('item-drag-begin',
|
|
|
|
Lang.bind(this, this._onDragBegin));
|
|
|
|
Main.overview.connect('item-drag-cancelled',
|
|
|
|
Lang.bind(this, this._onDragEnd));
|
|
|
|
Main.overview.connect('item-drag-end',
|
|
|
|
Lang.bind(this, this._onDragEnd));
|
|
|
|
|
|
|
|
Main.xdndHandler.connect('drag-begin',
|
|
|
|
Lang.bind(this, this._onDragBegin));
|
|
|
|
Main.xdndHandler.connect('drag-end',
|
|
|
|
Lang.bind(this, this._onDragEnd));
|
|
|
|
|
2012-08-20 20:16:21 +00:00
|
|
|
Main.wm.addKeybinding('focus-active-notification',
|
2014-06-24 19:17:09 +00:00
|
|
|
new Gio.Settings({ schema_id: SHELL_KEYBINDINGS_SCHEMA }),
|
2012-08-20 20:16:21 +00:00
|
|
|
Meta.KeyBindingFlags.NONE,
|
2014-12-11 14:35:40 +00:00
|
|
|
Shell.ActionMode.NORMAL |
|
|
|
|
Shell.ActionMode.OVERVIEW,
|
2012-08-20 20:16:21 +00:00
|
|
|
Lang.bind(this, this._expandActiveNotification));
|
2012-07-14 11:07:24 +00:00
|
|
|
|
2014-01-14 22:49:47 +00:00
|
|
|
this._sources = new Map();
|
2012-08-17 20:07:42 +00:00
|
|
|
|
2012-10-10 20:17:39 +00:00
|
|
|
this._sessionUpdated();
|
|
|
|
},
|
|
|
|
|
|
|
|
_sessionUpdated: function() {
|
|
|
|
this._updateState();
|
2012-08-17 20:07:42 +00:00
|
|
|
},
|
|
|
|
|
2015-02-21 08:05:58 +00:00
|
|
|
_onDragBegin: function() {
|
|
|
|
Shell.util_set_hidden_from_pick(this.actor, true);
|
|
|
|
},
|
|
|
|
|
|
|
|
_onDragEnd: function() {
|
|
|
|
Shell.util_set_hidden_from_pick(this.actor, false);
|
|
|
|
},
|
|
|
|
|
2012-11-08 14:38:57 +00:00
|
|
|
_onNotificationKeyRelease: function(actor, event) {
|
2012-12-23 03:21:47 +00:00
|
|
|
if (event.get_key_symbol() == Clutter.KEY_Escape && event.get_state() == 0) {
|
2014-02-26 13:44:53 +00:00
|
|
|
this._expireNotification();
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_STOP;
|
2012-11-08 14:38:57 +00:00
|
|
|
}
|
|
|
|
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2012-11-08 14:38:57 +00:00
|
|
|
},
|
|
|
|
|
2014-02-26 13:44:53 +00:00
|
|
|
_expireNotification: function() {
|
|
|
|
this._notificationExpired = true;
|
|
|
|
this._updateState();
|
|
|
|
},
|
|
|
|
|
2015-02-14 02:17:16 +00:00
|
|
|
get queueCount() {
|
|
|
|
return this._notificationQueue.length;
|
|
|
|
},
|
|
|
|
|
2015-02-13 22:53:18 +00:00
|
|
|
set bannerBlocked(v) {
|
|
|
|
if (this._bannerBlocked == v)
|
|
|
|
return;
|
|
|
|
this._bannerBlocked = v;
|
|
|
|
this._updateState();
|
|
|
|
},
|
|
|
|
|
2010-01-13 20:05:20 +00:00
|
|
|
contains: function(source) {
|
2012-11-04 17:49:14 +00:00
|
|
|
return this._sources.has(source);
|
2010-01-13 20:05:20 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
add: function(source) {
|
|
|
|
if (this.contains(source)) {
|
2010-08-09 17:18:15 +00:00
|
|
|
log('Trying to re-add source ' + source.title);
|
2010-01-13 20:05:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-16 15:08:54 +00:00
|
|
|
// Register that we got a notification for this source
|
|
|
|
source.policy.store();
|
|
|
|
|
|
|
|
source.policy.connect('enable-changed', Lang.bind(this, this._onSourceEnableChanged, source));
|
|
|
|
source.policy.connect('policy-changed', Lang.bind(this, this._updateState));
|
|
|
|
this._onSourceEnableChanged(source.policy, source);
|
2012-11-04 17:49:14 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_addSource: function(source) {
|
|
|
|
let obj = {
|
|
|
|
source: source,
|
|
|
|
notifyId: 0,
|
|
|
|
destroyId: 0,
|
|
|
|
};
|
2010-06-23 19:20:39 +00:00
|
|
|
|
2012-11-04 17:49:14 +00:00
|
|
|
this._sources.set(source, obj);
|
2010-01-28 18:12:03 +00:00
|
|
|
|
2012-11-04 17:49:14 +00:00
|
|
|
obj.notifyId = source.connect('notify', Lang.bind(this, this._onNotify));
|
|
|
|
obj.destroyId = source.connect('destroy', Lang.bind(this, this._onSourceDestroy));
|
2011-11-03 14:48:09 +00:00
|
|
|
|
2013-01-30 18:47:55 +00:00
|
|
|
this.emit('source-added', source);
|
2012-05-22 22:02:00 +00:00
|
|
|
},
|
|
|
|
|
2012-11-04 17:49:14 +00:00
|
|
|
_removeSource: function(source) {
|
2014-01-14 22:49:47 +00:00
|
|
|
let obj = this._sources.get(source);
|
|
|
|
this._sources.delete(source);
|
2010-12-30 21:09:56 +00:00
|
|
|
|
2012-11-04 17:49:14 +00:00
|
|
|
source.disconnect(obj.notifyId);
|
|
|
|
source.disconnect(obj.destroyId);
|
|
|
|
|
2013-02-05 18:06:19 +00:00
|
|
|
this.emit('source-removed', source);
|
2010-01-13 20:05:20 +00:00
|
|
|
},
|
|
|
|
|
2013-01-30 18:47:55 +00:00
|
|
|
getSources: function() {
|
2014-01-14 22:49:47 +00:00
|
|
|
return [k for (k of this._sources.keys())];
|
2012-11-04 17:49:14 +00:00
|
|
|
},
|
|
|
|
|
2012-10-16 15:08:54 +00:00
|
|
|
_onSourceEnableChanged: function(policy, source) {
|
|
|
|
let wasEnabled = this.contains(source);
|
|
|
|
let shouldBeEnabled = policy.enable;
|
|
|
|
|
|
|
|
if (wasEnabled != shouldBeEnabled) {
|
|
|
|
if (shouldBeEnabled)
|
|
|
|
this._addSource(source);
|
|
|
|
else
|
|
|
|
this._removeSource(source);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2012-11-04 17:49:14 +00:00
|
|
|
_onSourceDestroy: function(source) {
|
|
|
|
this._removeSource(source);
|
|
|
|
},
|
|
|
|
|
2011-03-03 00:47:58 +00:00
|
|
|
_onNotificationDestroy: function(notification) {
|
2010-02-22 22:19:32 +00:00
|
|
|
if (this._notification == notification && (this._notificationState == State.SHOWN || this._notificationState == State.SHOWING)) {
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
this._updateNotificationTimeout(0);
|
2010-02-22 22:19:32 +00:00
|
|
|
this._notificationRemoved = true;
|
|
|
|
this._updateState();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let index = this._notificationQueue.indexOf(notification);
|
2015-02-21 08:59:24 +00:00
|
|
|
if (index != -1) {
|
2010-02-22 22:19:32 +00:00
|
|
|
this._notificationQueue.splice(index, 1);
|
2015-02-21 08:59:24 +00:00
|
|
|
this.emit('queue-changed');
|
|
|
|
}
|
2010-02-22 22:19:32 +00:00
|
|
|
},
|
|
|
|
|
2010-02-01 20:23:49 +00:00
|
|
|
_onNotify: function(source, notification) {
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
if (this._notification == notification) {
|
|
|
|
// If a notification that is being shown is updated, we update
|
|
|
|
// how it is shown and extend the time until it auto-hides.
|
|
|
|
// If a new notification is updated while it is being hidden,
|
|
|
|
// we stop hiding it and show it again.
|
|
|
|
this._updateShowingNotification();
|
|
|
|
} else if (this._notificationQueue.indexOf(notification) < 0) {
|
2015-02-14 02:18:52 +00:00
|
|
|
// If the queue is "full", we skip banner mode and just show a small
|
|
|
|
// indicator in the panel; however do make an exception for CRITICAL
|
|
|
|
// notifications, as only banner mode allows expansion.
|
|
|
|
let bannerCount = this._notification ? 1 : 0;
|
|
|
|
let full = (this.queueCount + bannerCount >= MAX_NOTIFICATIONS_IN_QUEUE);
|
|
|
|
if (!full || notification.urgency == Urgency.CRITICAL) {
|
|
|
|
notification.connect('destroy',
|
|
|
|
Lang.bind(this, this._onNotificationDestroy));
|
|
|
|
this._notificationQueue.push(notification);
|
|
|
|
this._notificationQueue.sort(function(notification1, notification2) {
|
|
|
|
return (notification2.urgency - notification1.urgency);
|
|
|
|
});
|
2015-02-21 08:59:24 +00:00
|
|
|
this.emit('queue-changed');
|
2015-02-14 02:18:52 +00:00
|
|
|
}
|
2010-02-22 22:19:32 +00:00
|
|
|
}
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
this._updateState();
|
2010-01-28 18:12:03 +00:00
|
|
|
},
|
|
|
|
|
2014-05-28 19:18:00 +00:00
|
|
|
_resetNotificationLeftTimeout: function() {
|
|
|
|
this._useLongerNotificationLeftTimeout = false;
|
|
|
|
if (this._notificationLeftTimeoutId) {
|
|
|
|
Mainloop.source_remove(this._notificationLeftTimeoutId);
|
|
|
|
this._notificationLeftTimeoutId = 0;
|
|
|
|
this._notificationLeftMouseX = -1;
|
|
|
|
this._notificationLeftMouseY = -1;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2013-03-13 20:14:53 +00:00
|
|
|
_onNotificationHoverChanged: function() {
|
2015-02-25 16:43:54 +00:00
|
|
|
if (this._bannerBin.hover == this._notificationHovered)
|
2013-03-11 19:36:56 +00:00
|
|
|
return;
|
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
this._notificationHovered = this._bannerBin.hover;
|
2013-03-13 20:14:53 +00:00
|
|
|
if (this._notificationHovered) {
|
2014-05-28 19:18:00 +00:00
|
|
|
this._resetNotificationLeftTimeout();
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2010-08-31 19:50:18 +00:00
|
|
|
if (this._showNotificationMouseX >= 0) {
|
|
|
|
let actorAtShowNotificationPosition =
|
|
|
|
global.stage.get_actor_at_pos(Clutter.PickMode.ALL, this._showNotificationMouseX, this._showNotificationMouseY);
|
|
|
|
this._showNotificationMouseX = -1;
|
|
|
|
this._showNotificationMouseY = -1;
|
2013-03-13 20:14:53 +00:00
|
|
|
// Don't set this._pointerInNotification to true if the pointer was initially in the area where the notification
|
2010-08-31 19:50:18 +00:00
|
|
|
// popped up. That way we will not be expanding notifications that happen to pop up over the pointer
|
|
|
|
// automatically. Instead, the user is able to expand the notification by mousing away from it and then
|
|
|
|
// mousing back in. Because this is an expected action, we set the boolean flag that indicates that a longer
|
|
|
|
// timeout should be used before popping down the notification.
|
2015-02-25 16:43:54 +00:00
|
|
|
if (this._bannerBin.contains(actorAtShowNotificationPosition)) {
|
2013-03-13 20:14:53 +00:00
|
|
|
this._useLongerNotificationLeftTimeout = true;
|
2010-08-31 19:50:18 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2014-05-28 19:02:40 +00:00
|
|
|
|
2013-03-13 20:14:53 +00:00
|
|
|
this._pointerInNotification = true;
|
2010-03-15 16:20:10 +00:00
|
|
|
this._updateState();
|
|
|
|
} else {
|
2010-10-30 19:54:43 +00:00
|
|
|
// We record the position of the mouse the moment it leaves the tray. These coordinates are used in
|
2013-03-13 20:14:53 +00:00
|
|
|
// this._onNotificationLeftTimeout() to determine if the mouse has moved far enough during the initial timeout for us
|
2010-10-30 19:54:43 +00:00
|
|
|
// to consider that the user intended to leave the tray and therefore hide the tray. If the mouse is still
|
|
|
|
// close to its previous position, we extend the timeout once.
|
|
|
|
let [x, y, mods] = global.get_pointer();
|
2013-03-13 20:14:53 +00:00
|
|
|
this._notificationLeftMouseX = x;
|
|
|
|
this._notificationLeftMouseY = y;
|
2010-10-30 19:54:43 +00:00
|
|
|
|
2010-08-31 19:50:18 +00:00
|
|
|
// We wait just a little before hiding the message tray in case the user quickly moves the mouse back into it.
|
|
|
|
// We wait for a longer period if the notification popped up where the mouse pointer was already positioned.
|
|
|
|
// That gives the user more time to mouse away from the notification and mouse back in in order to expand it.
|
2013-03-13 20:14:53 +00:00
|
|
|
let timeout = this._useLongerNotificationLeftTimeout ? LONGER_HIDE_TIMEOUT * 1000 : HIDE_TIMEOUT * 1000;
|
|
|
|
this._notificationLeftTimeoutId = Mainloop.timeout_add(timeout, Lang.bind(this, this._onNotificationLeftTimeout));
|
2014-04-10 17:26:52 +00:00
|
|
|
GLib.Source.set_name_by_id(this._notificationLeftTimeoutId, '[gnome-shell] this._onNotificationLeftTimeout');
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
}
|
2010-01-13 20:05:20 +00:00
|
|
|
},
|
|
|
|
|
2011-08-16 12:24:39 +00:00
|
|
|
_onStatusChanged: function(status) {
|
2011-02-19 15:49:56 +00:00
|
|
|
if (status == GnomeSession.PresenceStatus.BUSY) {
|
|
|
|
// remove notification and allow the summary to be closed now
|
|
|
|
this._updateNotificationTimeout(0);
|
|
|
|
this._busy = true;
|
|
|
|
} else if (status != GnomeSession.PresenceStatus.IDLE) {
|
|
|
|
// We preserve the previous value of this._busy if the status turns to IDLE
|
|
|
|
// so that we don't start showing notifications queued during the BUSY state
|
|
|
|
// as the screensaver gets activated.
|
|
|
|
this._busy = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
this._updateState();
|
|
|
|
},
|
|
|
|
|
2013-03-13 20:14:53 +00:00
|
|
|
_onNotificationLeftTimeout: function() {
|
2010-10-30 19:54:43 +00:00
|
|
|
let [x, y, mods] = global.get_pointer();
|
2015-02-19 10:08:39 +00:00
|
|
|
// We extend the timeout once if the mouse moved no further than MOUSE_LEFT_ACTOR_THRESHOLD to either side.
|
2013-03-13 20:14:53 +00:00
|
|
|
if (this._notificationLeftMouseX > -1 &&
|
2015-02-19 10:08:39 +00:00
|
|
|
y < this._notificationLeftMouseY + MOUSE_LEFT_ACTOR_THRESHOLD &&
|
2013-03-13 20:14:53 +00:00
|
|
|
y > this._notificationLeftMouseY - MOUSE_LEFT_ACTOR_THRESHOLD &&
|
|
|
|
x < this._notificationLeftMouseX + MOUSE_LEFT_ACTOR_THRESHOLD &&
|
|
|
|
x > this._notificationLeftMouseX - MOUSE_LEFT_ACTOR_THRESHOLD) {
|
|
|
|
this._notificationLeftMouseX = -1;
|
|
|
|
this._notificationLeftTimeoutId = Mainloop.timeout_add(LONGER_HIDE_TIMEOUT * 1000,
|
|
|
|
Lang.bind(this, this._onNotificationLeftTimeout));
|
2014-04-10 17:26:52 +00:00
|
|
|
GLib.Source.set_name_by_id(this._notificationLeftTimeoutId, '[gnome-shell] this._onNotificationLeftTimeout');
|
2010-10-30 19:54:43 +00:00
|
|
|
} else {
|
2013-03-13 20:14:53 +00:00
|
|
|
this._notificationLeftTimeoutId = 0;
|
|
|
|
this._useLongerNotificationLeftTimeout = false;
|
|
|
|
this._pointerInNotification = false;
|
2010-10-30 19:54:43 +00:00
|
|
|
this._updateNotificationTimeout(0);
|
|
|
|
this._updateState();
|
|
|
|
}
|
2013-11-29 00:45:39 +00:00
|
|
|
return GLib.SOURCE_REMOVE;
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
},
|
2010-01-28 18:39:00 +00:00
|
|
|
|
2011-02-10 03:45:50 +00:00
|
|
|
_escapeTray: function() {
|
2013-03-13 20:14:53 +00:00
|
|
|
this._pointerInNotification = false;
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
this._updateNotificationTimeout(0);
|
2010-07-21 05:26:25 +00:00
|
|
|
this._updateState();
|
|
|
|
},
|
|
|
|
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
// All of the logic for what happens when occurs here; the various
|
|
|
|
// event handlers merely update variables such as
|
2013-03-13 20:14:53 +00:00
|
|
|
// 'this._pointerInNotification', 'this._traySummoned', etc, and
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
// _updateState() figures out what (if anything) needs to be done
|
|
|
|
// at the present time.
|
|
|
|
_updateState: function() {
|
2015-02-25 17:08:53 +00:00
|
|
|
this.actor.visible = !this._bannerBlocked && this._banner != null;
|
2015-02-13 22:53:18 +00:00
|
|
|
if (this._bannerBlocked)
|
|
|
|
return;
|
|
|
|
|
2013-11-15 15:34:04 +00:00
|
|
|
// If our state changes caused _updateState to be called,
|
|
|
|
// just exit now to prevent reentrancy issues.
|
|
|
|
if (this._updatingState)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this._updatingState = true;
|
|
|
|
|
2013-08-02 03:07:59 +00:00
|
|
|
// Filter out acknowledged notifications.
|
2015-02-21 08:59:24 +00:00
|
|
|
let changed = false;
|
2013-08-02 03:07:59 +00:00
|
|
|
this._notificationQueue = this._notificationQueue.filter(function(n) {
|
2015-02-21 08:59:24 +00:00
|
|
|
changed = changed || n.acknowledged;
|
2013-05-12 17:52:58 +00:00
|
|
|
return !n.acknowledged;
|
|
|
|
});
|
2013-05-20 17:54:48 +00:00
|
|
|
|
2015-02-21 08:59:24 +00:00
|
|
|
if (changed)
|
|
|
|
this.emit('queue-changed');
|
|
|
|
|
2013-08-02 03:07:59 +00:00
|
|
|
let hasNotifications = Main.sessionMode.hasNotifications;
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
|
|
|
|
if (this._notificationState == State.HIDDEN) {
|
2013-08-02 03:07:59 +00:00
|
|
|
let nextNotification = this._notificationQueue[0] || null;
|
2015-02-11 16:29:23 +00:00
|
|
|
if (hasNotifications && nextNotification) {
|
2013-08-02 03:07:59 +00:00
|
|
|
let limited = this._busy || Main.layoutManager.bottomMonitor.inFullscreen;
|
|
|
|
let showNextNotification = (!limited || nextNotification.forFeedback || nextNotification.urgency == Urgency.CRITICAL);
|
2015-02-14 02:19:49 +00:00
|
|
|
if (showNextNotification)
|
|
|
|
this._showNotification();
|
2013-08-02 03:07:59 +00:00
|
|
|
}
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
} else if (this._notificationState == State.SHOWN) {
|
2013-08-02 03:07:59 +00:00
|
|
|
let expired = (this._userActiveWhileNotificationShown &&
|
|
|
|
this._notificationTimeoutId == 0 &&
|
2013-12-04 16:22:48 +00:00
|
|
|
this._notification.urgency != Urgency.CRITICAL &&
|
2015-02-17 02:13:56 +00:00
|
|
|
!this._banner.focused &&
|
2014-02-26 13:44:53 +00:00
|
|
|
!this._pointerInNotification) || this._notificationExpired;
|
2015-02-11 16:29:23 +00:00
|
|
|
let mustClose = (this._notificationRemoved || !hasNotifications || expired);
|
2013-08-02 03:07:59 +00:00
|
|
|
|
|
|
|
if (mustClose) {
|
|
|
|
let animate = hasNotifications && !this._notificationRemoved;
|
2013-08-02 02:53:21 +00:00
|
|
|
this._hideNotification(animate);
|
2015-02-17 02:13:56 +00:00
|
|
|
} else if (this._pointerInNotification && !this._banner.expanded) {
|
|
|
|
this._expandBanner(false);
|
2013-11-04 19:16:28 +00:00
|
|
|
} else if (this._pointerInNotification) {
|
2015-02-17 02:13:56 +00:00
|
|
|
this._ensureBannerFocused();
|
2013-08-02 02:53:21 +00:00
|
|
|
}
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
}
|
|
|
|
|
2013-11-15 15:34:04 +00:00
|
|
|
this._updatingState = false;
|
2014-02-26 13:44:53 +00:00
|
|
|
|
|
|
|
// Clean transient variables that are used to communicate actions
|
|
|
|
// to updateState()
|
|
|
|
this._notificationExpired = false;
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_tween: function(actor, statevar, value, params) {
|
|
|
|
let onComplete = params.onComplete;
|
|
|
|
let onCompleteScope = params.onCompleteScope;
|
|
|
|
let onCompleteParams = params.onCompleteParams;
|
|
|
|
|
|
|
|
params.onComplete = this._tweenComplete;
|
|
|
|
params.onCompleteScope = this;
|
|
|
|
params.onCompleteParams = [statevar, value, onComplete, onCompleteScope, onCompleteParams];
|
|
|
|
|
2012-11-25 22:51:44 +00:00
|
|
|
// Remove other tweens that could mess with the state machine
|
|
|
|
Tweener.removeTweens(actor);
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
Tweener.addTween(actor, params);
|
|
|
|
|
|
|
|
let valuing = (value == State.SHOWN) ? State.SHOWING : State.HIDING;
|
|
|
|
this[statevar] = valuing;
|
|
|
|
},
|
|
|
|
|
|
|
|
_tweenComplete: function(statevar, value, onComplete, onCompleteScope, onCompleteParams) {
|
|
|
|
this[statevar] = value;
|
|
|
|
if (onComplete)
|
|
|
|
onComplete.apply(onCompleteScope, onCompleteParams);
|
|
|
|
this._updateState();
|
2010-01-13 20:05:20 +00:00
|
|
|
},
|
|
|
|
|
2015-02-19 10:08:39 +00:00
|
|
|
_clampOpacity: function() {
|
2015-02-25 16:43:54 +00:00
|
|
|
this._bannerBin.opacity = Math.max(0, Math.min(this._bannerBin._opacity, 255));
|
2015-02-19 10:08:39 +00:00
|
|
|
},
|
|
|
|
|
2012-08-20 04:06:50 +00:00
|
|
|
_onIdleMonitorBecameActive: function() {
|
2012-07-30 23:14:49 +00:00
|
|
|
this._userActiveWhileNotificationShown = true;
|
2012-08-20 04:06:50 +00:00
|
|
|
this._updateNotificationTimeout(2000);
|
2012-07-30 23:14:49 +00:00
|
|
|
this._updateState();
|
2012-03-15 02:50:58 +00:00
|
|
|
},
|
|
|
|
|
2012-08-27 12:42:22 +00:00
|
|
|
_showNotification: function() {
|
|
|
|
this._notification = this._notificationQueue.shift();
|
2015-02-21 08:59:24 +00:00
|
|
|
this.emit('queue-changed');
|
2012-08-20 04:06:50 +00:00
|
|
|
|
2013-03-11 21:29:41 +00:00
|
|
|
this._userActiveWhileNotificationShown = this.idleMonitor.get_idletime() <= IDLE_TIME;
|
2013-01-18 05:24:32 +00:00
|
|
|
if (!this._userActiveWhileNotificationShown) {
|
|
|
|
// If the user isn't active, set up a watch to let us know
|
|
|
|
// when the user becomes active.
|
|
|
|
this.idleMonitor.add_user_active_watch(Lang.bind(this, this._onIdleMonitorBecameActive));
|
2012-08-20 04:06:50 +00:00
|
|
|
}
|
|
|
|
|
2015-02-21 20:41:18 +00:00
|
|
|
this._banner = this._notification.createBanner();
|
2015-02-17 02:13:56 +00:00
|
|
|
this._bannerClickedId = this._banner.connect('done-displaying',
|
|
|
|
Lang.bind(this, this._escapeTray));
|
|
|
|
this._bannerUnfocusedId = this._banner.connect('unfocused', Lang.bind(this, function() {
|
2012-09-05 16:59:50 +00:00
|
|
|
this._updateState();
|
|
|
|
}));
|
2015-02-17 02:13:56 +00:00
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
this._bannerBin.add_actor(this._banner.actor);
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
this._bannerBin._opacity = 0;
|
|
|
|
this._bannerBin.opacity = 0;
|
|
|
|
this._bannerBin.y = -this._banner.actor.height;
|
2015-02-11 17:04:22 +00:00
|
|
|
this.actor.show();
|
2010-01-13 20:05:20 +00:00
|
|
|
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
this._updateShowingNotification();
|
2010-04-29 19:06:51 +00:00
|
|
|
|
|
|
|
let [x, y, mods] = global.get_pointer();
|
2010-08-31 19:50:18 +00:00
|
|
|
// We save the position of the mouse at the time when we started showing the notification
|
|
|
|
// in order to determine if the notification popped up under it. We make that check if
|
2013-03-13 20:14:53 +00:00
|
|
|
// the user starts moving the mouse and _onNotificationHoverChanged() gets called. We don't
|
2010-08-31 19:50:18 +00:00
|
|
|
// expand the notification if it just happened to pop up under the mouse unless the user
|
|
|
|
// explicitly mouses away from it and then mouses back in.
|
|
|
|
this._showNotificationMouseX = x;
|
|
|
|
this._showNotificationMouseY = y;
|
2012-09-03 16:29:39 +00:00
|
|
|
// We save the coordinates of the mouse at the time when we started showing the notification
|
|
|
|
// and then we update it in _notificationTimeout(). We don't pop down the notification if
|
|
|
|
// the mouse is moving towards it or within it.
|
|
|
|
this._lastSeenMouseX = x;
|
2010-04-29 19:06:51 +00:00
|
|
|
this._lastSeenMouseY = y;
|
2014-06-02 17:28:18 +00:00
|
|
|
|
|
|
|
this._resetNotificationLeftTimeout();
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
},
|
|
|
|
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
_updateShowingNotification: function() {
|
2012-08-06 15:28:55 +00:00
|
|
|
this._notification.acknowledged = true;
|
2012-11-05 17:10:24 +00:00
|
|
|
this._notification.playSound();
|
2012-08-06 15:28:55 +00:00
|
|
|
|
2012-10-16 15:08:54 +00:00
|
|
|
// We auto-expand notifications with CRITICAL urgency, or for which the relevant setting
|
|
|
|
// is on in the control center.
|
|
|
|
if (this._notification.urgency == Urgency.CRITICAL ||
|
|
|
|
this._notification.source.policy.forceExpanded)
|
2015-02-17 02:13:56 +00:00
|
|
|
this._expandBanner(true);
|
2011-01-13 01:05:36 +00:00
|
|
|
|
|
|
|
// We tween all notifications to full opacity. This ensures that both new notifications and
|
|
|
|
// notifications that might have been in the process of hiding get full opacity.
|
|
|
|
//
|
2012-11-30 15:05:38 +00:00
|
|
|
// We tween any notification showing in the banner mode to the appropriate height
|
|
|
|
// (which is banner height or expanded height, depending on the notification state)
|
2011-01-13 01:05:36 +00:00
|
|
|
// This ensures that both new notifications and notifications in the banner mode that might
|
2012-11-30 15:05:38 +00:00
|
|
|
// have been in the process of hiding are shown with the correct height.
|
2011-01-13 01:05:36 +00:00
|
|
|
//
|
|
|
|
// We use this._showNotificationCompleted() onComplete callback to extend the time the updated
|
|
|
|
// notification is being shown.
|
2012-11-30 15:05:38 +00:00
|
|
|
|
2015-02-19 10:08:39 +00:00
|
|
|
let tweenParams = { y: 0,
|
|
|
|
_opacity: 255,
|
2011-01-13 01:05:36 +00:00
|
|
|
time: ANIMATION_TIME,
|
2015-02-19 10:08:39 +00:00
|
|
|
transition: 'easeOutBack',
|
|
|
|
onUpdate: this._clampOpacity,
|
|
|
|
onUpdateScope: this,
|
2011-01-13 01:05:36 +00:00
|
|
|
onComplete: this._showNotificationCompleted,
|
|
|
|
onCompleteScope: this
|
|
|
|
};
|
|
|
|
|
2015-02-25 16:43:54 +00:00
|
|
|
this._tween(this._bannerBin, '_notificationState', State.SHOWN, tweenParams);
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
},
|
|
|
|
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
_showNotificationCompleted: function() {
|
2011-01-11 21:33:03 +00:00
|
|
|
if (this._notification.urgency != Urgency.CRITICAL)
|
|
|
|
this._updateNotificationTimeout(NOTIFICATION_TIMEOUT * 1000);
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_updateNotificationTimeout: function(timeout) {
|
|
|
|
if (this._notificationTimeoutId) {
|
|
|
|
Mainloop.source_remove(this._notificationTimeoutId);
|
|
|
|
this._notificationTimeoutId = 0;
|
|
|
|
}
|
2014-04-10 17:26:52 +00:00
|
|
|
if (timeout > 0) {
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
this._notificationTimeoutId =
|
|
|
|
Mainloop.timeout_add(timeout,
|
|
|
|
Lang.bind(this, this._notificationTimeout));
|
2014-04-10 17:26:52 +00:00
|
|
|
GLib.Source.set_name_by_id(this._notificationTimeoutId, '[gnome-shell] this._notificationTimeout');
|
|
|
|
}
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
_notificationTimeout: function() {
|
2010-04-29 19:06:51 +00:00
|
|
|
let [x, y, mods] = global.get_pointer();
|
2015-02-19 10:08:39 +00:00
|
|
|
if (y < this._lastSeenMouseY - 10 && !this._notificationHovered) {
|
2010-04-29 19:06:51 +00:00
|
|
|
// The mouse is moving towards the notification, so don't
|
|
|
|
// hide it yet. (We just create a new timeout (and destroy
|
|
|
|
// the old one) each time because the bookkeeping is
|
|
|
|
// simpler.)
|
2012-09-03 16:29:39 +00:00
|
|
|
this._updateNotificationTimeout(1000);
|
2013-03-13 20:14:53 +00:00
|
|
|
} else if (this._useLongerNotificationLeftTimeout && !this._notificationLeftTimeoutId &&
|
2012-09-03 16:29:39 +00:00
|
|
|
(x != this._lastSeenMouseX || y != this._lastSeenMouseY)) {
|
|
|
|
// Refresh the timeout if the notification originally
|
|
|
|
// popped up under the pointer, and the pointer is hovering
|
|
|
|
// inside it.
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
this._updateNotificationTimeout(1000);
|
2010-04-29 19:06:51 +00:00
|
|
|
} else {
|
|
|
|
this._notificationTimeoutId = 0;
|
|
|
|
this._updateState();
|
|
|
|
}
|
|
|
|
|
2012-09-03 16:29:39 +00:00
|
|
|
this._lastSeenMouseX = x;
|
|
|
|
this._lastSeenMouseY = y;
|
2013-11-29 00:45:39 +00:00
|
|
|
return GLib.SOURCE_REMOVE;
|
2010-01-28 18:39:00 +00:00
|
|
|
},
|
2010-01-13 20:05:20 +00:00
|
|
|
|
2013-08-02 02:53:21 +00:00
|
|
|
_hideNotification: function(animate) {
|
2013-05-23 21:11:40 +00:00
|
|
|
this._notificationFocusGrabber.ungrabFocus();
|
2012-02-28 20:04:00 +00:00
|
|
|
|
2015-02-17 02:13:56 +00:00
|
|
|
if (this._bannerClickedId) {
|
|
|
|
this._banner.disconnect(this._bannerClickedId);
|
|
|
|
this._bannerClickedId = 0;
|
2013-01-28 11:09:17 +00:00
|
|
|
}
|
2015-02-17 02:13:56 +00:00
|
|
|
if (this._bannerUnfocusedId) {
|
|
|
|
this._banner.disconnect(this._bannerUnfocusedId);
|
|
|
|
this._bannerUnfocusedId = 0;
|
2013-01-28 11:09:17 +00:00
|
|
|
}
|
2010-02-22 19:23:36 +00:00
|
|
|
|
2014-05-28 19:18:00 +00:00
|
|
|
this._resetNotificationLeftTimeout();
|
2013-03-06 08:30:17 +00:00
|
|
|
|
2013-08-02 02:53:21 +00:00
|
|
|
if (animate) {
|
2015-02-25 16:43:54 +00:00
|
|
|
this._tween(this._bannerBin, '_notificationState', State.HIDDEN,
|
|
|
|
{ y: -this._bannerBin.height,
|
2015-02-19 10:08:39 +00:00
|
|
|
_opacity: 0,
|
2012-08-19 22:21:50 +00:00
|
|
|
time: ANIMATION_TIME,
|
2015-02-19 10:08:39 +00:00
|
|
|
transition: 'easeOutBack',
|
|
|
|
onUpdate: this._clampOpacity,
|
|
|
|
onUpdateScope: this,
|
2012-08-19 22:21:50 +00:00
|
|
|
onComplete: this._hideNotificationCompleted,
|
|
|
|
onCompleteScope: this
|
|
|
|
});
|
2013-08-02 02:53:21 +00:00
|
|
|
} else {
|
2015-02-25 16:43:54 +00:00
|
|
|
Tweener.removeTweens(this._bannerBin);
|
|
|
|
this._bannerBin.y = -this._bannerBin.height;
|
|
|
|
this._bannerBin.opacity = 0;
|
2013-08-02 02:53:21 +00:00
|
|
|
this._notificationState = State.HIDDEN;
|
|
|
|
this._hideNotificationCompleted();
|
2012-08-19 22:21:50 +00:00
|
|
|
}
|
2010-01-28 18:39:00 +00:00
|
|
|
},
|
2010-01-13 20:05:20 +00:00
|
|
|
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
_hideNotificationCompleted: function() {
|
2010-12-15 21:30:50 +00:00
|
|
|
let notification = this._notification;
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
this._notification = null;
|
2010-12-15 21:30:50 +00:00
|
|
|
if (notification.isTransient)
|
2011-01-27 23:26:53 +00:00
|
|
|
notification.destroy(NotificationDestroyedReason.EXPIRED);
|
2012-12-22 15:02:19 +00:00
|
|
|
|
2013-03-13 20:14:53 +00:00
|
|
|
this._pointerInNotification = false;
|
|
|
|
this._notificationRemoved = false;
|
2015-02-17 02:13:56 +00:00
|
|
|
|
2015-03-11 16:25:25 +00:00
|
|
|
this._banner.actor.destroy();
|
2015-02-17 02:13:56 +00:00
|
|
|
this._banner = null;
|
2015-02-11 17:04:22 +00:00
|
|
|
this.actor.hide();
|
[MessageTray] reimplement the state machine
Previously, every time _updateState was called, it would make some
change, and so it was necessary to very carefully set up all the calls
to it, to ensure it was always called at exactly the right time. Now,
instead, we keep a bunch of state variables like "_notificationState"
and "_pointerInSummary", and potentially multiple timeouts, and
_updateState looks at all of them and figure out what, if anything,
needs to be changed.
By making the rules about what causes changes more explicit, it will
be easier to change those rules in the future as we add new
functionality.
Also, update the rules a bit, so that notifications can appear while
the summary is visible, and the summary only shows after a
notification if the summary has changed.
https://bugzilla.gnome.org/show_bug.cgi?id=609765
2010-02-11 20:31:12 +00:00
|
|
|
},
|
|
|
|
|
2012-11-08 14:24:40 +00:00
|
|
|
_expandActiveNotification: function() {
|
2015-02-17 02:13:56 +00:00
|
|
|
if (!this._banner)
|
2012-11-08 14:24:40 +00:00
|
|
|
return;
|
|
|
|
|
2015-02-17 02:13:56 +00:00
|
|
|
this._expandBanner(false);
|
2012-11-08 14:24:40 +00:00
|
|
|
},
|
|
|
|
|
2015-02-17 02:13:56 +00:00
|
|
|
_expandBanner: function(autoExpanding) {
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
// Don't animate changes in notifications that are auto-expanding.
|
2015-02-17 02:13:56 +00:00
|
|
|
this._banner.expand(!autoExpanding);
|
2013-06-21 19:24:50 +00:00
|
|
|
|
|
|
|
// Don't focus notifications that are auto-expanding.
|
|
|
|
if (!autoExpanding)
|
2015-02-17 02:13:56 +00:00
|
|
|
this._ensureBannerFocused();
|
Fix various details of how notifications are shown
This patch ensures the following notifications behavior:
- Urgent notifications that have long title or banner text are auto-expanded
correctly.
- Single-line notifications that have _expandNotification() called (e.g.
because the user mouses over to them), are treated as expanded, which means
they get fully expanded if they are updated with more content and the user
can escape them.
- The position of expanded notifications is updated when they are updated.
- Notification banner is shown again on the first line if it can fully fit
there after a notification is updated, even if it was previously hidden
because the notification was expanded and the old banner did not fully fit.
- New notifications are immediately hidden if the user mouses away from them.
- If a new notification is updated while it is shown, we extend the time it
will be shown.
- If a new notification is updated while it is hiding, we stop hiding it and
show it again.
- If a summary notification is updated while it is hiding, we let it finish
hiding and show a new notification with the updated information.
Implementation details:
- Single-line notifications now have 4px bottom padding instead of 8px, which
means that their height matches the tray height, they are fully shown in the
banner mode, and don't pop out by 4px when the notification is expanded.
- Notification keeps a flag that indicates whether it is expanded, updates
its expanded look when it is updated, and emits an 'expanded' signal
indicating that its layout has possibly changed. The message tray connects
to this 'expanded' signal when it is showing a notification in the expanded
state and updates the position of the notification accordingly when this
signal is received so that the notification is fully shown. This is better
than connecting to 'notify::height' signal on the notification bin, since
it results in fewer callbacks.
https://bugzilla.gnome.org/show_bug.cgi?id=617209
2010-09-10 19:47:12 +00:00
|
|
|
},
|
|
|
|
|
2015-02-17 02:13:56 +00:00
|
|
|
_ensureBannerFocused: function() {
|
2013-05-23 21:11:40 +00:00
|
|
|
this._notificationFocusGrabber.grabFocus();
|
2010-01-28 18:39:00 +00:00
|
|
|
}
|
2011-11-20 17:56:27 +00:00
|
|
|
});
|
2012-05-22 22:02:00 +00:00
|
|
|
Signals.addSignalMethods(MessageTray.prototype);
|
2010-11-30 15:47:28 +00:00
|
|
|
|
2011-11-20 15:12:02 +00:00
|
|
|
const SystemNotificationSource = new Lang.Class({
|
|
|
|
Name: 'SystemNotificationSource',
|
|
|
|
Extends: Source,
|
2010-11-30 15:47:28 +00:00
|
|
|
|
|
|
|
_init: function() {
|
2012-05-30 13:58:37 +00:00
|
|
|
this.parent(_("System Information"), 'dialog-information-symbolic');
|
2010-11-30 15:47:28 +00:00
|
|
|
},
|
|
|
|
|
2011-02-11 19:43:01 +00:00
|
|
|
open: function() {
|
2010-11-30 15:47:28 +00:00
|
|
|
this.destroy();
|
|
|
|
}
|
2011-11-20 15:12:02 +00:00
|
|
|
});
|