mirror of
https://github.com/MinimalBible/MinimalBible
synced 2024-12-22 14:48:23 -05:00
Forgot to include the UI Utils scroll files
This commit is contained in:
Bradlee Speice
parent
918f7688ba
commit
b842ee1933
229
app/src/main/assets/dist/scroll-jqlite.js
vendored
Normal file
229
app/src/main/assets/dist/scroll-jqlite.js
vendored
Normal file
@ -0,0 +1,229 @@
|
||||
'use strict';
|
||||
angular.module('ui.scroll.jqlite', ['ui.scroll']).service('jqLiteExtras', [
|
||||
'$log', '$window', function(console, window) {
|
||||
return {
|
||||
registerFor: function(element) {
|
||||
var convertToPx, css, getMeasurements, getStyle, getWidthHeight, isWindow, scrollTo;
|
||||
css = angular.element.prototype.css;
|
||||
element.prototype.css = function(name, value) {
|
||||
var elem, self;
|
||||
self = this;
|
||||
elem = self[0];
|
||||
if (!(!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style)) {
|
||||
return css.call(self, name, value);
|
||||
}
|
||||
};
|
||||
isWindow = function(obj) {
|
||||
return obj && obj.document && obj.location && obj.alert && obj.setInterval;
|
||||
};
|
||||
scrollTo = function(self, direction, value) {
|
||||
var elem, method, preserve, prop, _ref;
|
||||
elem = self[0];
|
||||
_ref = {
|
||||
top: ['scrollTop', 'pageYOffset', 'scrollLeft'],
|
||||
left: ['scrollLeft', 'pageXOffset', 'scrollTop']
|
||||
}[direction], method = _ref[0], prop = _ref[1], preserve = _ref[2];
|
||||
if (isWindow(elem)) {
|
||||
if (angular.isDefined(value)) {
|
||||
return elem.scrollTo(self[preserve].call(self), value);
|
||||
} else {
|
||||
if (prop in elem) {
|
||||
return elem[prop];
|
||||
} else {
|
||||
return elem.document.documentElement[method];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (angular.isDefined(value)) {
|
||||
return elem[method] = value;
|
||||
} else {
|
||||
return elem[method];
|
||||
}
|
||||
}
|
||||
};
|
||||
if (window.getComputedStyle) {
|
||||
getStyle = function(elem) {
|
||||
return window.getComputedStyle(elem, null);
|
||||
};
|
||||
convertToPx = function(elem, value) {
|
||||
return parseFloat(value);
|
||||
};
|
||||
} else {
|
||||
getStyle = function(elem) {
|
||||
return elem.currentStyle;
|
||||
};
|
||||
convertToPx = function(elem, value) {
|
||||
var core_pnum, left, result, rnumnonpx, rs, rsLeft, style;
|
||||
core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
|
||||
rnumnonpx = new RegExp('^(' + core_pnum + ')(?!px)[a-z%]+$', 'i');
|
||||
if (!rnumnonpx.test(value)) {
|
||||
return parseFloat(value);
|
||||
} else {
|
||||
style = elem.style;
|
||||
left = style.left;
|
||||
rs = elem.runtimeStyle;
|
||||
rsLeft = rs && rs.left;
|
||||
if (rs) {
|
||||
rs.left = style.left;
|
||||
}
|
||||
style.left = value;
|
||||
result = style.pixelLeft;
|
||||
style.left = left;
|
||||
if (rsLeft) {
|
||||
rs.left = rsLeft;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
};
|
||||
}
|
||||
getMeasurements = function(elem, measure) {
|
||||
var base, borderA, borderB, computedMarginA, computedMarginB, computedStyle, dirA, dirB, marginA, marginB, paddingA, paddingB, _ref;
|
||||
if (isWindow(elem)) {
|
||||
base = document.documentElement[{
|
||||
height: 'clientHeight',
|
||||
width: 'clientWidth'
|
||||
}[measure]];
|
||||
return {
|
||||
base: base,
|
||||
padding: 0,
|
||||
border: 0,
|
||||
margin: 0
|
||||
};
|
||||
}
|
||||
_ref = {
|
||||
width: [elem.offsetWidth, 'Left', 'Right'],
|
||||
height: [elem.offsetHeight, 'Top', 'Bottom']
|
||||
}[measure], base = _ref[0], dirA = _ref[1], dirB = _ref[2];
|
||||
computedStyle = getStyle(elem);
|
||||
paddingA = convertToPx(elem, computedStyle['padding' + dirA]) || 0;
|
||||
paddingB = convertToPx(elem, computedStyle['padding' + dirB]) || 0;
|
||||
borderA = convertToPx(elem, computedStyle['border' + dirA + 'Width']) || 0;
|
||||
borderB = convertToPx(elem, computedStyle['border' + dirB + 'Width']) || 0;
|
||||
computedMarginA = computedStyle['margin' + dirA];
|
||||
computedMarginB = computedStyle['margin' + dirB];
|
||||
marginA = convertToPx(elem, computedMarginA) || 0;
|
||||
marginB = convertToPx(elem, computedMarginB) || 0;
|
||||
return {
|
||||
base: base,
|
||||
padding: paddingA + paddingB,
|
||||
border: borderA + borderB,
|
||||
margin: marginA + marginB
|
||||
};
|
||||
};
|
||||
getWidthHeight = function(elem, direction, measure) {
|
||||
var computedStyle, measurements, result;
|
||||
measurements = getMeasurements(elem, direction);
|
||||
if (measurements.base > 0) {
|
||||
return {
|
||||
base: measurements.base - measurements.padding - measurements.border,
|
||||
outer: measurements.base,
|
||||
outerfull: measurements.base + measurements.margin
|
||||
}[measure];
|
||||
} else {
|
||||
computedStyle = getStyle(elem);
|
||||
result = computedStyle[direction];
|
||||
if (result < 0 || result === null) {
|
||||
result = elem.style[direction] || 0;
|
||||
}
|
||||
result = parseFloat(result) || 0;
|
||||
return {
|
||||
base: result - measurements.padding - measurements.border,
|
||||
outer: result,
|
||||
outerfull: result + measurements.padding + measurements.border + measurements.margin
|
||||
}[measure];
|
||||
}
|
||||
};
|
||||
return angular.forEach({
|
||||
before: function(newElem) {
|
||||
var children, elem, i, parent, self, _i, _ref;
|
||||
self = this;
|
||||
elem = self[0];
|
||||
parent = self.parent();
|
||||
children = parent.contents();
|
||||
if (children[0] === elem) {
|
||||
return parent.prepend(newElem);
|
||||
} else {
|
||||
for (i = _i = 1, _ref = children.length - 1; 1 <= _ref ? _i <= _ref : _i >= _ref; i = 1 <= _ref ? ++_i : --_i) {
|
||||
if (children[i] === elem) {
|
||||
angular.element(children[i - 1]).after(newElem);
|
||||
return;
|
||||
}
|
||||
}
|
||||
throw new Error('invalid DOM structure ' + elem.outerHTML);
|
||||
}
|
||||
},
|
||||
height: function(value) {
|
||||
var self;
|
||||
self = this;
|
||||
if (angular.isDefined(value)) {
|
||||
if (angular.isNumber(value)) {
|
||||
value = value + 'px';
|
||||
}
|
||||
return css.call(self, 'height', value);
|
||||
} else {
|
||||
return getWidthHeight(this[0], 'height', 'base');
|
||||
}
|
||||
},
|
||||
outerHeight: function(option) {
|
||||
return getWidthHeight(this[0], 'height', option ? 'outerfull' : 'outer');
|
||||
},
|
||||
/*
|
||||
UIScroller no longer relies on jQuery method offset. The jQLite implementation of the method
|
||||
is kept here just for the reference. Also the offset setter method was never implemented
|
||||
*/
|
||||
|
||||
offset: function(value) {
|
||||
var box, doc, docElem, elem, self, win;
|
||||
self = this;
|
||||
if (arguments.length) {
|
||||
if (value === void 0) {
|
||||
return self;
|
||||
} else {
|
||||
throw new Error('offset setter method is not implemented');
|
||||
}
|
||||
}
|
||||
box = {
|
||||
top: 0,
|
||||
left: 0
|
||||
};
|
||||
elem = self[0];
|
||||
doc = elem && elem.ownerDocument;
|
||||
if (!doc) {
|
||||
return;
|
||||
}
|
||||
docElem = doc.documentElement;
|
||||
if (elem.getBoundingClientRect != null) {
|
||||
box = elem.getBoundingClientRect();
|
||||
}
|
||||
win = doc.defaultView || doc.parentWindow;
|
||||
return {
|
||||
top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
|
||||
left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)
|
||||
};
|
||||
},
|
||||
scrollTop: function(value) {
|
||||
return scrollTo(this, 'top', value);
|
||||
},
|
||||
scrollLeft: function(value) {
|
||||
return scrollTo(this, 'left', value);
|
||||
}
|
||||
}, function(value, key) {
|
||||
if (!element.prototype[key]) {
|
||||
return element.prototype[key] = value;
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
}
|
||||
]).run([
|
||||
'$log', '$window', 'jqLiteExtras', function(console, window, jqLiteExtras) {
|
||||
if (!window.jQuery) {
|
||||
return jqLiteExtras.registerFor(angular.element);
|
||||
}
|
||||
}
|
||||
]);
|
||||
|
||||
/*
|
||||
//# sourceURL=src/scripts/ui-scroll-jqlite.js
|
||||
*/
|
||||
|
||||
576
app/src/main/assets/dist/scroll.js
vendored
Normal file
576
app/src/main/assets/dist/scroll.js
vendored
Normal file
@ -0,0 +1,576 @@
|
||||
'use strict';
|
||||
/*
|
||||
globals: angular, window
|
||||
|
||||
List of used element methods available in JQuery but not in JQuery Lite
|
||||
|
||||
element.before(elem)
|
||||
element.height()
|
||||
element.outerHeight(true)
|
||||
element.height(value) = only for Top/Bottom padding elements
|
||||
element.scrollTop()
|
||||
element.scrollTop(value)
|
||||
*/
|
||||
|
||||
angular.module('ui.scroll', []).directive('uiScrollViewport', [
|
||||
'$log', function() {
|
||||
return {
|
||||
controller: [
|
||||
'$scope', '$element', function(scope, element) {
|
||||
return element;
|
||||
}
|
||||
]
|
||||
};
|
||||
}
|
||||
]).directive('uiScroll', [
|
||||
'$log', '$injector', '$rootScope', '$timeout', function(console, $injector, $rootScope, $timeout) {
|
||||
return {
|
||||
require: ['?^uiScrollViewport'],
|
||||
transclude: 'element',
|
||||
priority: 1000,
|
||||
terminal: true,
|
||||
compile: function(elementTemplate, attr, linker) {
|
||||
return function($scope, element, $attr, controllers) {
|
||||
var adapter, adjustBuffer, adjustRowHeight, bof, bottomVisiblePos, buffer, bufferPadding, bufferSize, clipBottom, clipTop, datasource, datasourceName, doAdjustment, enqueueFetch, eof, eventListener, fetch, finalize, first, hideElementBeforeAppend, insert, isDatasource, isLoading, itemName, loading, log, match, next, pending, reload, removeFromBuffer, resizeHandler, ridActual, scrollHandler, scrollHeight, shouldLoadBottom, shouldLoadTop, showElementAfterRender, tempScope, topVisible, topVisibleElement, topVisibleItem, topVisiblePos, topVisibleScope, viewport, viewportScope, wheelHandler;
|
||||
log = console.debug || console.log;
|
||||
match = $attr.uiScroll.match(/^\s*(\w+)\s+in\s+(\w+)\s*$/);
|
||||
if (!match) {
|
||||
throw new Error('Expected uiScroll in form of \'_item_ in _datasource_\' but got \'' + $attr.uiScroll + '\'');
|
||||
}
|
||||
itemName = match[1];
|
||||
datasourceName = match[2];
|
||||
isDatasource = function(datasource) {
|
||||
return angular.isObject(datasource) && datasource.get && angular.isFunction(datasource.get);
|
||||
};
|
||||
datasource = $scope[datasourceName];
|
||||
if (!isDatasource(datasource)) {
|
||||
datasource = $injector.get(datasourceName);
|
||||
if (!isDatasource(datasource)) {
|
||||
throw new Error('' + datasourceName + ' is not a valid datasource');
|
||||
}
|
||||
}
|
||||
bufferSize = Math.max(3, +$attr.bufferSize || 10);
|
||||
bufferPadding = function() {
|
||||
return viewport.outerHeight() * Math.max(0.1, +$attr.padding || 0.1);
|
||||
};
|
||||
scrollHeight = function(elem) {
|
||||
var _ref;
|
||||
return (_ref = elem[0].scrollHeight) != null ? _ref : elem[0].document.documentElement.scrollHeight;
|
||||
};
|
||||
adapter = null;
|
||||
linker(tempScope = $scope.$new(), function(template) {
|
||||
var bottomPadding, createPadding, padding, repeaterType, topPadding, viewport;
|
||||
repeaterType = template[0].localName;
|
||||
if (repeaterType === 'dl') {
|
||||
throw new Error('ui-scroll directive does not support <' + template[0].localName + '> as a repeating tag: ' + template[0].outerHTML);
|
||||
}
|
||||
if (repeaterType !== 'li' && repeaterType !== 'tr') {
|
||||
repeaterType = 'div';
|
||||
}
|
||||
viewport = controllers[0] || angular.element(window);
|
||||
viewport.css({
|
||||
'overflow-y': 'auto',
|
||||
'display': 'block'
|
||||
});
|
||||
padding = function(repeaterType) {
|
||||
var div, result, table;
|
||||
switch (repeaterType) {
|
||||
case 'tr':
|
||||
table = angular.element('<table><tr><td><div></div></td></tr></table>');
|
||||
div = table.find('div');
|
||||
result = table.find('tr');
|
||||
result.paddingHeight = function() {
|
||||
return div.height.apply(div, arguments);
|
||||
};
|
||||
return result;
|
||||
default:
|
||||
result = angular.element('<' + repeaterType + '></' + repeaterType + '>');
|
||||
result.paddingHeight = result.height;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
createPadding = function(padding, element, direction) {
|
||||
element[{
|
||||
top: 'before',
|
||||
bottom: 'after'
|
||||
}[direction]](padding);
|
||||
return {
|
||||
paddingHeight: function() {
|
||||
return padding.paddingHeight.apply(padding, arguments);
|
||||
},
|
||||
insert: function(element) {
|
||||
return padding[{
|
||||
top: 'after',
|
||||
bottom: 'before'
|
||||
}[direction]](element);
|
||||
}
|
||||
};
|
||||
};
|
||||
topPadding = createPadding(padding(repeaterType), element, 'top');
|
||||
bottomPadding = createPadding(padding(repeaterType), element, 'bottom');
|
||||
tempScope.$destroy();
|
||||
return adapter = {
|
||||
viewport: viewport,
|
||||
topPadding: topPadding.paddingHeight,
|
||||
bottomPadding: bottomPadding.paddingHeight,
|
||||
append: bottomPadding.insert,
|
||||
prepend: topPadding.insert,
|
||||
bottomDataPos: function() {
|
||||
return scrollHeight(viewport) - bottomPadding.paddingHeight();
|
||||
},
|
||||
topDataPos: function() {
|
||||
return topPadding.paddingHeight();
|
||||
}
|
||||
};
|
||||
});
|
||||
viewport = adapter.viewport;
|
||||
viewportScope = viewport.scope() || $rootScope;
|
||||
if (angular.isDefined($attr.topVisible)) {
|
||||
topVisibleItem = function(item) {
|
||||
return viewportScope[$attr.topVisible] = item;
|
||||
};
|
||||
}
|
||||
if (angular.isDefined($attr.topVisibleElement)) {
|
||||
topVisibleElement = function(element) {
|
||||
return viewportScope[$attr.topVisibleElement] = element;
|
||||
};
|
||||
}
|
||||
if (angular.isDefined($attr.topVisibleScope)) {
|
||||
topVisibleScope = function(scope) {
|
||||
return viewportScope[$attr.topVisibleScope] = scope;
|
||||
};
|
||||
}
|
||||
topVisible = function(item) {
|
||||
if (topVisibleItem) {
|
||||
topVisibleItem(item.scope[itemName]);
|
||||
}
|
||||
if (topVisibleElement) {
|
||||
topVisibleElement(item.element);
|
||||
}
|
||||
if (topVisibleScope) {
|
||||
topVisibleScope(item.scope);
|
||||
}
|
||||
if (datasource.topVisible) {
|
||||
return datasource.topVisible(item);
|
||||
}
|
||||
};
|
||||
if (angular.isDefined($attr.isLoading)) {
|
||||
loading = function(value) {
|
||||
viewportScope[$attr.isLoading] = value;
|
||||
if (datasource.loading) {
|
||||
return datasource.loading(value);
|
||||
}
|
||||
};
|
||||
} else {
|
||||
loading = function(value) {
|
||||
if (datasource.loading) {
|
||||
return datasource.loading(value);
|
||||
}
|
||||
};
|
||||
}
|
||||
ridActual = 0;
|
||||
first = 1;
|
||||
next = 1;
|
||||
buffer = [];
|
||||
pending = [];
|
||||
eof = false;
|
||||
bof = false;
|
||||
isLoading = false;
|
||||
removeFromBuffer = function(start, stop) {
|
||||
var i, _i;
|
||||
for (i = _i = start; start <= stop ? _i < stop : _i > stop; i = start <= stop ? ++_i : --_i) {
|
||||
buffer[i].scope.$destroy();
|
||||
buffer[i].element.remove();
|
||||
}
|
||||
return buffer.splice(start, stop - start);
|
||||
};
|
||||
reload = function() {
|
||||
ridActual++;
|
||||
first = 1;
|
||||
next = 1;
|
||||
removeFromBuffer(0, buffer.length);
|
||||
adapter.topPadding(0);
|
||||
adapter.bottomPadding(0);
|
||||
pending = [];
|
||||
eof = false;
|
||||
bof = false;
|
||||
return adjustBuffer(ridActual, false);
|
||||
};
|
||||
bottomVisiblePos = function() {
|
||||
return viewport.scrollTop() + viewport.outerHeight();
|
||||
};
|
||||
topVisiblePos = function() {
|
||||
return viewport.scrollTop();
|
||||
};
|
||||
shouldLoadBottom = function() {
|
||||
return !eof && adapter.bottomDataPos() < bottomVisiblePos() + bufferPadding();
|
||||
};
|
||||
clipBottom = function() {
|
||||
var bottomHeight, i, item, itemHeight, itemTop, newRow, overage, rowTop, _i, _ref;
|
||||
bottomHeight = 0;
|
||||
overage = 0;
|
||||
for (i = _i = _ref = buffer.length - 1; _ref <= 0 ? _i <= 0 : _i >= 0; i = _ref <= 0 ? ++_i : --_i) {
|
||||
item = buffer[i];
|
||||
itemTop = item.element.offset().top;
|
||||
newRow = rowTop !== itemTop;
|
||||
rowTop = itemTop;
|
||||
if (newRow) {
|
||||
itemHeight = item.element.outerHeight(true);
|
||||
}
|
||||
if (adapter.bottomDataPos() - bottomHeight - itemHeight > bottomVisiblePos() + bufferPadding()) {
|
||||
if (newRow) {
|
||||
bottomHeight += itemHeight;
|
||||
}
|
||||
overage++;
|
||||
eof = false;
|
||||
} else {
|
||||
if (newRow) {
|
||||
break;
|
||||
}
|
||||
overage++;
|
||||
}
|
||||
}
|
||||
if (overage > 0) {
|
||||
adapter.bottomPadding(adapter.bottomPadding() + bottomHeight);
|
||||
removeFromBuffer(buffer.length - overage, buffer.length);
|
||||
next -= overage;
|
||||
return log('clipped off bottom ' + overage + ' bottom padding ' + (adapter.bottomPadding()));
|
||||
}
|
||||
};
|
||||
shouldLoadTop = function() {
|
||||
return !bof && (adapter.topDataPos() > topVisiblePos() - bufferPadding());
|
||||
};
|
||||
clipTop = function() {
|
||||
var item, itemHeight, itemTop, newRow, overage, rowTop, topHeight, _i, _len;
|
||||
topHeight = 0;
|
||||
overage = 0;
|
||||
for (_i = 0, _len = buffer.length; _i < _len; _i++) {
|
||||
item = buffer[_i];
|
||||
itemTop = item.element.offset().top;
|
||||
newRow = rowTop !== itemTop;
|
||||
rowTop = itemTop;
|
||||
if (newRow) {
|
||||
itemHeight = item.element.outerHeight(true);
|
||||
}
|
||||
if (adapter.topDataPos() + topHeight + itemHeight < topVisiblePos() - bufferPadding()) {
|
||||
if (newRow) {
|
||||
topHeight += itemHeight;
|
||||
}
|
||||
overage++;
|
||||
bof = false;
|
||||
} else {
|
||||
if (newRow) {
|
||||
break;
|
||||
}
|
||||
overage++;
|
||||
}
|
||||
}
|
||||
if (overage > 0) {
|
||||
adapter.topPadding(adapter.topPadding() + topHeight);
|
||||
removeFromBuffer(0, overage);
|
||||
first += overage;
|
||||
return log('clipped off top ' + overage + ' top padding ' + (adapter.topPadding()));
|
||||
}
|
||||
};
|
||||
enqueueFetch = function(rid, direction, scrolling) {
|
||||
if (!isLoading) {
|
||||
isLoading = true;
|
||||
loading(true);
|
||||
}
|
||||
if (pending.push(direction) === 1) {
|
||||
return fetch(rid, scrolling);
|
||||
}
|
||||
};
|
||||
hideElementBeforeAppend = function(element) {
|
||||
element.displayTemp = element.css('display');
|
||||
return element.css('display', 'none');
|
||||
};
|
||||
showElementAfterRender = function(element) {
|
||||
if (element.hasOwnProperty('displayTemp')) {
|
||||
return element.css('display', element.displayTemp);
|
||||
}
|
||||
};
|
||||
insert = function(index, item) {
|
||||
var itemScope, toBeAppended, wrapper;
|
||||
itemScope = $scope.$new();
|
||||
itemScope[itemName] = item;
|
||||
toBeAppended = index > first;
|
||||
itemScope.$index = index;
|
||||
if (toBeAppended) {
|
||||
itemScope.$index--;
|
||||
}
|
||||
wrapper = {
|
||||
scope: itemScope
|
||||
};
|
||||
linker(itemScope, function(clone) {
|
||||
wrapper.element = clone;
|
||||
if (toBeAppended) {
|
||||
if (index === next) {
|
||||
hideElementBeforeAppend(clone);
|
||||
adapter.append(clone);
|
||||
return buffer.push(wrapper);
|
||||
} else {
|
||||
buffer[index - first].element.after(clone);
|
||||
return buffer.splice(index - first + 1, 0, wrapper);
|
||||
}
|
||||
} else {
|
||||
hideElementBeforeAppend(clone);
|
||||
adapter.prepend(clone);
|
||||
return buffer.unshift(wrapper);
|
||||
}
|
||||
});
|
||||
return {
|
||||
appended: toBeAppended,
|
||||
wrapper: wrapper
|
||||
};
|
||||
};
|
||||
adjustRowHeight = function(appended, wrapper) {
|
||||
var newHeight;
|
||||
if (appended) {
|
||||
return adapter.bottomPadding(Math.max(0, adapter.bottomPadding() - wrapper.element.outerHeight(true)));
|
||||
} else {
|
||||
newHeight = adapter.topPadding() - wrapper.element.outerHeight(true);
|
||||
if (newHeight >= 0) {
|
||||
return adapter.topPadding(newHeight);
|
||||
} else {
|
||||
return viewport.scrollTop(viewport.scrollTop() + wrapper.element.outerHeight(true));
|
||||
}
|
||||
}
|
||||
};
|
||||
doAdjustment = function(rid, scrolling, finalize) {
|
||||
var item, itemHeight, itemTop, newRow, rowTop, topHeight, _i, _len, _results;
|
||||
log('top {actual=' + (adapter.topDataPos()) + ' visible from=' + (topVisiblePos()) + ' bottom {visible through=' + (bottomVisiblePos()) + ' actual=' + (adapter.bottomDataPos()) + '}');
|
||||
if (shouldLoadBottom()) {
|
||||
enqueueFetch(rid, true, scrolling);
|
||||
} else {
|
||||
if (shouldLoadTop()) {
|
||||
enqueueFetch(rid, false, scrolling);
|
||||
}
|
||||
}
|
||||
if (finalize) {
|
||||
finalize(rid);
|
||||
}
|
||||
if (pending.length === 0) {
|
||||
topHeight = 0;
|
||||
_results = [];
|
||||
for (_i = 0, _len = buffer.length; _i < _len; _i++) {
|
||||
item = buffer[_i];
|
||||
itemTop = item.element.offset().top;
|
||||
newRow = rowTop !== itemTop;
|
||||
rowTop = itemTop;
|
||||
if (newRow) {
|
||||
itemHeight = item.element.outerHeight(true);
|
||||
}
|
||||
if (newRow && (adapter.topDataPos() + topHeight + itemHeight < topVisiblePos())) {
|
||||
_results.push(topHeight += itemHeight);
|
||||
} else {
|
||||
if (newRow) {
|
||||
topVisible(item);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return _results;
|
||||
}
|
||||
};
|
||||
adjustBuffer = function(rid, scrolling, newItems, finalize) {
|
||||
if (newItems && newItems.length) {
|
||||
return $timeout(function() {
|
||||
var itemTop, row, rowTop, rows, _i, _j, _len, _len1;
|
||||
rows = [];
|
||||
for (_i = 0, _len = newItems.length; _i < _len; _i++) {
|
||||
row = newItems[_i];
|
||||
element = row.wrapper.element;
|
||||
showElementAfterRender(element);
|
||||
itemTop = element.offset().top;
|
||||
if (rowTop !== itemTop) {
|
||||
rows.push(row);
|
||||
rowTop = itemTop;
|
||||
}
|
||||
}
|
||||
for (_j = 0, _len1 = rows.length; _j < _len1; _j++) {
|
||||
row = rows[_j];
|
||||
adjustRowHeight(row.appended, row.wrapper);
|
||||
}
|
||||
return doAdjustment(rid, scrolling, finalize);
|
||||
});
|
||||
} else {
|
||||
return doAdjustment(rid, scrolling, finalize);
|
||||
}
|
||||
};
|
||||
finalize = function(rid, scrolling, newItems) {
|
||||
return adjustBuffer(rid, scrolling, newItems, function() {
|
||||
pending.shift();
|
||||
if (pending.length === 0) {
|
||||
isLoading = false;
|
||||
return loading(false);
|
||||
} else {
|
||||
return fetch(rid, scrolling);
|
||||
}
|
||||
});
|
||||
};
|
||||
fetch = function(rid, scrolling) {
|
||||
var direction;
|
||||
direction = pending[0];
|
||||
if (direction) {
|
||||
if (buffer.length && !shouldLoadBottom()) {
|
||||
return finalize(rid, scrolling);
|
||||
} else {
|
||||
return datasource.get(next, bufferSize, function(result) {
|
||||
var item, newItems, _i, _len;
|
||||
if (rid && rid !== ridActual) {
|
||||
return;
|
||||
}
|
||||
newItems = [];
|
||||
if (result.length < bufferSize) {
|
||||
eof = true;
|
||||
adapter.bottomPadding(0);
|
||||
}
|
||||
if (result.length > 0) {
|
||||
clipTop();
|
||||
for (_i = 0, _len = result.length; _i < _len; _i++) {
|
||||
item = result[_i];
|
||||
newItems.push(insert(++next, item));
|
||||
}
|
||||
}
|
||||
return finalize(rid, scrolling, newItems);
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (buffer.length && !shouldLoadTop()) {
|
||||
return finalize(rid, scrolling);
|
||||
} else {
|
||||
return datasource.get(first - bufferSize, bufferSize, function(result) {
|
||||
var i, newItems, _i, _ref;
|
||||
if (rid && rid !== ridActual) {
|
||||
return;
|
||||
}
|
||||
newItems = [];
|
||||
if (result.length < bufferSize) {
|
||||
bof = true;
|
||||
adapter.topPadding(0);
|
||||
}
|
||||
if (result.length > 0) {
|
||||
if (buffer.length) {
|
||||
clipBottom();
|
||||
}
|
||||
for (i = _i = _ref = result.length - 1; _ref <= 0 ? _i <= 0 : _i >= 0; i = _ref <= 0 ? ++_i : --_i) {
|
||||
newItems.unshift(insert(--first, result[i]));
|
||||
}
|
||||
}
|
||||
return finalize(rid, scrolling, newItems);
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
resizeHandler = function() {
|
||||
if (!$rootScope.$$phase && !isLoading) {
|
||||
adjustBuffer(null, false);
|
||||
return $scope.$apply();
|
||||
}
|
||||
};
|
||||
viewport.bind('resize', resizeHandler);
|
||||
scrollHandler = function() {
|
||||
if (!$rootScope.$$phase && !isLoading) {
|
||||
adjustBuffer(null, true);
|
||||
return $scope.$apply();
|
||||
}
|
||||
};
|
||||
viewport.bind('scroll', scrollHandler);
|
||||
wheelHandler = function(event) {
|
||||
var scrollTop, yMax;
|
||||
scrollTop = viewport[0].scrollTop;
|
||||
yMax = viewport[0].scrollHeight - viewport[0].clientHeight;
|
||||
if ((scrollTop === 0 && !bof) || (scrollTop === yMax && !eof)) {
|
||||
return event.preventDefault();
|
||||
}
|
||||
};
|
||||
viewport.bind('mousewheel', wheelHandler);
|
||||
$scope.$watch(datasource.revision, function() {
|
||||
return reload();
|
||||
});
|
||||
if (datasource.scope) {
|
||||
eventListener = datasource.scope.$new();
|
||||
} else {
|
||||
eventListener = $scope.$new();
|
||||
}
|
||||
$scope.$on('$destroy', function() {
|
||||
eventListener.$destroy();
|
||||
viewport.unbind('resize', resizeHandler);
|
||||
viewport.unbind('scroll', scrollHandler);
|
||||
return viewport.unbind('mousewheel', wheelHandler);
|
||||
});
|
||||
eventListener.$on('update.items', function(event, locator, newItem) {
|
||||
var wrapper, _fn, _i, _len, _ref;
|
||||
if (angular.isFunction(locator)) {
|
||||
_fn = function(wrapper) {
|
||||
return locator(wrapper.scope);
|
||||
};
|
||||
for (_i = 0, _len = buffer.length; _i < _len; _i++) {
|
||||
wrapper = buffer[_i];
|
||||
_fn(wrapper);
|
||||
}
|
||||
} else {
|
||||
if ((0 <= (_ref = locator - first - 1) && _ref < buffer.length)) {
|
||||
buffer[locator - first - 1].scope[itemName] = newItem;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
});
|
||||
eventListener.$on('delete.items', function(event, locator) {
|
||||
var i, item, temp, wrapper, _fn, _i, _j, _k, _len, _len1, _len2, _ref;
|
||||
if (angular.isFunction(locator)) {
|
||||
temp = [];
|
||||
for (_i = 0, _len = buffer.length; _i < _len; _i++) {
|
||||
item = buffer[_i];
|
||||
temp.unshift(item);
|
||||
}
|
||||
_fn = function(wrapper) {
|
||||
if (locator(wrapper.scope)) {
|
||||
removeFromBuffer(temp.length - 1 - i, temp.length - i);
|
||||
return next--;
|
||||
}
|
||||
};
|
||||
for (i = _j = 0, _len1 = temp.length; _j < _len1; i = ++_j) {
|
||||
wrapper = temp[i];
|
||||
_fn(wrapper);
|
||||
}
|
||||
} else {
|
||||
if ((0 <= (_ref = locator - first - 1) && _ref < buffer.length)) {
|
||||
removeFromBuffer(locator - first - 1, locator - first);
|
||||
next--;
|
||||
}
|
||||
}
|
||||
for (i = _k = 0, _len2 = buffer.length; _k < _len2; i = ++_k) {
|
||||
item = buffer[i];
|
||||
item.scope.$index = first + i;
|
||||
}
|
||||
return adjustBuffer(null, false);
|
||||
});
|
||||
return eventListener.$on('insert.item', function(event, locator, item) {
|
||||
var i, inserted, _i, _len, _ref;
|
||||
inserted = [];
|
||||
if (angular.isFunction(locator)) {
|
||||
throw new Error('not implemented - Insert with locator function');
|
||||
} else {
|
||||
if ((0 <= (_ref = locator - first - 1) && _ref < buffer.length)) {
|
||||
inserted.push(insert(locator, item));
|
||||
next++;
|
||||
}
|
||||
}
|
||||
for (i = _i = 0, _len = buffer.length; _i < _len; i = ++_i) {
|
||||
item = buffer[i];
|
||||
item.scope.$index = first + i;
|
||||
}
|
||||
return adjustBuffer(null, false, inserted);
|
||||
});
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
]);
|
||||
|
||||
/*
|
||||
//# sourceURL=src/scripts/ui-scroll.js
|
||||
*/
|
||||
|
||||
Loading…
Reference in New Issue
Block a user