ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2024-12-19 05:07:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #402 from nasa/open209

Browse Source 
[Clocks/Timers] Update code style
This commit is contained in:
akhenry 2016-01-06 14:07:15 -08:00
commit 9cc03123b1
9 changed files with 236 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
platform/features/clock/src/actions/AbstractStartTimerAction.js
View File

@ -35,10 +35,21 @@ define(
* Both "Start" and "Restart" share this implementation, but
* control their visibility with different `appliesTo` behavior.
*
* @implements Action
* @implements {Action}
* @memberof platform/features/clock
* @constructor
* @param {Function} now a function which returns the current
* time (typically wrapping `Date.now`)
* @param {ActionContext} context the context for this action
*/
function AbstractStartTimerAction(now, context) {
var domainObject = context.domainObject;
this.domainObject = context.domainObject;
this.now = now;
}
AbstractStartTimerAction.prototype.perform = function () {
var domainObject = this.domainObject,
now = this.now;
function doPersist() {
var persistence = domainObject.getCapability('persistence');
@ -49,13 +60,9 @@ define(
model.timestamp = now();
}
return {
perform: function () {
return domainObject.useCapability('mutation', setTimestamp)
.then(doPersist);
}
};
}
return AbstractStartTimerAction;
}

14
platform/features/clock/src/actions/RestartTimerAction.js
View File

@ -31,12 +31,22 @@ define(
*
* Behaves the same as (and delegates functionality to)
* the "Start" action.
* @implements Action
*
* @extends {platform/features/clock.AbstractTimerAction}
* @implements {Action}
* @memberof platform/features/clock
* @constructor
* @param {Function} now a function which returns the current
* time (typically wrapping `Date.now`)
* @param {ActionContext} context the context for this action
*/
function RestartTimerAction(now, context) {
return new AbstractStartTimerAction(now, context);
AbstractStartTimerAction.apply(this, [ now, context ]);
}
RestartTimerAction.prototype =
Object.create(AbstractStartTimerAction.prototype);
RestartTimerAction.appliesTo = function (context) {
var model =
(context.domainObject && context.domainObject.getModel())

13
platform/features/clock/src/actions/StartTimerAction.js
View File

@ -32,12 +32,21 @@ define(
* Sets the reference timestamp in a timer to the current
* time, such that it begins counting up.
*
* @implements Action
* @extends {platform/features/clock.AbstractTimerAction}
* @implements {Action}
* @memberof platform/features/clock
* @constructor
* @param {Function} now a function which returns the current
* time (typically wrapping `Date.now`)
* @param {ActionContext} context the context for this action
*/
function StartTimerAction(now, context) {
return new AbstractStartTimerAction(now, context);
AbstractStartTimerAction.apply(this, [ now, context ]);
}
StartTimerAction.prototype =
Object.create(AbstractStartTimerAction.prototype);
StartTimerAction.appliesTo = function (context) {
var model =
(context.domainObject && context.domainObject.getModel())

40
platform/features/clock/src/controllers/ClockController.js
View File

@ -30,19 +30,21 @@ define(
* Controller for views of a Clock domain object.
*
* @constructor
* @memberof platform/features/clock
* @param {angular.Scope} $scope the Angular scope
* @param {platform/features/clock.TickerService} tickerService
* a service used to align behavior with clock ticks
*/
function ClockController($scope, tickerService) {
var text,
ampm,
use24,
lastTimestamp,
var lastTimestamp,
unlisten,
timeFormat;
timeFormat,
self = this;
function update() {
var m = moment.utc(lastTimestamp);
text = timeFormat && m.format(timeFormat);
ampm = m.format("A"); // Just the AM or PM part
self.textValue = timeFormat && m.format(timeFormat);
self.ampmValue = m.format("A"); // Just the AM or PM part
}
function tick(timestamp) {
@ -56,8 +58,8 @@ define(
if (clockFormat !== undefined) {
baseFormat = clockFormat[0];
use24 = clockFormat[1] === 'clock24';
timeFormat = use24 ?
self.use24 = clockFormat[1] === 'clock24';
timeFormat = self.use24 ?
baseFormat.replace('hh', "HH") : baseFormat;
update();
@ -69,31 +71,31 @@ define(
// Listen for clock ticks ... and stop listening on destroy
unlisten = tickerService.listen(tick);
$scope.$on('$destroy', unlisten);
}
return {
/**
* Get the clock's time zone, as displayable text.
* @returns {string}
*/
zone: function () {
ClockController.prototype.zone = function () {
return "UTC";
},
};
/**
* Get the current time, as displayable text.
* @returns {string}
*/
text: function () {
return text;
},
ClockController.prototype.text = function () {
return this.textValue;
};
/**
* Get the text to display to qualify a time as AM or PM.
* @returns {string}
*/
ampm: function () {
return use24 ? '' : ampm;
}
ClockController.prototype.ampm = function () {
return this.use24 ? '' : this.ampmValue;
};
}
return ClockController;
}

6
platform/features/clock/src/controllers/RefreshingController.js
View File

@ -31,6 +31,12 @@ define(
*
* This is a short-term workaround to assure Timer views stay
* up-to-date; should be replaced by a global auto-refresh.
*
* @constructor
* @memberof platform/features/clock
* @param {angular.Scope} $scope the Angular scope
* @param {platform/features/clock.TickerService} tickerService
* a service used to align behavior with clock ticks
*/
function RefreshingController($scope, tickerService) {
var unlisten;

77
platform/features/clock/src/controllers/TimerController.js
View File

@ -33,26 +33,30 @@ define(
* Controller for views of a Timer domain object.
*
* @constructor
* @memberof platform/features/clock
* @param {angular.Scope} $scope the Angular scope
* @param $window Angular-provided window object
* @param {Function} now a function which returns the current
* time (typically wrapping `Date.now`)
*/
function TimerController($scope, $window, now) {
var timerObject,
relevantAction,
sign = '',
text = '',
formatter,
active = true,
relativeTimestamp,
lastTimestamp;
lastTimestamp,
self = this;
function update() {
var timeDelta = lastTimestamp - relativeTimestamp;
if (formatter && !isNaN(timeDelta)) {
text = formatter(timeDelta);
sign = timeDelta < 0 ? "-" : timeDelta >= 1000 ? "+" : "";
self.textValue = formatter(timeDelta);
self.signValue = timeDelta < 0 ? "-" :
timeDelta >= 1000 ? "+" : "";
} else {
text = "";
sign = "";
self.textValue = "";
self.signValue = "";
}
}
@ -75,7 +79,7 @@ define(
updateFormat(formatKey);
updateTimestamp(timestamp);
relevantAction = actionCapability &&
self.relevantAction = actionCapability &&
actionCapability.getActions(actionKey)[0];
update();
@ -92,13 +96,14 @@ define(
}
function tick() {
var lastSign = sign, lastText = text;
var lastSign = self.signValue,
lastText = self.textValue;
lastTimestamp = now();
update();
// We're running in an animation frame, not in a digest cycle.
// We need to trigger a digest cycle if our displayable data
// changes.
if (lastSign !== sign || lastText !== text) {
if (lastSign !== self.signValue || lastText !== self.textValue) {
$scope.$apply();
}
if (active) {
@ -117,50 +122,58 @@ define(
active = false;
});
return {
this.$scope = $scope;
this.signValue = '';
this.textValue = '';
this.updateObject = updateObject;
}
/**
* Get the glyph to display for the start/restart button.
* @returns {string} glyph to display
*/
buttonGlyph: function () {
return relevantAction ?
relevantAction.getMetadata().glyph : "";
},
TimerController.prototype.buttonGlyph = function () {
return this.relevantAction ?
this.relevantAction.getMetadata().glyph : "";
};
/**
* Get the text to show for the start/restart button
* (e.g. in a tooltip)
* @returns {string} name of the action
*/
buttonText: function () {
return relevantAction ?
relevantAction.getMetadata().name : "";
},
TimerController.prototype.buttonText = function () {
return this.relevantAction ?
this.relevantAction.getMetadata().name : "";
};
/**
* Perform the action associated with the start/restart button.
*/
clickButton: function () {
if (relevantAction) {
relevantAction.perform();
updateObject($scope.domainObject);
TimerController.prototype.clickButton = function () {
if (this.relevantAction) {
this.relevantAction.perform();
this.updateObject(this.$scope.domainObject);
}
},
};
/**
* Get the sign (+ or -) of the current timer value, as
* displayable text.
* @returns {string} sign of the current timer value
*/
sign: function () {
return sign;
},
TimerController.prototype.sign = function () {
return this.signValue;
};
/**
* Get the text to display for the current timer value.
* @returns {string} current timer value
*/
text: function () {
return text;
}
TimerController.prototype.text = function () {
return this.textValue;
};
}
return TimerController;
}

26
platform/features/clock/src/controllers/TimerFormatter.js
View File

@ -37,8 +37,10 @@ define(
* supports `TimerController`.
*
* @constructor
* @memberof platform/features/clock
*/
function TimerFormatter() {
}
// Round this timestamp down to the second boundary
// (e.g. 1124ms goes down to 1000ms, -2400ms goes down to -3000ms)
@ -46,35 +48,27 @@ define(
return Math.abs(Math.floor(duration / 1000) * 1000);
}
// Short-form format, e.g. 02:22:11
function short(duration) {
return moment.duration(toWholeSeconds(duration), 'ms')
.format(SHORT_FORMAT, { trim: false });
}
// Long-form format, e.g. 3d 02:22:11
function long(duration) {
return moment.duration(toWholeSeconds(duration), 'ms')
.format(LONG_FORMAT, { trim: false });
}
return {
/**
* Format a duration for display, using the short form.
* (e.g. 03:33:11)
* @param {number} duration the duration, in milliseconds
* @param {boolean} sign true if positive
*/
short: short,
TimerFormatter.prototype.short = function (duration) {
return moment.duration(toWholeSeconds(duration), 'ms')
.format(SHORT_FORMAT, { trim: false });
};
/**
* Format a duration for display, using the long form.
* (e.g. 0d 03:33:11)
* @param {number} duration the duration, in milliseconds
* @param {boolean} sign true if positive
*/
long: long
TimerFormatter.prototype.long = function (duration) {
return moment.duration(toWholeSeconds(duration), 'ms')
.format(LONG_FORMAT, { trim: false });
};
}
return TimerFormatter;
}

44
platform/features/clock/src/indicators/ClockIndicator.js
View File

@ -28,31 +28,39 @@ define(
/**
* Indicator that displays the current UTC time in the status area.
* @implements Indicator
* @implements {Indicator}
* @memberof platform/features/clock
* @param {platform/features/clock.TickerService} tickerService
* a service used to align behavior with clock ticks
* @param {string} indicatorFormat format string for timestamps
* shown in this indicator
*/
function ClockIndicator(tickerService, CLOCK_INDICATOR_FORMAT) {
var text = "";
function ClockIndicator(tickerService, indicatorFormat) {
var self = this;
this.text = "";
tickerService.listen(function (timestamp) {
text = moment.utc(timestamp).format(CLOCK_INDICATOR_FORMAT) + " UTC";
self.text = moment.utc(timestamp)
.format(indicatorFormat) + " UTC";
});
return {
getGlyph: function () {
return "C";
},
getGlyphClass: function () {
return "no-icon no-collapse float-right subtle";
},
getText: function () {
return text;
},
getDescription: function () {
return "";
}
ClockIndicator.prototype.getGlyph = function () {
return "C";
};
}
ClockIndicator.prototype.getGlyphClass = function () {
return "no-icon no-collapse float-right subtle";
};
ClockIndicator.prototype.getText = function () {
return this.text;
};
ClockIndicator.prototype.getDescription = function () {
return "";
};
return ClockIndicator;
}

30
platform/features/clock/src/services/TickerService.js
View File

@ -30,23 +30,23 @@ define(
* Calls functions every second, as close to the actual second
* tick as is feasible.
* @constructor
* @memberof platform/features/clock
* @param $timeout Angular's $timeout
* @param {Function} now function to provide the current time in ms
*/
function TickerService($timeout, now) {
var callbacks = [],
last = now() - 1000;
var self = this;
function tick() {
var timestamp = now(),
millis = timestamp % 1000;
// Only update callbacks if a second has actually passed.
if (timestamp >= last + 1000) {
callbacks.forEach(function (callback) {
if (timestamp >= self.last + 1000) {
self.callbacks.forEach(function (callback) {
callback(timestamp);
});
last = timestamp - millis;
self.last = timestamp - millis;
}
// Try to update at exactly the next second
@ -55,35 +55,35 @@ define(
tick();
return {
this.callbacks = [];
this.last = now() - 1000;
}
/**
* Listen for clock ticks. The provided callback will
* be invoked with the current timestamp (in milliseconds
* since Jan 1 1970) at regular intervals, as near to the
* second boundary as possible.
*
* @method listen
* @name TickerService#listen
* @param {Function} callback callback to invoke
* @returns {Function} a function to unregister this listener
*/
listen: function (callback) {
callbacks.push(callback);
TickerService.prototype.listen = function (callback) {
var self = this;
self.callbacks.push(callback);
// Provide immediate feedback
callback(last);
callback(this.last);
// Provide a deregistration function
return function () {
callbacks = callbacks.filter(function (cb) {
self.callbacks = self.callbacks.filter(function (cb) {
return cb !== callback;
});
};
}
};
}
return TickerService;
}
);