309 lines
9.8 KiB
JavaScript
309 lines
9.8 KiB
JavaScript
/* *
|
|
*
|
|
* (c) 2009-2021 Øystein Moseng
|
|
*
|
|
* TimelineEvent class definition.
|
|
*
|
|
* License: www.highcharts.com/license
|
|
*
|
|
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
|
*
|
|
* */
|
|
'use strict';
|
|
import Sonification from './Sonification.js';
|
|
import U from '../../Core/Utilities.js';
|
|
var merge = U.merge, splat = U.splat;
|
|
/**
|
|
* Internal types.
|
|
* @private
|
|
*/
|
|
import SU from './SonificationUtilities.js';
|
|
/* eslint-disable no-invalid-this, valid-jsdoc */
|
|
/* *
|
|
*
|
|
* Class
|
|
*
|
|
* */
|
|
/**
|
|
* The Timeline class. Represents a sonification timeline with a list of
|
|
* timeline paths with events to play at certain times relative to each other.
|
|
*
|
|
* @requires module:modules/sonification
|
|
*
|
|
* @private
|
|
* @class
|
|
* @name Highcharts.Timeline
|
|
*
|
|
* @param {Highcharts.TimelineOptionsObject} options
|
|
* Options for the Timeline.
|
|
*/
|
|
var Timeline = /** @class */ (function () {
|
|
/* *
|
|
*
|
|
* Constructor
|
|
*
|
|
* */
|
|
function Timeline(options) {
|
|
/* *
|
|
*
|
|
* Properties
|
|
*
|
|
* */
|
|
this.cursor = void 0;
|
|
this.options = void 0;
|
|
this.paths = void 0;
|
|
this.pathsPlaying = void 0;
|
|
this.signalHandler = void 0;
|
|
this.init(options || {});
|
|
}
|
|
/* *
|
|
*
|
|
* Functions
|
|
*
|
|
* */
|
|
Timeline.prototype.init = function (options) {
|
|
this.options = options;
|
|
this.cursor = 0;
|
|
this.paths = options.paths || [];
|
|
this.pathsPlaying = {};
|
|
this.signalHandler = new SU.SignalHandler(['playOnEnd', 'masterOnEnd', 'onPathStart', 'onPathEnd']);
|
|
this.signalHandler.registerSignalCallbacks(merge(options, { masterOnEnd: options.onEnd }));
|
|
};
|
|
/**
|
|
* Play the timeline forwards from cursor.
|
|
* @private
|
|
* @param {Function} [onEnd]
|
|
* Callback to call when play finished. Does not override other onEnd
|
|
* callbacks.
|
|
*/
|
|
Timeline.prototype.play = function (onEnd) {
|
|
this.pause();
|
|
this.signalHandler.clearSignalCallbacks(['playOnEnd']);
|
|
this.signalHandler.registerSignalCallbacks({ playOnEnd: onEnd });
|
|
this.playPaths(1);
|
|
};
|
|
/**
|
|
* Play the timeline backwards from cursor.
|
|
* @private
|
|
* @param {Function} onEnd
|
|
* Callback to call when play finished. Does not override other onEnd
|
|
* callbacks.
|
|
*/
|
|
Timeline.prototype.rewind = function (onEnd) {
|
|
this.pause();
|
|
this.signalHandler.clearSignalCallbacks(['playOnEnd']);
|
|
this.signalHandler.registerSignalCallbacks({ playOnEnd: onEnd });
|
|
this.playPaths(-1);
|
|
};
|
|
/**
|
|
* Play the timeline in the specified direction.
|
|
* @private
|
|
* @param {number} direction
|
|
* Direction to play in. 1 for forwards, -1 for backwards.
|
|
*/
|
|
Timeline.prototype.playPaths = function (direction) {
|
|
var timeline = this, signalHandler = timeline.signalHandler;
|
|
if (!timeline.paths.length) {
|
|
var emptySignal = {
|
|
cancelled: false
|
|
};
|
|
signalHandler.emitSignal('playOnEnd', emptySignal);
|
|
signalHandler.emitSignal('masterOnEnd', emptySignal);
|
|
return;
|
|
}
|
|
var curPaths = splat(this.paths[this.cursor]), nextPaths = this.paths[this.cursor + direction],
|
|
// Play a path
|
|
playPath = function (path) {
|
|
// Emit signal and set playing state
|
|
signalHandler.emitSignal('onPathStart', path);
|
|
timeline.pathsPlaying[path.id] = path;
|
|
// Do the play
|
|
path[direction > 0 ? 'play' : 'rewind'](function (callbackData) {
|
|
// Play ended callback
|
|
// Data to pass to signal callbacks
|
|
var cancelled = callbackData && callbackData.cancelled, signalData = {
|
|
path: path,
|
|
cancelled: cancelled
|
|
};
|
|
// Clear state and send signal
|
|
delete timeline.pathsPlaying[path.id];
|
|
signalHandler.emitSignal('onPathEnd', signalData);
|
|
// Handle next paths
|
|
var pathsEnded = 0;
|
|
pathsEnded++;
|
|
if (pathsEnded >= curPaths.length) {
|
|
// We finished all of the current paths for cursor.
|
|
if (nextPaths && !cancelled) {
|
|
// We have more paths, move cursor along
|
|
timeline.cursor += direction;
|
|
// Reset upcoming path cursors before playing
|
|
splat(nextPaths).forEach(function (nextPath) {
|
|
nextPath[direction > 0 ?
|
|
'resetCursor' : 'resetCursorEnd']();
|
|
});
|
|
// Play next
|
|
timeline.playPaths(direction);
|
|
}
|
|
else {
|
|
// If it is the last path in this direction,
|
|
// call onEnd
|
|
signalHandler.emitSignal('playOnEnd', signalData);
|
|
signalHandler.emitSignal('masterOnEnd', signalData);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
// Go through the paths under cursor and play them
|
|
curPaths.forEach(function (path) {
|
|
if (path) {
|
|
// Store reference to timeline
|
|
path.timeline = timeline;
|
|
// Leave a timeout to let notes fade out before next play
|
|
setTimeout(function () {
|
|
playPath(path);
|
|
}, Sonification.fadeOutDuration);
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* Stop the playing of the timeline. Cancels all current sounds, but does
|
|
* not affect the cursor.
|
|
* @private
|
|
* @param {boolean} [fadeOut=false]
|
|
* Whether or not to fade out as we stop. If false, the timeline is
|
|
* cancelled synchronously.
|
|
*/
|
|
Timeline.prototype.pause = function (fadeOut) {
|
|
var timeline = this;
|
|
// Cancel currently playing events
|
|
Object.keys(timeline.pathsPlaying).forEach(function (id) {
|
|
if (timeline.pathsPlaying[id]) {
|
|
timeline.pathsPlaying[id].pause(fadeOut);
|
|
}
|
|
});
|
|
timeline.pathsPlaying = {};
|
|
};
|
|
/**
|
|
* Reset the cursor to the beginning of the timeline.
|
|
* @private
|
|
*/
|
|
Timeline.prototype.resetCursor = function () {
|
|
this.paths.forEach(function (paths) {
|
|
splat(paths).forEach(function (path) {
|
|
path.resetCursor();
|
|
});
|
|
});
|
|
this.cursor = 0;
|
|
};
|
|
/**
|
|
* Reset the cursor to the end of the timeline.
|
|
* @private
|
|
*/
|
|
Timeline.prototype.resetCursorEnd = function () {
|
|
this.paths.forEach(function (paths) {
|
|
splat(paths).forEach(function (path) {
|
|
path.resetCursorEnd();
|
|
});
|
|
});
|
|
this.cursor = this.paths.length - 1;
|
|
};
|
|
/**
|
|
* Set the current TimelineEvent under the cursor. If multiple paths are
|
|
* being played at the same time, this function only affects a single path
|
|
* (the one that contains the eventId that is passed in).
|
|
* @private
|
|
* @param {string} eventId
|
|
* The ID of the timeline event to set as current.
|
|
* @return {boolean}
|
|
* True if the cursor was set, false if no TimelineEvent was found for
|
|
* this ID.
|
|
*/
|
|
Timeline.prototype.setCursor = function (eventId) {
|
|
return this.paths.some(function (paths) {
|
|
return splat(paths).some(function (path) {
|
|
return path.setCursor(eventId);
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Get the current TimelineEvents under the cursors. This function will
|
|
* return the event under the cursor for each currently playing path, as an
|
|
* object where the path ID is mapped to the TimelineEvent under that
|
|
* path's cursor.
|
|
* @private
|
|
* @return {Highcharts.Dictionary<Highcharts.TimelineEvent>}
|
|
* The TimelineEvents under each path's cursors.
|
|
*/
|
|
Timeline.prototype.getCursor = function () {
|
|
return this.getCurrentPlayingPaths().reduce(function (acc, cur) {
|
|
acc[cur.id] = cur.getCursor();
|
|
return acc;
|
|
}, {});
|
|
};
|
|
/**
|
|
* Check if timeline is reset or at start.
|
|
* @private
|
|
* @return {boolean}
|
|
* True if timeline is at the beginning.
|
|
*/
|
|
Timeline.prototype.atStart = function () {
|
|
if (this.cursor) {
|
|
return false;
|
|
}
|
|
return !splat(this.paths[0]).some(function (path) {
|
|
return path.cursor;
|
|
});
|
|
};
|
|
/**
|
|
* Get the current TimelinePaths being played.
|
|
* @private
|
|
* @return {Array<Highcharts.TimelinePath>}
|
|
* The TimelinePaths currently being played.
|
|
*/
|
|
Timeline.prototype.getCurrentPlayingPaths = function () {
|
|
if (!this.paths.length) {
|
|
return [];
|
|
}
|
|
return splat(this.paths[this.cursor]);
|
|
};
|
|
return Timeline;
|
|
}());
|
|
/* *
|
|
*
|
|
* Default Export
|
|
*
|
|
* */
|
|
export default Timeline;
|
|
/* *
|
|
*
|
|
* API Declarations
|
|
*
|
|
* */
|
|
/**
|
|
* A set of options for the Timeline class.
|
|
*
|
|
* @requires module:modules/sonification
|
|
*
|
|
* @private
|
|
* @interface Highcharts.TimelineOptionsObject
|
|
*/ /**
|
|
* List of TimelinePaths to play. Multiple paths can be grouped together and
|
|
* played simultaneously by supplying an array of paths in place of a single
|
|
* path.
|
|
* @name Highcharts.TimelineOptionsObject#paths
|
|
* @type {Array<(Highcharts.TimelinePath|Array<Highcharts.TimelinePath>)>}
|
|
*/ /**
|
|
* Callback function to call before a path plays.
|
|
* @name Highcharts.TimelineOptionsObject#onPathStart
|
|
* @type {Function|undefined}
|
|
*/ /**
|
|
* Callback function to call after a path has stopped playing.
|
|
* @name Highcharts.TimelineOptionsObject#onPathEnd
|
|
* @type {Function|undefined}
|
|
*/ /**
|
|
* Callback called when the whole path is finished.
|
|
* @name Highcharts.TimelineOptionsObject#onEnd
|
|
* @type {Function|undefined}
|
|
*/
|
|
(''); // detach doclets above
|