angular2gridsterv3
Version:
792 lines • 112 kB
JavaScript
const GridCol = function (lanes) {
for (let i = 0; i < lanes; i++) {
this.push(null);
}
};
// Extend the Array prototype
GridCol.prototype = [];
/**
* A GridList manages the two-dimensional positions from a list of items,
* within a virtual matrix.
*
* The GridList's main function is to convert the item positions from one
* grid size to another, maintaining as much of their order as possible.
*
* The GridList's second function is to handle collisions when moving an item
* over another.
*
* The positioning algorithm places items in columns. Starting from left to
* right, going through each column top to bottom.
*
* The size of an item is expressed using the number of cols and rows it
* takes up within the grid (w and h)
*
* The position of an item is express using the col and row position within
* the grid (x and y)
*
* An item is an object of structure:
* {
* w: 3, h: 1,
* x: 0, y: 1
* }
*/
export class GridList {
constructor(items, options) {
this.options = options;
this.items = items;
this.adjustSizeOfItems();
this.generateGrid();
}
/**
* Illustrates grid as text-based table, using a number identifier for each
* item. E.g.
*
* #| 0 1 2 3 4 5 6 7 8 9 10 11 12 13
* --------------------------------------------
* 0| 00 02 03 04 04 06 08 08 08 12 12 13 14 16
* 1| 01 -- 03 05 05 07 09 10 11 11 -- 13 15 --
*
* Warn: Does not work if items don't have a width or height specified
* besides their position in the grid.
*/
toString() {
const widthOfGrid = this.grid.length;
let output = '\n #|', border = '\n --', item, i, j;
// Render the table header
for (i = 0; i < widthOfGrid; i++) {
output += ' ' + this.padNumber(i, ' ');
border += '---';
}
output += border;
// Render table contents row by row, as we go on the y axis
for (i = 0; i < this.options.lanes; i++) {
output += '\n' + this.padNumber(i, ' ') + '|';
for (j = 0; j < widthOfGrid; j++) {
output += ' ';
item = this.grid[j][i];
output += item
? this.padNumber(this.items.indexOf(item), '0')
: '--';
}
}
output += '\n';
return output;
}
setOption(name, value) {
this.options[name] = value;
}
/**
* Build the grid structure from scratch, with the current item positions
*/
generateGrid() {
let i;
this.resetGrid();
for (i = 0; i < this.items.length; i++) {
this.markItemPositionToGrid(this.items[i]);
}
}
resizeGrid(lanes) {
let currentColumn = 0;
this.options.lanes = lanes;
this.adjustSizeOfItems();
this.sortItemsByPosition();
this.resetGrid();
// The items will be sorted based on their index within the this.items array,
// that is their "1d position"
for (let i = 0; i < this.items.length; i++) {
const item = this.items[i], position = this.getItemPosition(item);
this.updateItemPosition(item, this.findPositionForItem(item, { x: currentColumn, y: 0 }));
// New items should never be placed to the left of previous items
currentColumn = Math.max(currentColumn, position.x);
}
this.pullItemsToLeft();
}
/**
* This method has two options for the position we want for the item:
* - Starting from a certain row/column number and only looking for
* positions to its right
* - Accepting positions for a certain row number only (use-case: items
* being shifted to the left/right as a result of collisions)
*
* @param Object item
* @param Object start Position from which to start
* the search.
* @param number [fixedRow] If provided, we're going to try to find a
* position for the new item on it. If doesn't fit there, we're going
* to put it on the first row.
*
* @returns Array x and y.
*/
findPositionForItem(item, start, fixedRow) {
let x, y, position;
// Start searching for a position from the horizontal position of the
// rightmost item from the grid
for (x = start.x; x < this.grid.length; x++) {
if (fixedRow !== undefined) {
position = [x, fixedRow];
if (this.itemFitsAtPosition(item, position)) {
return position;
}
}
else {
for (y = start.y; y < this.options.lanes; y++) {
position = [x, y];
if (this.itemFitsAtPosition(item, position)) {
return position;
}
}
}
}
// If we've reached this point, we need to start a new column
const newCol = this.grid.length;
let newRow = 0;
if (fixedRow !== undefined &&
this.itemFitsAtPosition(item, [newCol, fixedRow])) {
newRow = fixedRow;
}
return [newCol, newRow];
}
moveAndResize(item, newPosition, size) {
const position = this.getItemPosition({
x: newPosition[0],
y: newPosition[1],
w: item.w,
h: item.h
});
const width = size.w || item.w, height = size.h || item.h;
this.updateItemPosition(item, [position.x, position.y]);
this.updateItemSize(item, width, height);
this.resolveCollisions(item);
}
moveItemToPosition(item, newPosition) {
const position = this.getItemPosition({
x: newPosition[0],
y: newPosition[1],
w: item.w,
h: item.h
});
this.updateItemPosition(item, [position.x, position.y]);
this.resolveCollisions(item);
}
/**
* Resize an item and resolve collisions.
*
* @param Object item A reference to an item that's part of the grid.
* @param Object size
* @param number [size.w=item.w] The new width.
* @param number [size.h=item.h] The new height.
*/
resizeItem(item, size) {
const width = size.w || item.w, height = size.h || item.h;
this.updateItemSize(item, width, height);
this.pullItemsToLeft(item);
}
/**
* Compare the current items against a previous snapshot and return only
* the ones that changed their attributes in the meantime. This includes both
* position (x, y) and size (w, h)
*
* Each item that is returned is not the GridListItem but the helper that holds GridListItem
* and list of changed properties.
*/
getChangedItems(initialItems, breakpoint) {
return this.items
.map((item) => {
const changes = [];
const oldValues = {};
const initItem = initialItems.find(initItm => initItm.$element === item.$element);
if (!initItem) {
return { item, changes: ['x', 'y', 'w', 'h'], isNew: true };
}
const oldX = initItem.getValueX(breakpoint);
if (item.getValueX(breakpoint) !== oldX) {
changes.push('x');
if (oldX || oldX === 0) {
oldValues.x = oldX;
}
}
const oldY = initItem.getValueY(breakpoint);
if (item.getValueY(breakpoint) !== oldY) {
changes.push('y');
if (oldY || oldY === 0) {
oldValues.y = oldY;
}
}
if (item.getValueW(breakpoint) !==
initItem.getValueW(breakpoint)) {
changes.push('w');
oldValues.w = initItem.w;
}
if (item.getValueH(breakpoint) !==
initItem.getValueH(breakpoint)) {
changes.push('h');
oldValues.h = initItem.h;
}
return { item, oldValues, changes, isNew: false };
})
.filter((itemChange) => {
return itemChange.changes.length;
});
}
resolveCollisions(item) {
if (!this.tryToResolveCollisionsLocally(item)) {
this.pullItemsToLeft(item);
}
if (this.options.floating) {
this.pullItemsToLeft();
}
else if (this.getItemsCollidingWithItem(item).length) {
this.pullItemsToLeft();
}
}
pushCollidingItems(fixedItem) {
// Start a fresh grid with the fixed item already placed inside
this.sortItemsByPosition();
this.resetGrid();
this.generateGrid();
this.items
.filter(item => !this.isItemFloating(item) && item !== fixedItem)
.forEach(item => {
if (!this.tryToResolveCollisionsLocally(item)) {
this.pullItemsToLeft(item);
}
});
}
/**
* Build the grid from scratch, by using the current item positions and
* pulling them as much to the left as possible, removing as space between
* them as possible.
*
* If a "fixed item" is provided, its position will be kept intact and the
* rest of the items will be layed around it.
*/
pullItemsToLeft(fixedItem) {
if (this.options.direction === 'none') {
return;
}
// Start a fresh grid with the fixed item already placed inside
this.sortItemsByPosition();
this.resetGrid();
// Start the grid with the fixed item as the first positioned item
if (fixedItem) {
const fixedPosition = this.getItemPosition(fixedItem);
this.updateItemPosition(fixedItem, [
fixedPosition.x,
fixedPosition.y
]);
}
this.items
.filter((item) => {
return !item.dragAndDrop && item !== fixedItem;
})
.forEach((item) => {
const fixedPosition = this.getItemPosition(item);
this.updateItemPosition(item, [
fixedPosition.x,
fixedPosition.y
]);
});
for (let i = 0; i < this.items.length; i++) {
const item = this.items[i], position = this.getItemPosition(item);
// The fixed item keeps its exact position
if ((fixedItem && item === fixedItem) ||
!item.dragAndDrop ||
(!this.options.floating &&
this.isItemFloating(item) &&
!this.getItemsCollidingWithItem(item).length)) {
continue;
}
const x = this.findLeftMostPositionForItem(item), newPosition = this.findPositionForItem(item, { x: x, y: 0 }, position.y);
this.updateItemPosition(item, newPosition);
}
}
isOverFixedArea(x, y, w, h, item = null) {
let itemData = { x, y, w, h };
if (this.options.direction !== 'horizontal') {
itemData = { x: y, y: x, w: h, h: w };
}
for (let i = itemData.x; i < itemData.x + itemData.w; i++) {
for (let j = itemData.y; j < itemData.y + itemData.h; j++) {
if (this.grid[i] &&
this.grid[i][j] &&
this.grid[i][j] !== item &&
!this.grid[i][j].dragAndDrop) {
return true;
}
}
}
return false;
}
checkItemAboveEmptyArea(item, newPosition) {
let itemData = {
x: newPosition.x,
y: newPosition.y,
w: item.w,
h: item.h
};
if (!item.itemPrototype &&
item.x === newPosition.x &&
item.y === newPosition.y) {
return true;
}
if (this.options.direction === 'horizontal') {
itemData = {
x: newPosition.y,
y: newPosition.x,
w: itemData.h,
h: itemData.w
};
}
return !this.checkItemsInArea(itemData.y, itemData.y + itemData.h - 1, itemData.x, itemData.x + itemData.w - 1, item);
}
fixItemsPositions(options) {
// items with x, y that fits gird with size of options.lanes
const validItems = this.items
.filter((item) => item.itemComponent)
.filter((item) => this.isItemValidForGrid(item, options));
// items that x, y must be generated
const invalidItems = this.items
.filter((item) => item.itemComponent)
.filter((item) => !this.isItemValidForGrid(item, options));
const gridList = new GridList([], options);
// put items with defined positions to the grid
gridList.items = validItems.map((item) => {
return item.copyForBreakpoint(options.breakpoint);
});
gridList.generateGrid();
invalidItems.forEach(item => {
// TODO: check if this change does not broke anything
// const itemCopy = item.copy();
const itemCopy = item.copyForBreakpoint(options.breakpoint);
const position = gridList.findPositionForItem(itemCopy, {
x: 0,
y: 0
});
gridList.items.push(itemCopy);
gridList.setItemPosition(itemCopy, position);
gridList.markItemPositionToGrid(itemCopy);
});
gridList.pullItemsToLeft();
gridList.pushCollidingItems();
this.items.forEach((itm) => {
const cachedItem = gridList.items.filter(cachedItm => {
return cachedItm.$element === itm.$element;
})[0];
itm.setValueX(cachedItem.x, options.breakpoint);
itm.setValueY(cachedItem.y, options.breakpoint);
itm.setValueW(cachedItem.w, options.breakpoint);
itm.setValueH(cachedItem.h, options.breakpoint);
itm.autoSize = cachedItem.autoSize;
});
}
deleteItemPositionFromGrid(item) {
const position = this.getItemPosition(item);
let x, y;
for (x = position.x; x < position.x + position.w; x++) {
// It can happen to try to remove an item from a position not generated
// in the grid, probably when loading a persisted grid of items. No need
// to create a column to be able to remove something from it, though
if (!this.grid[x]) {
continue;
}
for (y = position.y; y < position.y + position.h; y++) {
// Don't clear the cell if it's been occupied by a different widget in
// the meantime (e.g. when an item has been moved over this one, and
// thus by continuing to clear this item's previous position you would
// cancel the first item's move, leaving it without any position even)
if (this.grid[x][y] === item) {
this.grid[x][y] = null;
}
}
}
}
isItemFloating(item) {
if (item.itemComponent && item.itemComponent.isDragging) {
return false;
}
const position = this.getItemPosition(item);
if (position.x === 0) {
return false;
}
const rowBelowItem = this.grid[position.x - 1];
return (rowBelowItem || [])
.slice(position.y, position.y + position.h)
.reduce((isFloating, cellItem) => {
return isFloating && !cellItem;
}, true);
}
isItemValidForGrid(item, options) {
const itemData = options.direction === 'horizontal'
? {
x: item.getValueY(options.breakpoint),
y: item.getValueX(options.breakpoint),
w: item.getValueH(options.breakpoint),
h: Math.min(item.getValueW(this.options.breakpoint), options.lanes)
}
: {
x: item.getValueX(options.breakpoint),
y: item.getValueY(options.breakpoint),
w: Math.min(item.getValueW(this.options.breakpoint), options.lanes),
h: item.getValueH(options.breakpoint)
};
return (typeof itemData.x === 'number' &&
typeof itemData.y === 'number' &&
itemData.x + itemData.w <= options.lanes);
}
findDefaultPositionHorizontal(width, height) {
for (const col of this.grid) {
const colIdx = this.grid.indexOf(col);
let rowIdx = 0;
while (rowIdx < col.length - height + 1) {
if (!this.checkItemsInArea(colIdx, colIdx + width - 1, rowIdx, rowIdx + height - 1)) {
return [colIdx, rowIdx];
}
rowIdx++;
}
}
return [this.grid.length, 0];
}
findDefaultPositionVertical(width, height) {
for (const row of this.grid) {
const rowIdx = this.grid.indexOf(row);
let colIdx = 0;
while (colIdx < row.length - width + 1) {
if (!this.checkItemsInArea(rowIdx, rowIdx + height - 1, colIdx, colIdx + width - 1)) {
return [colIdx, rowIdx];
}
colIdx++;
}
}
return [0, this.grid.length];
}
checkItemsInArea(rowStart, rowEnd, colStart, colEnd, item) {
for (let i = rowStart; i <= rowEnd; i++) {
for (let j = colStart; j <= colEnd; j++) {
if (this.grid[i] &&
this.grid[i][j] &&
(item ? this.grid[i][j] !== item : true)) {
return true;
}
}
}
return false;
}
sortItemsByPosition() {
this.items.sort((item1, item2) => {
const position1 = this.getItemPosition(item1), position2 = this.getItemPosition(item2);
// Try to preserve columns.
if (position1.x !== position2.x) {
return position1.x - position2.x;
}
if (position1.y !== position2.y) {
return position1.y - position2.y;
}
// The items are placed on the same position.
return 0;
});
}
/**
* Some items can have 100% height or 100% width. Those dimmensions are
* expressed as 0. We need to ensure a valid width and height for each of
* those items as the number of items per lane.
*/
adjustSizeOfItems() {
for (let i = 0; i < this.items.length; i++) {
const item = this.items[i];
// This can happen only the first time items are checked.
// We need the property to have a value for all the items so that the
// `cloneItems` method will merge the properties properly. If we only set
// it to the items that need it then the following can happen:
//
// cloneItems([{id: 1, autoSize: true}, {id: 2}],
// [{id: 2}, {id: 1, autoSize: true}]);
//
// will result in
//
// [{id: 1, autoSize: true}, {id: 2, autoSize: true}]
if (item.autoSize === undefined) {
item.autoSize = item.w === 0 || item.h === 0;
}
if (item.autoSize) {
if (this.options.direction === 'horizontal') {
item.h = this.options.lanes;
}
else {
item.w = this.options.lanes;
}
}
}
}
resetGrid() {
this.grid = [];
}
/**
* Check that an item wouldn't overlap with another one if placed at a
* certain position within the grid
*/
itemFitsAtPosition(item, newPosition) {
const position = this.getItemPosition(item);
let x, y;
// No coordonate can be negative
if (newPosition[0] < 0 || newPosition[1] < 0) {
return false;
}
// Make sure the item isn't larger than the entire grid
if (newPosition[1] + Math.min(position.h, this.options.lanes) >
this.options.lanes) {
return false;
}
if (this.isOverFixedArea(item.x, item.y, item.w, item.h)) {
return false;
}
// Make sure the position doesn't overlap with an already positioned
// item.
for (x = newPosition[0]; x < newPosition[0] + position.w; x++) {
const col = this.grid[x];
// Surely a column that hasn't even been created yet is available
if (!col) {
continue;
}
for (y = newPosition[1]; y < newPosition[1] + position.h; y++) {
// Any space occupied by an item can continue to be occupied by the
// same item.
if (col[y] && col[y] !== item) {
return false;
}
}
}
return true;
}
updateItemPosition(item, position) {
if (item.x !== null && item.y !== null) {
this.deleteItemPositionFromGrid(item);
}
this.setItemPosition(item, position);
this.markItemPositionToGrid(item);
}
/**
* @param Object item A reference to a grid item.
* @param number width The new width.
* @param number height The new height.
*/
updateItemSize(item, width, height) {
if (item.x !== null && item.y !== null) {
this.deleteItemPositionFromGrid(item);
}
item.w = width;
item.h = height;
this.markItemPositionToGrid(item);
}
/**
* Mark the grid cells that are occupied by an item. This prevents items
* from overlapping in the grid
*/
markItemPositionToGrid(item) {
const position = this.getItemPosition(item);
let x, y;
// Ensure that the grid has enough columns to accomodate the current item.
this.ensureColumns(position.x + position.w);
for (x = position.x; x < position.x + position.w; x++) {
for (y = position.y; y < position.y + position.h; y++) {
this.grid[x][y] = item;
}
}
}
/**
* Ensure that the grid has at least N columns available.
*/
ensureColumns(N) {
for (let i = 0; i < N; i++) {
if (!this.grid[i]) {
this.grid.push(new GridCol(this.options.lanes));
}
}
}
getItemsCollidingWithItem(item) {
const collidingItems = [];
for (let i = 0; i < this.items.length; i++) {
if (item !== this.items[i] &&
this.itemsAreColliding(item, this.items[i])) {
collidingItems.push(i);
}
}
return collidingItems;
}
itemsAreColliding(item1, item2) {
const position1 = this.getItemPosition(item1), position2 = this.getItemPosition(item2);
return !(position2.x >= position1.x + position1.w ||
position2.x + position2.w <= position1.x ||
position2.y >= position1.y + position1.h ||
position2.y + position2.h <= position1.y);
}
/**
* Attempt to resolve the collisions after moving an item over one or more
* other items within the grid, by shifting the position of the colliding
* items around the moving one. This might result in subsequent collisions,
* in which case we will revert all position permutations. To be able to
* revert to the initial item positions, we create a virtual grid in the
* process
*/
tryToResolveCollisionsLocally(item) {
const collidingItems = this.getItemsCollidingWithItem(item);
if (!collidingItems.length) {
return true;
}
const _gridList = new GridList(this.items.map(itm => {
return itm.copy();
}), this.options);
let leftOfItem;
let rightOfItem;
let aboveOfItem;
let belowOfItem;
for (let i = 0; i < collidingItems.length; i++) {
const collidingItem = _gridList.items[collidingItems[i]], collidingPosition = this.getItemPosition(collidingItem);
// We use a simple algorithm for moving items around when collisions occur:
// In this prioritized order, we try to move a colliding item around the
// moving one:
// 1. to its left side
// 2. above it
// 3. under it
// 4. to its right side
const position = this.getItemPosition(item);
leftOfItem = [
position.x - collidingPosition.w,
collidingPosition.y
];
rightOfItem = [position.x + position.w, collidingPosition.y];
aboveOfItem = [
collidingPosition.x,
position.y - collidingPosition.h
];
belowOfItem = [collidingPosition.x, position.y + position.h];
if (_gridList.itemFitsAtPosition(collidingItem, leftOfItem)) {
_gridList.updateItemPosition(collidingItem, leftOfItem);
}
else if (_gridList.itemFitsAtPosition(collidingItem, aboveOfItem)) {
_gridList.updateItemPosition(collidingItem, aboveOfItem);
}
else if (_gridList.itemFitsAtPosition(collidingItem, belowOfItem)) {
_gridList.updateItemPosition(collidingItem, belowOfItem);
}
else if (_gridList.itemFitsAtPosition(collidingItem, rightOfItem)) {
_gridList.updateItemPosition(collidingItem, rightOfItem);
}
else {
// Collisions failed, we must use the pullItemsToLeft method to arrange
// the other items around this item with fixed position. This is our
// plan B for when local collision resolving fails.
return false;
}
}
// If we reached this point it means we managed to resolve the collisions
// from one single iteration, just by moving the colliding items around. So
// we accept this scenario and merge the branched-out grid instance into the
// original one
this.items.forEach((itm, idx) => {
const cachedItem = _gridList.items.filter(cachedItm => {
return cachedItm.$element === itm.$element;
})[0];
itm.x = cachedItem.x;
itm.y = cachedItem.y;
itm.w = cachedItem.w;
itm.h = cachedItem.h;
itm.autoSize = cachedItem.autoSize;
});
this.generateGrid();
return true;
}
/**
* When pulling items to the left, we need to find the leftmost position for
* an item, with two considerations in mind:
* - preserving its current row
* - preserving the previous horizontal order between items
*/
findLeftMostPositionForItem(item) {
let tail = 0;
const position = this.getItemPosition(item);
for (let i = 0; i < this.grid.length; i++) {
for (let j = position.y; j < position.y + position.h; j++) {
const otherItem = this.grid[i][j];
if (!otherItem) {
continue;
}
const otherPosition = this.getItemPosition(otherItem);
if (this.items.indexOf(otherItem) < this.items.indexOf(item)) {
tail = otherPosition.x + otherPosition.w;
}
}
}
return tail;
}
findItemByPosition(x, y) {
for (let i = 0; i < this.items.length; i++) {
if (this.items[i].x === x && this.items[i].y === y) {
return this.items[i];
}
}
}
getItemByAttribute(key, value) {
for (let i = 0; i < this.items.length; i++) {
if (this.items[i][key] === value) {
return this.items[i];
}
}
return null;
}
padNumber(nr, prefix) {
// Currently works for 2-digit numbers (<100)
return nr >= 10 ? nr : prefix + nr;
}
/**
* If the direction is vertical we need to rotate the grid 90 deg to the
* left. Thus, we simulate the fact that items are being pulled to the top.
*
* Since the items have widths and heights, if we apply the classic
* counter-clockwise 90 deg rotation
*
* [0 -1]
* [1 0]
*
* then the top left point of an item will become the bottom left point of
* the rotated item. To adjust for this, we need to subtract from the y
* position the height of the original item - the width of the rotated item.
*
* However, if we do this then we'll reverse some actions: resizing the
* width of an item will stretch the item to the left instead of to the
* right; resizing an item that doesn't fit into the grid will push the
* items around it instead of going on a new row, etc.
*
* We found it better to do a vertical flip of the grid after rotating it.
* This restores the direction of the actions and greatly simplifies the
* transformations.
*/
getItemPosition(item) {
if (this.options.direction === 'horizontal') {
return item;
}
else {
return {
x: item.y,
y: item.x,
w: item.h,
h: item.w
};
}
}
/**
* See getItemPosition.
*/
setItemPosition(item, position) {
if (this.options.direction === 'horizontal') {
item.x = position[0];
item.y = position[1];
}
else {
// We're supposed to subtract the rotated item's height which is actually
// the non-rotated item's width.
item.x = position[1];
item.y = position[0];
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gridList.js","sourceRoot":"","sources":["../../../../../projects/angular2gridsterv3/src/lib/gridList/gridList.ts"],"names":[],"mappings":"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