brl/gnome-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace cursor position monitoring with MetaCursorTracker

Browse Source 
I was tired of seeing 1s updates in shell recording videos when seeing
them on Planet GNOME, so here you go.
This commit is contained in:
Jasper St. Pierre 2017-02-23 11:13:36 -08:00
parent ef18b7ea25
commit 8c9aa2efd9
2 changed files with 14 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
js/ui/pointerWatcher.js
View File

@ -7,13 +7,6 @@ const Meta = imports.gi.Meta;
const GnomeDesktop = imports.gi.GnomeDesktop;
const Shell = imports.gi.Shell;
// We stop polling if the user is idle for more than this amount of time
const IDLE_TIME = 1000;
// This file implements a reasonably efficient system for tracking the position
// of the mouse pointer. We simply query the pointer from the X server in a loop,
// but we turn off the polling when the user is idle.
let _pointerWatcher = null;
function getPointerWatcher() {
if (_pointerWatcher == null)
@ -25,9 +18,8 @@ function getPointerWatcher() {
const PointerWatch = new Lang.Class({
Name: 'PointerWatch',
_init: function(watcher, interval, callback) {
_init: function(watcher, callback) {
this.watcher = watcher;
this.interval = interval;
this.callback = callback;
},
@ -43,9 +35,9 @@ const PointerWatcher = new Lang.Class({
Name: 'PointerWatcher',
_init: function() {
this._idleMonitor = Meta.IdleMonitor.get_core();
this._idleMonitor.add_idle_watch(IDLE_TIME, Lang.bind(this, this._onIdleMonitorBecameIdle));
this._idle = this._idleMonitor.get_idletime() > IDLE_TIME;
this._cursorTracker = Meta.CursorTracker.get_for_screen(global.screen);
this._cursorTracker.connect('position-changed', Lang.bind(this, this._updatePointer));
this._watches = [];
this.pointerX = null;
this.pointerY = null;
@ -61,60 +53,25 @@ const PointerWatcher = new Lang.Class({
// Set up a watch on the position of the mouse pointer. Returns a
// PointerWatch object which has a remove() method to remove the watch.
addWatch: function(interval, callback) {
this._cursorTracker.enable_track_position();
// Avoid unreliably calling the watch for the current position
this._updatePointer();
let watch = new PointerWatch(this, interval, callback);
this._watches.push(watch);
this._updateTimeout();
this._watches.push(callback);
return watch;
},
_removeWatch: function(watch) {
for (let i = 0; i < this._watches.length; i++) {
if (this._watches[i] == watch) {
this._cursorTracker.disable_track_position();
this._watches.splice(i, 1);
this._updateTimeout();
return;
}
}
},
_onIdleMonitorBecameActive: function(monitor) {
this._idle = false;
this._updatePointer();
this._updateTimeout();
},
_onIdleMonitorBecameIdle: function(monitor) {
this._idle = true;
this._idleMonitor.add_user_active_watch(Lang.bind(this, this._onIdleMonitorBecameActive));
this._updateTimeout();
},
_updateTimeout: function() {
if (this._timeoutId) {
Mainloop.source_remove(this._timeoutId);
this._timeoutId = 0;
}
if (this._idle || this._watches.length == 0)
return;
let minInterval = this._watches[0].interval;
for (let i = 1; i < this._watches.length; i++)
minInterval = Math.min(this._watches[i].interval, minInterval);
this._timeoutId = Mainloop.timeout_add(minInterval,
Lang.bind(this, this._onTimeout));
GLib.Source.set_name_by_id(this._timeoutId, '[gnome-shell] this._onTimeout');
},
_onTimeout: function() {
this._updatePointer();
return GLib.SOURCE_CONTINUE;
},
_updatePointer: function() {
let [x, y, mods] = global.get_pointer();
if (this.pointerX == x && this.pointerY == y)

45
src/shell-recorder.c
View File

@ -80,7 +80,6 @@ struct _ShellRecorder {
guint redraw_timeout;
guint redraw_idle;
guint update_memory_used_timeout;
guint update_pointer_timeout;
guint repaint_hook_id;
};
@ -126,11 +125,6 @@ G_DEFINE_TYPE(ShellRecorder, shell_recorder, G_TYPE_OBJECT);
*/
#define DEFAULT_FRAMES_PER_SECOND 30
/* The time (in milliseconds) between querying the server for the cursor
* position.
*/
#define UPDATE_POINTER_TIME 100
/* The time we wait (in milliseconds) before redrawing when the memory used
* changes.
*/
@ -537,7 +531,8 @@ on_cursor_changed (MetaCursorTracker *tracker,
}
static void
recorder_update_pointer (ShellRecorder *recorder)
on_cursor_position_changed (MetaCursorTracker *tracker,
ShellRecorder *recorder)
{
int pointer_x, pointer_y;
@ -551,36 +546,6 @@ recorder_update_pointer (ShellRecorder *recorder)
}
}
static gboolean
recorder_update_pointer_timeout (gpointer data)
{
recorder_update_pointer (data);
return TRUE;
}
static void
recorder_add_update_pointer_timeout (ShellRecorder *recorder)
{
if (!recorder->update_pointer_timeout)
{
recorder->update_pointer_timeout = g_timeout_add (UPDATE_POINTER_TIME,
recorder_update_pointer_timeout,
recorder);
g_source_set_name_by_id (recorder->update_pointer_timeout, "[gnome-shell] recorder_update_pointer_timeout");
}
}
static void
recorder_remove_update_pointer_timeout (ShellRecorder *recorder)
{
if (recorder->update_pointer_timeout)
{
g_source_remove (recorder->update_pointer_timeout);
recorder->update_pointer_timeout = 0;
}
}
static void
recorder_connect_stage_callbacks (ShellRecorder *recorder)
{
@ -652,6 +617,8 @@ recorder_set_screen (ShellRecorder *recorder,
recorder->cursor_tracker = tracker;
g_signal_connect_object (tracker, "cursor-changed",
G_CALLBACK (on_cursor_changed), recorder, 0);
g_signal_connect_object (tracker, "position-changed",
G_CALLBACK (on_cursor_position_changed), recorder, 0);
}
static void
@ -1514,7 +1481,7 @@ shell_recorder_record (ShellRecorder *recorder,
recorder->state = RECORDER_STATE_RECORDING;
recorder_update_pointer (recorder);
recorder_add_update_pointer_timeout (recorder);
meta_cursor_tracker_enable_track_position (recorder->cursor_tracker);
/* Disable unredirection while we are recoring */
meta_disable_unredirect_for_screen (shell_global_get_screen (shell_global_get ()));
@ -1553,7 +1520,7 @@ shell_recorder_close (ShellRecorder *recorder)
*/
clutter_actor_paint (CLUTTER_ACTOR (recorder->stage));
recorder_remove_update_pointer_timeout (recorder);
meta_cursor_tracker_disable_track_position (recorder->cursor_tracker);
recorder_close_pipeline (recorder);
/* Queue a redraw to remove the recording indicator */