import PropTypes from 'prop-types';
import IntersectionObserverArticleContainer from '../containers/intersection_observer_article_container';
import LoadMore from './load_more';
+import LoadPending from './load_pending';
import IntersectionObserverWrapper from '../features/ui/util/intersection_observer_wrapper';
import { throttle } from 'lodash';
import { List as ImmutableList } from 'immutable';
static propTypes = {
scrollKey: PropTypes.string.isRequired,
onLoadMore: PropTypes.func,
+ onLoadPending: PropTypes.func,
onScrollToTop: PropTypes.func,
onScroll: PropTypes.func,
trackScroll: PropTypes.bool,
isLoading: PropTypes.bool,
showLoading: PropTypes.bool,
hasMore: PropTypes.bool,
+ numPending: PropTypes.number,
prepend: PropTypes.node,
alwaysPrepend: PropTypes.bool,
- alwaysShowScrollbar: PropTypes.bool,
emptyMessage: PropTypes.node,
children: PropTypes.node,
+ bindToDocument: PropTypes.bool,
};
static defaultProps = {
state = {
fullscreen: null,
+ cachedMediaWidth: 250, // Default media/card width using default Mastodon theme
};
intersectionObserverWrapper = new IntersectionObserverWrapper();
handleScroll = throttle(() => {
if (this.node) {
- const { scrollTop, scrollHeight, clientHeight } = this.node;
+ const scrollTop = this.getScrollTop();
+ const scrollHeight = this.getScrollHeight();
+ const clientHeight = this.getClientHeight();
const offset = scrollHeight - scrollTop - clientHeight;
- if (400 > offset && this.props.onLoadMore && !this.props.isLoading) {
+ if (400 > offset && this.props.onLoadMore && this.props.hasMore && !this.props.isLoading) {
this.props.onLoadMore();
}
scrollToTopOnMouseIdle = false;
setScrollTop = newScrollTop => {
- if (this.node.scrollTop !== newScrollTop) {
+ if (this.getScrollTop() !== newScrollTop) {
this.lastScrollWasSynthetic = true;
- this.node.scrollTop = newScrollTop;
+
+ if (this.props.bindToDocument) {
+ document.scrollingElement.scrollTop = newScrollTop;
+ } else {
+ this.node.scrollTop = newScrollTop;
+ }
}
};
this.clearMouseIdleTimer();
this.mouseIdleTimer = setTimeout(this.handleMouseIdle, MOUSE_IDLE_DELAY);
- if (!this.mouseMovedRecently && this.node.scrollTop === 0) {
+ if (!this.mouseMovedRecently && this.getScrollTop() === 0) {
// Only set if we just started moving and are scrolled to the top.
this.scrollToTopOnMouseIdle = true;
}
this.handleScroll();
}
+ getScrollPosition = () => {
+ if (this.node && (this.getScrollTop() > 0 || this.mouseMovedRecently)) {
+ return { height: this.getScrollHeight(), top: this.getScrollTop() };
+ } else {
+ return null;
+ }
+ }
+
+ getScrollTop = () => {
+ return this.props.bindToDocument ? document.scrollingElement.scrollTop : this.node.scrollTop;
+ }
+
+ getScrollHeight = () => {
+ return this.props.bindToDocument ? document.scrollingElement.scrollHeight : this.node.scrollHeight;
+ }
+
+ getClientHeight = () => {
+ return this.props.bindToDocument ? document.scrollingElement.clientHeight : this.node.clientHeight;
+ }
+
+ updateScrollBottom = (snapshot) => {
+ const newScrollTop = this.getScrollHeight() - snapshot;
+
+ this.setScrollTop(newScrollTop);
+ }
+
getSnapshotBeforeUpdate (prevProps) {
const someItemInserted = React.Children.count(prevProps.children) > 0 &&
React.Children.count(prevProps.children) < React.Children.count(this.props.children) &&
this.getFirstChildKey(prevProps) !== this.getFirstChildKey(this.props);
+ const pendingChanged = (prevProps.numPending > 0) !== (this.props.numPending > 0);
- if (someItemInserted && (this.node.scrollTop > 0 || this.mouseMovedRecently)) {
- return this.node.scrollHeight - this.node.scrollTop;
+ if (pendingChanged || someItemInserted && (this.getScrollTop() > 0 || this.mouseMovedRecently)) {
+ return this.getScrollHeight() - this.getScrollTop();
} else {
return null;
}
// Reset the scroll position when a new child comes in in order not to
// jerk the scrollbar around if you're already scrolled down the page.
if (snapshot !== null) {
- this.setScrollTop(this.node.scrollHeight - snapshot);
+ this.setScrollTop(this.getScrollHeight() - snapshot);
+ }
+ }
+
+ cacheMediaWidth = (width) => {
+ if (width && this.state.cachedMediaWidth !== width) {
+ this.setState({ cachedMediaWidth: width });
}
}
this.clearMouseIdleTimer();
this.detachScrollListener();
this.detachIntersectionObserver();
+
detachFullscreenListener(this.onFullScreenChange);
}
}
attachIntersectionObserver () {
- this.intersectionObserverWrapper.connect({
+ let nodeOptions = {
root: this.node,
rootMargin: '300% 0px',
- });
+ };
+
+ this.intersectionObserverWrapper
+ .connect(this.props.bindToDocument ? {} : nodeOptions);
}
detachIntersectionObserver () {
}
attachScrollListener () {
- this.node.addEventListener('scroll', this.handleScroll);
- this.node.addEventListener('wheel', this.handleWheel);
+ if (this.props.bindToDocument) {
+ document.addEventListener('scroll', this.handleScroll);
+ document.addEventListener('wheel', this.handleWheel);
+ } else {
+ this.node.addEventListener('scroll', this.handleScroll);
+ this.node.addEventListener('wheel', this.handleWheel);
+ }
}
detachScrollListener () {
- this.node.removeEventListener('scroll', this.handleScroll);
- this.node.removeEventListener('wheel', this.handleWheel);
+ if (this.props.bindToDocument) {
+ document.removeEventListener('scroll', this.handleScroll);
+ document.removeEventListener('wheel', this.handleWheel);
+ } else {
+ this.node.removeEventListener('scroll', this.handleScroll);
+ this.node.removeEventListener('wheel', this.handleWheel);
+ }
}
getFirstChildKey (props) {
this.props.onLoadMore();
}
+ handleLoadPending = e => {
+ e.preventDefault();
+ this.props.onLoadPending();
+ // Prevent the weird scroll-jumping behavior, as we explicitly don't want to
+ // scroll to top, and we know the scroll height is going to change
+ this.scrollToTopOnMouseIdle = false;
+ this.lastScrollWasSynthetic = false;
+ this.clearMouseIdleTimer();
+ this.mouseIdleTimer = setTimeout(this.handleMouseIdle, MOUSE_IDLE_DELAY);
+ this.mouseMovedRecently = true;
+ }
+
render () {
- const { children, scrollKey, trackScroll, shouldUpdateScroll, showLoading, isLoading, hasMore, prepend, alwaysPrepend, alwaysShowScrollbar, emptyMessage, onLoadMore } = this.props;
+ const { children, scrollKey, trackScroll, shouldUpdateScroll, showLoading, isLoading, hasMore, numPending, prepend, alwaysPrepend, emptyMessage, onLoadMore } = this.props;
const { fullscreen } = this.state;
const childrenCount = React.Children.count(children);
- const loadMore = (hasMore && childrenCount > 0 && onLoadMore) ? <LoadMore visible={!isLoading} onClick={this.handleLoadMore} /> : null;
+ const loadMore = (hasMore && onLoadMore) ? <LoadMore visible={!isLoading} onClick={this.handleLoadMore} /> : null;
+ const loadPending = (numPending > 0) ? <LoadPending count={numPending} onClick={this.handleLoadPending} /> : null;
let scrollableArea = null;
if (showLoading) {
</div>
</div>
);
- } else if (isLoading || childrenCount > 0 || !emptyMessage) {
+ } else if (isLoading || childrenCount > 0 || hasMore || !emptyMessage) {
scrollableArea = (
<div className={classNames('scrollable', { fullscreen })} ref={this.setRef} onMouseMove={this.handleMouseMove}>
<div role='feed' className='item-list'>
{prepend}
+ {loadPending}
+
{React.Children.map(this.props.children, (child, index) => (
<IntersectionObserverArticleContainer
key={child.key}
intersectionObserverWrapper={this.intersectionObserverWrapper}
saveHeightKey={trackScroll ? `${this.context.router.route.location.key}:${scrollKey}` : null}
>
- {child}
+ {React.cloneElement(child, {
+ getScrollPosition: this.getScrollPosition,
+ updateScrollBottom: this.updateScrollBottom,
+ cachedMediaWidth: this.state.cachedMediaWidth,
+ cacheMediaWidth: this.cacheMediaWidth,
+ })}
</IntersectionObserverArticleContainer>
))}
</div>
);
} else {
- const scrollable = alwaysShowScrollbar;
-
scrollableArea = (
- <div className={classNames({ scrollable, fullscreen })} ref={this.setRef} style={{ flex: '1 1 auto', display: 'flex', flexDirection: 'column' }}>
+ <div className={classNames('scrollable scrollable--flex', { fullscreen })} ref={this.setRef}>
{alwaysPrepend && prepend}
<div className='empty-column-indicator'>
git-æsc / mastodon.git / blobdiff