Skip to content

Commit 9dfc48f

Browse files
alexdimaalexdima
committed
Clean up some base/browser files
1 parent 70297de commit 9dfc48f

7 files changed

Lines changed: 142 additions & 329 deletions

File tree

‎src/vs/base/browser/globalMouseMoveMonitor.ts‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,10 @@
44
*--------------------------------------------------------------------------------------------*/
55
'use strict';
66

7-
import Lifecycle = require('vs/base/common/lifecycle');
8-
import DomUtils = require('vs/base/browser/dom');
9-
import Mouse = require('vs/base/browser/mouseEvent');
10-
import IframeUtils = require('vs/base/browser/iframe');
7+
import * as DomUtils from 'vs/base/browser/dom';
8+
import {IDisposable, disposeAll} from 'vs/base/common/lifecycle';
9+
import {StandardMouseEvent} from 'vs/base/browser/mouseEvent';
10+
import {IframeUtils} from 'vs/base/browser/iframe';
1111

1212
export interface IStandardMouseMoveEventData {
1313
leftButton:boolean;
@@ -28,7 +28,7 @@ export interface IOnStopCallback {
2828
}
2929

3030
export function standardMouseMoveMerger(lastEvent:IStandardMouseMoveEventData, currentEvent:MouseEvent):IStandardMouseMoveEventData {
31-
var ev = new Mouse.StandardMouseEvent(currentEvent);
31+
let ev = new StandardMouseEvent(currentEvent);
3232
ev.preventDefault();
3333
return {
3434
leftButton: ev.leftButton,
@@ -37,9 +37,9 @@ export function standardMouseMoveMerger(lastEvent:IStandardMouseMoveEventData, c
3737
};
3838
}
3939

40-
export class GlobalMouseMoveMonitor<R> implements Lifecycle.IDisposable {
40+
export class GlobalMouseMoveMonitor<R> implements IDisposable {
4141

42-
private hooks:Lifecycle.IDisposable[];
42+
private hooks:IDisposable[];
4343
private mouseMoveEventMerger:IEventMerger<R>;
4444
private mouseMoveCallback:IMouseMoveCallback<R>;
4545
private onStopCallback:IOnStopCallback;
@@ -62,10 +62,10 @@ export class GlobalMouseMoveMonitor<R> implements Lifecycle.IDisposable {
6262
}
6363

6464
// Unhook
65-
this.hooks = Lifecycle.disposeAll(this.hooks);
65+
this.hooks = disposeAll(this.hooks);
6666
this.mouseMoveEventMerger = null;
6767
this.mouseMoveCallback = null;
68-
var onStopCallback = this.onStopCallback;
68+
let onStopCallback = this.onStopCallback;
6969
this.onStopCallback = null;
7070

7171
if (invokeStopCallback) {
@@ -90,28 +90,28 @@ export class GlobalMouseMoveMonitor<R> implements Lifecycle.IDisposable {
9090
this.mouseMoveCallback = mouseMoveCallback;
9191
this.onStopCallback = onStopCallback;
9292

93-
var windowChain = IframeUtils.getSameOriginWindowChain();
94-
for (var i = 0; i < windowChain.length; i++) {
95-
this.hooks.push(DomUtils.addDisposableThrottledListener(windowChain[i].window.document, 'mousemove',
93+
let windowChain = IframeUtils.getSameOriginWindowChain();
94+
for (let i = 0; i < windowChain.length; i++) {
95+
this.hooks.push(DomUtils.addDisposableThrottledListener(windowChain[i].window.document, 'mousemove',
9696
(data:R) => this.mouseMoveCallback(data),
9797
(lastEvent:R, currentEvent:MouseEvent) => this.mouseMoveEventMerger(lastEvent, currentEvent)
9898
));
9999
this.hooks.push(DomUtils.addDisposableListener(windowChain[i].window.document, 'mouseup', (e:MouseEvent) => this.stopMonitoring(true)));
100100
}
101101

102102
if (IframeUtils.hasDifferentOriginAncestor()) {
103-
var lastSameOriginAncestor = windowChain[windowChain.length - 1];
103+
let lastSameOriginAncestor = windowChain[windowChain.length - 1];
104104
// We might miss a mouse up if it happens outside the iframe
105105
// This one is for Chrome
106106
this.hooks.push(DomUtils.addDisposableListener(lastSameOriginAncestor.window.document, 'mouseout', (browserEvent:MouseEvent) => {
107-
var e = new Mouse.StandardMouseEvent(browserEvent);
107+
let e = new StandardMouseEvent(browserEvent);
108108
if (e.target.tagName.toLowerCase() === 'html') {
109109
this.stopMonitoring(true);
110110
}
111111
}));
112112
// This one is for FF
113113
this.hooks.push(DomUtils.addDisposableListener(lastSameOriginAncestor.window.document, 'mouseover', (browserEvent:MouseEvent) => {
114-
var e = new Mouse.StandardMouseEvent(browserEvent);
114+
let e = new StandardMouseEvent(browserEvent);
115115
if (e.target.tagName.toLowerCase() === 'html') {
116116
this.stopMonitoring(true);
117117
}
@@ -122,4 +122,4 @@ export class GlobalMouseMoveMonitor<R> implements Lifecycle.IDisposable {
122122
}));
123123
}
124124
}
125-
}
125+
}

‎src/vs/base/browser/idleMonitor.ts‎

Lines changed: 46 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,11 @@
44
*--------------------------------------------------------------------------------------------*/
55
'use strict';
66

7-
import DomUtils = require('vs/base/browser/dom');
8-
import {IDisposable, disposeAll} from 'vs/base/common/lifecycle';
7+
import * as DomUtils from 'vs/base/browser/dom';
8+
import {Disposable, IDisposable, disposeAll} from 'vs/base/common/lifecycle';
99
import {EventEmitter, ListenerUnbind} from 'vs/base/common/eventEmitter';
1010
import {getService} from 'vs/base/browser/browserService';
11+
import {TimeoutTimer} from 'vs/base/common/async';
1112

1213
export enum UserStatus {
1314
Idle,
@@ -16,151 +17,73 @@ export enum UserStatus {
1617

1718
export const DEFAULT_IDLE_TIME = 60 * 60 * 1000; // 60 minutes
1819

19-
export class IdleMonitor {
20+
export class IdleMonitor extends Disposable {
2021

21-
private toDispose: IDisposable[];
22-
private lastActiveTime: number;
23-
private idleCheckTimeout: number;
24-
private status: UserStatus;
25-
private eventEmitter: EventEmitter;
26-
private instance: ReferenceCountedIdleMonitor;
27-
private idleTime: number;
22+
private _lastActiveTime: number;
23+
private _idleCheckTimeout: TimeoutTimer;
24+
private _status: UserStatus;
25+
private _eventEmitter: EventEmitter;
26+
private _idleTime: number;
2827

2928
constructor(idleTime: number = DEFAULT_IDLE_TIME) {
30-
this.instance = ReferenceCountedIdleMonitor.INSTANCE;
31-
this.instance.increment();
32-
33-
this.status = null;
34-
this.idleCheckTimeout = -1;
35-
this.lastActiveTime = -1;
36-
this.idleTime = idleTime;
37-
38-
this.toDispose = [];
39-
this.eventEmitter = new EventEmitter();
40-
this.toDispose.push(this.eventEmitter);
41-
this.toDispose.push({ dispose: this.instance.addListener(() => this.onUserActive()) });
42-
this.onUserActive();
43-
}
29+
super();
4430

45-
public addOneTimeActiveListener(callback: () => void): IDisposable {
46-
return this.eventEmitter.addOneTimeDisposableListener('onActive', callback);
47-
}
48-
49-
public addOneTimeIdleListener(callback: () => void): IDisposable {
50-
return this.eventEmitter.addOneTimeDisposableListener('onIdle', callback);
51-
}
31+
this._status = null;
32+
this._idleCheckTimeout = this._register(new TimeoutTimer());
33+
this._lastActiveTime = -1;
34+
this._idleTime = idleTime;
5235

53-
public getStatus(): UserStatus {
54-
return this.status;
36+
this._eventEmitter = this._register(new EventEmitter());
37+
this._register(DomUtils.addDisposableListener(getService().document, 'mousemove', () => this._onUserActive()));
38+
this._register(DomUtils.addDisposableListener(getService().document, 'keydown', () => this._onUserActive()));
39+
this._onUserActive();
5540
}
5641

5742
public dispose(): void {
58-
this.cancelIdleCheck();
59-
this.toDispose = disposeAll(this.toDispose);
60-
this.instance.decrement();
43+
super.dispose();
6144
}
6245

63-
private onUserActive(): void {
64-
this.lastActiveTime = (new Date()).getTime();
65-
if (this.status !== UserStatus.Active) {
66-
this.status = UserStatus.Active;
67-
this.scheduleIdleCheck();
68-
this.eventEmitter.emit('onActive');
69-
}
46+
public addOneTimeActiveListener(callback: () => void): IDisposable {
47+
return this._eventEmitter.addOneTimeDisposableListener('onActive', callback);
7048
}
7149

72-
private onUserIdle(): void {
73-
if (this.status !== UserStatus.Idle) {
74-
this.status = UserStatus.Idle;
75-
this.eventEmitter.emit('onIdle');
76-
}
50+
public addOneTimeIdleListener(callback: () => void): IDisposable {
51+
return this._eventEmitter.addOneTimeDisposableListener('onIdle', callback);
7752
}
7853

79-
private scheduleIdleCheck(): void {
80-
if (this.idleCheckTimeout === -1) {
81-
let minimumTimeWhenUserCanBecomeIdle = this.lastActiveTime + this.idleTime;
82-
this.idleCheckTimeout = setTimeout(() => {
83-
this.idleCheckTimeout = -1;
84-
this.checkIfUserIsIdle();
85-
}, minimumTimeWhenUserCanBecomeIdle - (new Date()).getTime());
86-
}
54+
public getStatus(): UserStatus {
55+
return this._status;
8756
}
8857

89-
private cancelIdleCheck(): void {
90-
if (this.idleCheckTimeout !== -1) {
91-
clearTimeout(this.idleCheckTimeout);
92-
this.idleCheckTimeout = -1;
58+
private _onUserActive(): void {
59+
this._lastActiveTime = (new Date()).getTime();
60+
if (this._status !== UserStatus.Active) {
61+
this._status = UserStatus.Active;
62+
this._scheduleIdleCheck();
63+
this._eventEmitter.emit('onActive');
9364
}
9465
}
9566

96-
private checkIfUserIsIdle(): void {
97-
let actualIdleTime = (new Date()).getTime() - this.lastActiveTime;
98-
if (actualIdleTime >= this.idleTime) {
99-
this.onUserIdle();
100-
} else {
101-
this.scheduleIdleCheck();
67+
private _onUserIdle(): void {
68+
if (this._status !== UserStatus.Idle) {
69+
this._status = UserStatus.Idle;
70+
this._eventEmitter.emit('onIdle');
10271
}
10372
}
104-
}
105-
106-
class ReferenceCountedObject {
107-
108-
private referenceCount: number;
109-
110-
constructor() {
111-
this.referenceCount = 0;
112-
}
11373

114-
public increment(): void {
115-
if (this.referenceCount === 0) {
116-
this.construct();
117-
}
118-
this.referenceCount++;
74+
private _scheduleIdleCheck(): void {
75+
let minimumTimeWhenUserCanBecomeIdle = this._lastActiveTime + this._idleTime;
76+
this._idleCheckTimeout.setIfNotSet(() => {
77+
this._checkIfUserIsIdle();
78+
}, minimumTimeWhenUserCanBecomeIdle - (new Date()).getTime());
11979
}
12080

121-
public decrement(): void {
122-
if (this.referenceCount > 0) {
123-
this.referenceCount--;
124-
if (this.referenceCount === 0) {
125-
this.dispose();
126-
}
81+
private _checkIfUserIsIdle(): void {
82+
let actualIdleTime = (new Date()).getTime() - this._lastActiveTime;
83+
if (actualIdleTime >= this._idleTime) {
84+
this._onUserIdle();
85+
} else {
86+
this._scheduleIdleCheck();
12787
}
12888
}
129-
130-
public construct(): void {
131-
throw new Error('Implement me');
132-
}
133-
134-
public dispose(): void {
135-
throw new Error('Implement me');
136-
}
13789
}
138-
139-
class ReferenceCountedIdleMonitor extends ReferenceCountedObject {
140-
141-
public static INSTANCE: ReferenceCountedIdleMonitor = new ReferenceCountedIdleMonitor();
142-
143-
private toDispose: IDisposable[];
144-
private eventEmitter: EventEmitter;
145-
146-
public construct(): void {
147-
this.toDispose = [];
148-
this.eventEmitter = new EventEmitter();
149-
this.toDispose.push(this.eventEmitter);
150-
this.toDispose.push(DomUtils.addDisposableListener(getService().document, 'mousemove', () => this.onUserActive()));
151-
this.toDispose.push(DomUtils.addDisposableListener(getService().document, 'keydown', () => this.onUserActive()));
152-
this.onUserActive();
153-
}
154-
155-
public dispose(): void {
156-
this.toDispose = disposeAll(this.toDispose);
157-
}
158-
159-
private onUserActive(): void {
160-
this.eventEmitter.emit('onActive');
161-
}
162-
163-
public addListener(callback: () => void): ListenerUnbind {
164-
return this.eventEmitter.addListener('onActive', callback);
165-
}
166-
}

0 commit comments

Comments
 (0)