You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
424 lines
12 KiB
424 lines
12 KiB
var util = require('../../util');
|
|
var stack = require('../Stack');
|
|
var ItemRange = require('./item/ItemRange');
|
|
|
|
/**
|
|
* @constructor Group
|
|
* @param {Number | String} groupId
|
|
* @param {Object} data
|
|
* @param {ItemSet} itemSet
|
|
*/
|
|
function Group (groupId, data, itemSet) {
|
|
this.groupId = groupId;
|
|
|
|
this.itemSet = itemSet;
|
|
|
|
this.dom = {};
|
|
this.props = {
|
|
label: {
|
|
width: 0,
|
|
height: 0
|
|
}
|
|
};
|
|
this.className = null;
|
|
|
|
this.items = {}; // items filtered by groupId of this group
|
|
this.visibleItems = []; // items currently visible in window
|
|
this.orderedItems = { // items sorted by start and by end
|
|
byStart: [],
|
|
byEnd: []
|
|
};
|
|
|
|
this._create();
|
|
|
|
this.setData(data);
|
|
}
|
|
|
|
/**
|
|
* Create DOM elements for the group
|
|
* @private
|
|
*/
|
|
Group.prototype._create = function() {
|
|
var label = document.createElement('div');
|
|
label.className = 'vlabel';
|
|
this.dom.label = label;
|
|
|
|
var inner = document.createElement('div');
|
|
inner.className = 'inner';
|
|
label.appendChild(inner);
|
|
this.dom.inner = inner;
|
|
|
|
var foreground = document.createElement('div');
|
|
foreground.className = 'group';
|
|
foreground['timeline-group'] = this;
|
|
this.dom.foreground = foreground;
|
|
|
|
this.dom.background = document.createElement('div');
|
|
this.dom.background.className = 'group';
|
|
|
|
this.dom.axis = document.createElement('div');
|
|
this.dom.axis.className = 'group';
|
|
|
|
// create a hidden marker to detect when the Timelines container is attached
|
|
// to the DOM, or the style of a parent of the Timeline is changed from
|
|
// display:none is changed to visible.
|
|
this.dom.marker = document.createElement('div');
|
|
this.dom.marker.style.visibility = 'hidden';
|
|
this.dom.marker.innerHTML = '?';
|
|
this.dom.background.appendChild(this.dom.marker);
|
|
};
|
|
|
|
/**
|
|
* Set the group data for this group
|
|
* @param {Object} data Group data, can contain properties content and className
|
|
*/
|
|
Group.prototype.setData = function(data) {
|
|
// update contents
|
|
var content = data && data.content;
|
|
if (content instanceof Element) {
|
|
this.dom.inner.appendChild(content);
|
|
}
|
|
else if (content != undefined) {
|
|
this.dom.inner.innerHTML = content;
|
|
}
|
|
else {
|
|
this.dom.inner.innerHTML = this.groupId;
|
|
}
|
|
|
|
// update title
|
|
this.dom.label.title = data && data.title || '';
|
|
|
|
if (!this.dom.inner.firstChild) {
|
|
util.addClassName(this.dom.inner, 'hidden');
|
|
}
|
|
else {
|
|
util.removeClassName(this.dom.inner, 'hidden');
|
|
}
|
|
|
|
// update className
|
|
var className = data && data.className || null;
|
|
if (className != this.className) {
|
|
if (this.className) {
|
|
util.removeClassName(this.dom.label, className);
|
|
util.removeClassName(this.dom.foreground, className);
|
|
util.removeClassName(this.dom.background, className);
|
|
util.removeClassName(this.dom.axis, className);
|
|
}
|
|
util.addClassName(this.dom.label, className);
|
|
util.addClassName(this.dom.foreground, className);
|
|
util.addClassName(this.dom.background, className);
|
|
util.addClassName(this.dom.axis, className);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get the width of the group label
|
|
* @return {number} width
|
|
*/
|
|
Group.prototype.getLabelWidth = function() {
|
|
return this.props.label.width;
|
|
};
|
|
|
|
|
|
/**
|
|
* Repaint this group
|
|
* @param {{start: number, end: number}} range
|
|
* @param {{item: {horizontal: number, vertical: number}, axis: number}} margin
|
|
* @param {boolean} [restack=false] Force restacking of all items
|
|
* @return {boolean} Returns true if the group is resized
|
|
*/
|
|
Group.prototype.redraw = function(range, margin, restack) {
|
|
var resized = false;
|
|
|
|
this.visibleItems = this._updateVisibleItems(this.orderedItems, this.visibleItems, range);
|
|
|
|
// force recalculation of the height of the items when the marker height changed
|
|
// (due to the Timeline being attached to the DOM or changed from display:none to visible)
|
|
var markerHeight = this.dom.marker.clientHeight;
|
|
if (markerHeight != this.lastMarkerHeight) {
|
|
this.lastMarkerHeight = markerHeight;
|
|
|
|
util.forEach(this.items, function (item) {
|
|
item.dirty = true;
|
|
if (item.displayed) item.redraw();
|
|
});
|
|
|
|
restack = true;
|
|
}
|
|
|
|
// reposition visible items vertically
|
|
if (this.itemSet.options.stack) { // TODO: ugly way to access options...
|
|
stack.stack(this.visibleItems, margin, restack);
|
|
}
|
|
else { // no stacking
|
|
stack.nostack(this.visibleItems, margin);
|
|
}
|
|
|
|
// recalculate the height of the group
|
|
var height;
|
|
var visibleItems = this.visibleItems;
|
|
if (visibleItems.length) {
|
|
var min = visibleItems[0].top;
|
|
var max = visibleItems[0].top + visibleItems[0].height;
|
|
util.forEach(visibleItems, function (item) {
|
|
min = Math.min(min, item.top);
|
|
max = Math.max(max, (item.top + item.height));
|
|
});
|
|
if (min > margin.axis) {
|
|
// there is an empty gap between the lowest item and the axis
|
|
var offset = min - margin.axis;
|
|
max -= offset;
|
|
util.forEach(visibleItems, function (item) {
|
|
item.top -= offset;
|
|
});
|
|
}
|
|
height = max + margin.item.vertical / 2;
|
|
}
|
|
else {
|
|
height = margin.axis + margin.item.vertical;
|
|
}
|
|
height = Math.max(height, this.props.label.height);
|
|
|
|
// calculate actual size and position
|
|
var foreground = this.dom.foreground;
|
|
this.top = foreground.offsetTop;
|
|
this.left = foreground.offsetLeft;
|
|
this.width = foreground.offsetWidth;
|
|
resized = util.updateProperty(this, 'height', height) || resized;
|
|
|
|
// recalculate size of label
|
|
resized = util.updateProperty(this.props.label, 'width', this.dom.inner.clientWidth) || resized;
|
|
resized = util.updateProperty(this.props.label, 'height', this.dom.inner.clientHeight) || resized;
|
|
|
|
// apply new height
|
|
this.dom.background.style.height = height + 'px';
|
|
this.dom.foreground.style.height = height + 'px';
|
|
this.dom.label.style.height = height + 'px';
|
|
|
|
// update vertical position of items after they are re-stacked and the height of the group is calculated
|
|
for (var i = 0, ii = this.visibleItems.length; i < ii; i++) {
|
|
var item = this.visibleItems[i];
|
|
item.repositionY();
|
|
}
|
|
|
|
return resized;
|
|
};
|
|
|
|
/**
|
|
* Show this group: attach to the DOM
|
|
*/
|
|
Group.prototype.show = function() {
|
|
if (!this.dom.label.parentNode) {
|
|
this.itemSet.dom.labelSet.appendChild(this.dom.label);
|
|
}
|
|
|
|
if (!this.dom.foreground.parentNode) {
|
|
this.itemSet.dom.foreground.appendChild(this.dom.foreground);
|
|
}
|
|
|
|
if (!this.dom.background.parentNode) {
|
|
this.itemSet.dom.background.appendChild(this.dom.background);
|
|
}
|
|
|
|
if (!this.dom.axis.parentNode) {
|
|
this.itemSet.dom.axis.appendChild(this.dom.axis);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Hide this group: remove from the DOM
|
|
*/
|
|
Group.prototype.hide = function() {
|
|
var label = this.dom.label;
|
|
if (label.parentNode) {
|
|
label.parentNode.removeChild(label);
|
|
}
|
|
|
|
var foreground = this.dom.foreground;
|
|
if (foreground.parentNode) {
|
|
foreground.parentNode.removeChild(foreground);
|
|
}
|
|
|
|
var background = this.dom.background;
|
|
if (background.parentNode) {
|
|
background.parentNode.removeChild(background);
|
|
}
|
|
|
|
var axis = this.dom.axis;
|
|
if (axis.parentNode) {
|
|
axis.parentNode.removeChild(axis);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Add an item to the group
|
|
* @param {Item} item
|
|
*/
|
|
Group.prototype.add = function(item) {
|
|
this.items[item.id] = item;
|
|
item.setParent(this);
|
|
|
|
if (this.visibleItems.indexOf(item) == -1) {
|
|
var range = this.itemSet.body.range; // TODO: not nice accessing the range like this
|
|
this._checkIfVisible(item, this.visibleItems, range);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Remove an item from the group
|
|
* @param {Item} item
|
|
*/
|
|
Group.prototype.remove = function(item) {
|
|
delete this.items[item.id];
|
|
item.setParent(this.itemSet);
|
|
|
|
// remove from visible items
|
|
var index = this.visibleItems.indexOf(item);
|
|
if (index != -1) this.visibleItems.splice(index, 1);
|
|
|
|
// TODO: also remove from ordered items?
|
|
};
|
|
|
|
/**
|
|
* Remove an item from the corresponding DataSet
|
|
* @param {Item} item
|
|
*/
|
|
Group.prototype.removeFromDataSet = function(item) {
|
|
this.itemSet.removeItem(item.id);
|
|
};
|
|
|
|
/**
|
|
* Reorder the items
|
|
*/
|
|
Group.prototype.order = function() {
|
|
var array = util.toArray(this.items);
|
|
this.orderedItems.byStart = array;
|
|
this.orderedItems.byEnd = this._constructByEndArray(array);
|
|
|
|
stack.orderByStart(this.orderedItems.byStart);
|
|
stack.orderByEnd(this.orderedItems.byEnd);
|
|
};
|
|
|
|
/**
|
|
* Create an array containing all items being a range (having an end date)
|
|
* @param {Item[]} array
|
|
* @returns {ItemRange[]}
|
|
* @private
|
|
*/
|
|
Group.prototype._constructByEndArray = function(array) {
|
|
var endArray = [];
|
|
|
|
for (var i = 0; i < array.length; i++) {
|
|
if (array[i] instanceof ItemRange) {
|
|
endArray.push(array[i]);
|
|
}
|
|
}
|
|
return endArray;
|
|
};
|
|
|
|
/**
|
|
* Update the visible items
|
|
* @param {{byStart: Item[], byEnd: Item[]}} orderedItems All items ordered by start date and by end date
|
|
* @param {Item[]} visibleItems The previously visible items.
|
|
* @param {{start: number, end: number}} range Visible range
|
|
* @return {Item[]} visibleItems The new visible items.
|
|
* @private
|
|
*/
|
|
Group.prototype._updateVisibleItems = function(orderedItems, visibleItems, range) {
|
|
var initialPosByStart,
|
|
newVisibleItems = [],
|
|
i;
|
|
|
|
// first check if the items that were in view previously are still in view.
|
|
// this handles the case for the ItemRange that is both before and after the current one.
|
|
if (visibleItems.length > 0) {
|
|
for (i = 0; i < visibleItems.length; i++) {
|
|
this._checkIfVisible(visibleItems[i], newVisibleItems, range);
|
|
}
|
|
}
|
|
|
|
// If there were no visible items previously, use binarySearch to find a visible ItemPoint or ItemRange (based on startTime)
|
|
if (newVisibleItems.length == 0) {
|
|
initialPosByStart = util.binarySearch(orderedItems.byStart, range, 'data','start');
|
|
}
|
|
else {
|
|
initialPosByStart = orderedItems.byStart.indexOf(newVisibleItems[0]);
|
|
}
|
|
|
|
// use visible search to find a visible ItemRange (only based on endTime)
|
|
var initialPosByEnd = util.binarySearch(orderedItems.byEnd, range, 'data','end');
|
|
|
|
// if we found a initial ID to use, trace it up and down until we meet an invisible item.
|
|
if (initialPosByStart != -1) {
|
|
for (i = initialPosByStart; i >= 0; i--) {
|
|
if (this._checkIfInvisible(orderedItems.byStart[i], newVisibleItems, range)) {break;}
|
|
}
|
|
for (i = initialPosByStart + 1; i < orderedItems.byStart.length; i++) {
|
|
if (this._checkIfInvisible(orderedItems.byStart[i], newVisibleItems, range)) {break;}
|
|
}
|
|
}
|
|
|
|
// if we found a initial ID to use, trace it up and down until we meet an invisible item.
|
|
if (initialPosByEnd != -1) {
|
|
for (i = initialPosByEnd; i >= 0; i--) {
|
|
if (this._checkIfInvisible(orderedItems.byEnd[i], newVisibleItems, range)) {break;}
|
|
}
|
|
for (i = initialPosByEnd + 1; i < orderedItems.byEnd.length; i++) {
|
|
if (this._checkIfInvisible(orderedItems.byEnd[i], newVisibleItems, range)) {break;}
|
|
}
|
|
}
|
|
|
|
return newVisibleItems;
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* this function checks if an item is invisible. If it is NOT we make it visible
|
|
* and add it to the global visible items. If it is, return true.
|
|
*
|
|
* @param {Item} item
|
|
* @param {Item[]} visibleItems
|
|
* @param {{start:number, end:number}} range
|
|
* @returns {boolean}
|
|
* @private
|
|
*/
|
|
Group.prototype._checkIfInvisible = function(item, visibleItems, range) {
|
|
if (item.isVisible(range)) {
|
|
if (!item.displayed) item.show();
|
|
item.repositionX();
|
|
if (visibleItems.indexOf(item) == -1) {
|
|
visibleItems.push(item);
|
|
}
|
|
return false;
|
|
}
|
|
else {
|
|
if (item.displayed) item.hide();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* this function is very similar to the _checkIfInvisible() but it does not
|
|
* return booleans, hides the item if it should not be seen and always adds to
|
|
* the visibleItems.
|
|
* this one is for brute forcing and hiding.
|
|
*
|
|
* @param {Item} item
|
|
* @param {Array} visibleItems
|
|
* @param {{start:number, end:number}} range
|
|
* @private
|
|
*/
|
|
Group.prototype._checkIfVisible = function(item, visibleItems, range) {
|
|
if (item.isVisible(range)) {
|
|
if (!item.displayed) item.show();
|
|
// reposition item horizontally
|
|
item.repositionX();
|
|
visibleItems.push(item);
|
|
}
|
|
else {
|
|
if (item.displayed) item.hide();
|
|
}
|
|
};
|
|
|
|
module.exports = Group;
|