|
|
|
/**
|
|
|
|
* Copyright (c) 2015-present, Facebook, Inc.
|
|
|
|
*
|
|
|
|
* This source code is licensed under the MIT license found in the
|
|
|
|
* LICENSE file in the root directory of this source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#import "RCTMJScrollView.h"
|
|
|
|
|
|
|
|
#import <UIKit/UIKit.h>
|
|
|
|
|
|
|
|
#import <React/RCTConvert.h>
|
|
|
|
#import <React/RCTEventDispatcher.h>
|
|
|
|
#import <React/RCTLog.h>
|
|
|
|
#import <React/RCTUIManager.h>
|
|
|
|
#import <React/RCTUIManagerObserverCoordinator.h>
|
|
|
|
#import <React/RCTUIManagerUtils.h>
|
|
|
|
#import <React/RCTUtils.h>
|
|
|
|
#import "UIView+Private1.h"
|
|
|
|
#import <React/UIView+React.h>
|
|
|
|
#import "MJRefresh.h"
|
|
|
|
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
#import <React/RCTRefreshControl.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
@interface RCTMJScrollEvent : NSObject <RCTEvent>
|
|
|
|
|
|
|
|
- (instancetype)initWithEventName:(NSString *)eventName
|
|
|
|
reactTag:(NSNumber *)reactTag
|
|
|
|
scrollViewContentOffset:(CGPoint)scrollViewContentOffset
|
|
|
|
scrollViewContentInset:(UIEdgeInsets)scrollViewContentInset
|
|
|
|
scrollViewContentSize:(CGSize)scrollViewContentSize
|
|
|
|
scrollViewFrame:(CGRect)scrollViewFrame
|
|
|
|
scrollViewZoomScale:(CGFloat)scrollViewZoomScale
|
|
|
|
userData:(NSDictionary *)userData
|
|
|
|
coalescingKey:(uint16_t)coalescingKey NS_DESIGNATED_INITIALIZER;
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
@implementation RCTMJScrollEvent
|
|
|
|
{
|
|
|
|
CGPoint _scrollViewContentOffset;
|
|
|
|
UIEdgeInsets _scrollViewContentInset;
|
|
|
|
CGSize _scrollViewContentSize;
|
|
|
|
CGRect _scrollViewFrame;
|
|
|
|
CGFloat _scrollViewZoomScale;
|
|
|
|
NSDictionary *_userData;
|
|
|
|
uint16_t _coalescingKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
@synthesize viewTag = _viewTag;
|
|
|
|
@synthesize eventName = _eventName;
|
|
|
|
|
|
|
|
- (instancetype)initWithEventName:(NSString *)eventName
|
|
|
|
reactTag:(NSNumber *)reactTag
|
|
|
|
scrollViewContentOffset:(CGPoint)scrollViewContentOffset
|
|
|
|
scrollViewContentInset:(UIEdgeInsets)scrollViewContentInset
|
|
|
|
scrollViewContentSize:(CGSize)scrollViewContentSize
|
|
|
|
scrollViewFrame:(CGRect)scrollViewFrame
|
|
|
|
scrollViewZoomScale:(CGFloat)scrollViewZoomScale
|
|
|
|
userData:(NSDictionary *)userData
|
|
|
|
coalescingKey:(uint16_t)coalescingKey
|
|
|
|
{
|
|
|
|
RCTAssertParam(reactTag);
|
|
|
|
|
|
|
|
if ((self = [super init])) {
|
|
|
|
_eventName = [eventName copy];
|
|
|
|
_viewTag = reactTag;
|
|
|
|
_scrollViewContentOffset = scrollViewContentOffset;
|
|
|
|
_scrollViewContentInset = scrollViewContentInset;
|
|
|
|
_scrollViewContentSize = scrollViewContentSize;
|
|
|
|
_scrollViewFrame = scrollViewFrame;
|
|
|
|
_scrollViewZoomScale = scrollViewZoomScale;
|
|
|
|
_userData = userData;
|
|
|
|
_coalescingKey = coalescingKey;
|
|
|
|
}
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
RCT_NOT_IMPLEMENTED(- (instancetype)init)
|
|
|
|
|
|
|
|
- (uint16_t)coalescingKey
|
|
|
|
{
|
|
|
|
return _coalescingKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (NSDictionary *)body
|
|
|
|
{
|
|
|
|
NSDictionary *body = @{
|
|
|
|
@"contentOffset": @{
|
|
|
|
@"x": @(_scrollViewContentOffset.x),
|
|
|
|
@"y": @(_scrollViewContentOffset.y)
|
|
|
|
},
|
|
|
|
@"contentInset": @{
|
|
|
|
@"top": @(_scrollViewContentInset.top),
|
|
|
|
@"left": @(_scrollViewContentInset.left),
|
|
|
|
@"bottom": @(_scrollViewContentInset.bottom),
|
|
|
|
@"right": @(_scrollViewContentInset.right)
|
|
|
|
},
|
|
|
|
@"contentSize": @{
|
|
|
|
@"width": @(_scrollViewContentSize.width),
|
|
|
|
@"height": @(_scrollViewContentSize.height)
|
|
|
|
},
|
|
|
|
@"layoutMeasurement": @{
|
|
|
|
@"width": @(_scrollViewFrame.size.width),
|
|
|
|
@"height": @(_scrollViewFrame.size.height)
|
|
|
|
},
|
|
|
|
@"zoomScale": @(_scrollViewZoomScale ?: 1),
|
|
|
|
};
|
|
|
|
|
|
|
|
if (_userData) {
|
|
|
|
NSMutableDictionary *mutableBody = [body mutableCopy];
|
|
|
|
[mutableBody addEntriesFromDictionary:_userData];
|
|
|
|
body = mutableBody;
|
|
|
|
}
|
|
|
|
|
|
|
|
return body;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (BOOL)canCoalesce
|
|
|
|
{
|
|
|
|
return YES;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (RCTMJScrollEvent *)coalesceWithEvent:(RCTMJScrollEvent *)newEvent
|
|
|
|
{
|
|
|
|
NSArray<NSDictionary *> *updatedChildFrames = [_userData[@"updatedChildFrames"] arrayByAddingObjectsFromArray:newEvent->_userData[@"updatedChildFrames"]];
|
|
|
|
if (updatedChildFrames) {
|
|
|
|
NSMutableDictionary *userData = [newEvent->_userData mutableCopy];
|
|
|
|
userData[@"updatedChildFrames"] = updatedChildFrames;
|
|
|
|
newEvent->_userData = userData;
|
|
|
|
}
|
|
|
|
|
|
|
|
return newEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
+ (NSString *)moduleDotMethod
|
|
|
|
{
|
|
|
|
return @"RCTEventEmitter.receiveEvent";
|
|
|
|
}
|
|
|
|
|
|
|
|
- (NSArray *)arguments
|
|
|
|
{
|
|
|
|
return @[self.viewTag, RCTNormalizeInputEventName(self.eventName), [self body]];
|
|
|
|
}
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Include a custom scroll view subclass because we want to limit certain
|
|
|
|
* default UIKit behaviors such as textFields automatically scrolling
|
|
|
|
* scroll views that contain them.
|
|
|
|
*/
|
|
|
|
@interface RCTMJCustomScrollView : UIScrollView<UIGestureRecognizerDelegate>
|
|
|
|
|
|
|
|
@property (nonatomic, assign) BOOL centerContent;
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
@property (nonatomic, strong) RCTRefreshControl *rctRefreshControl;
|
|
|
|
@property (nonatomic, assign) BOOL pinchGestureEnabled;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
|
|
|
|
@implementation RCTMJCustomScrollView
|
|
|
|
|
|
|
|
- (instancetype)initWithFrame:(CGRect)frame
|
|
|
|
{
|
|
|
|
if ((self = [super initWithFrame:frame])) {
|
|
|
|
[self.panGestureRecognizer addTarget:self action:@selector(handleCustomPan:)];
|
|
|
|
|
|
|
|
if ([self respondsToSelector:@selector(setSemanticContentAttribute:)]) {
|
|
|
|
// We intentionaly force `UIScrollView`s `semanticContentAttribute` to `LTR` here
|
|
|
|
// because this attribute affects a position of vertical scrollbar; we don't want this
|
|
|
|
// scrollbar flip because we also flip it with whole `UIScrollView` flip.
|
|
|
|
self.semanticContentAttribute = UISemanticContentAttributeForceLeftToRight;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
_pinchGestureEnabled = YES;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (UIView *)contentView
|
|
|
|
{
|
|
|
|
return ((RCTMJScrollView *)self.superview).contentView;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Whether or not the scroll view interaction should be blocked because
|
|
|
|
* JS was found to be the responder.
|
|
|
|
*/
|
|
|
|
- (BOOL)_shouldDisableScrollInteraction
|
|
|
|
{
|
|
|
|
// Since this may be called on every pan, we need to make sure to only climb
|
|
|
|
// the hierarchy on rare occasions.
|
|
|
|
UIView *JSResponder = [RCTUIManager JSResponder];
|
|
|
|
if (JSResponder && JSResponder != self.superview) {
|
|
|
|
BOOL superviewHasResponder = [self isDescendantOfView:JSResponder];
|
|
|
|
return superviewHasResponder;
|
|
|
|
}
|
|
|
|
return NO;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)handleCustomPan:(__unused UIPanGestureRecognizer *)sender
|
|
|
|
{
|
|
|
|
if ([self _shouldDisableScrollInteraction] && ![[RCTUIManager JSResponder] isKindOfClass:[RCTMJScrollView class]]) {
|
|
|
|
self.panGestureRecognizer.enabled = NO;
|
|
|
|
self.panGestureRecognizer.enabled = YES;
|
|
|
|
// TODO: If mid bounce, animate the scroll view to a non-bounced position
|
|
|
|
// while disabling (but only if `stopScrollInteractionIfJSHasResponder` was
|
|
|
|
// called *during* a `pan`). Currently, it will just snap into place which
|
|
|
|
// is not so bad either.
|
|
|
|
// Another approach:
|
|
|
|
// self.scrollEnabled = NO;
|
|
|
|
// self.scrollEnabled = YES;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollRectToVisible:(CGRect)rect animated:(BOOL)animated
|
|
|
|
{
|
|
|
|
// Limiting scroll area to an area where we actually have content.
|
|
|
|
CGSize contentSize = self.contentSize;
|
|
|
|
UIEdgeInsets contentInset = self.contentInset;
|
|
|
|
CGSize fullSize = CGSizeMake(
|
|
|
|
contentSize.width + contentInset.left + contentInset.right,
|
|
|
|
contentSize.height + contentInset.top + contentInset.bottom);
|
|
|
|
|
|
|
|
rect = CGRectIntersection((CGRect){CGPointZero, fullSize}, rect);
|
|
|
|
if (CGRectIsNull(rect)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
[super scrollRectToVisible:rect animated:animated];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returning `YES` cancels touches for the "inner" `view` and causes a scroll.
|
|
|
|
* Returning `NO` causes touches to be directed to that inner view and prevents
|
|
|
|
* the scroll view from scrolling.
|
|
|
|
*
|
|
|
|
* `YES` -> Allows scrolling.
|
|
|
|
* `NO` -> Doesn't allow scrolling.
|
|
|
|
*
|
|
|
|
* By default this returns NO for all views that are UIControls and YES for
|
|
|
|
* everything else. What that does is allows scroll views to scroll even when a
|
|
|
|
* touch started inside of a `UIControl` (`UIButton` etc). For React scroll
|
|
|
|
* views, we want the default to be the same behavior as `UIControl`s so we
|
|
|
|
* return `YES` by default. But there's one case where we want to block the
|
|
|
|
* scrolling no matter what: When JS believes it has its own responder lock on
|
|
|
|
* a view that is *above* the scroll view in the hierarchy. So we abuse this
|
|
|
|
* `touchesShouldCancelInContentView` API in order to stop the scroll view from
|
|
|
|
* scrolling in this case.
|
|
|
|
*
|
|
|
|
* We are not aware of *any* other solution to the problem because alternative
|
|
|
|
* approaches require that we disable the scrollview *before* touches begin or
|
|
|
|
* move. This approach (`touchesShouldCancelInContentView`) works even if the
|
|
|
|
* JS responder is set after touches start/move because
|
|
|
|
* `touchesShouldCancelInContentView` is called as soon as the scroll view has
|
|
|
|
* been touched and dragged *just* far enough to decide to begin the "drag"
|
|
|
|
* movement of the scroll interaction. Returning `NO`, will cause the drag
|
|
|
|
* operation to fail.
|
|
|
|
*
|
|
|
|
* `touchesShouldCancelInContentView` will stop the *initialization* of a
|
|
|
|
* scroll pan gesture and most of the time this is sufficient. On rare
|
|
|
|
* occasion, the scroll gesture would have already initialized right before JS
|
|
|
|
* notifies native of the JS responder being set. In order to recover from that
|
|
|
|
* timing issue we have a fallback that kills any ongoing pan gesture that
|
|
|
|
* occurs when native is notified of a JS responder.
|
|
|
|
*
|
|
|
|
* Note: Explicitly returning `YES`, instead of relying on the default fixes
|
|
|
|
* (at least) one bug where if you have a UIControl inside a UIScrollView and
|
|
|
|
* tap on the UIControl and then start dragging (to scroll), it won't scroll.
|
|
|
|
* Chat with @andras for more details.
|
|
|
|
*
|
|
|
|
* In order to have this called, you must have delaysContentTouches set to NO
|
|
|
|
* (which is the not the `UIKit` default).
|
|
|
|
*/
|
|
|
|
- (BOOL)touchesShouldCancelInContentView:(__unused UIView *)view
|
|
|
|
{
|
|
|
|
//TODO: shouldn't this call super if _shouldDisableScrollInteraction returns NO?
|
|
|
|
return ![self _shouldDisableScrollInteraction];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Automatically centers the content such that if the content is smaller than the
|
|
|
|
* ScrollView, we force it to be centered, but when you zoom or the content otherwise
|
|
|
|
* becomes larger than the ScrollView, there is no padding around the content but it
|
|
|
|
* can still fill the whole view.
|
|
|
|
*/
|
|
|
|
- (void)setContentOffset:(CGPoint)contentOffset
|
|
|
|
{
|
|
|
|
UIView *contentView = [self contentView];
|
|
|
|
if (contentView && _centerContent) {
|
|
|
|
CGSize subviewSize = contentView.frame.size;
|
|
|
|
CGSize scrollViewSize = self.bounds.size;
|
|
|
|
if (subviewSize.width <= scrollViewSize.width) {
|
|
|
|
contentOffset.x = -(scrollViewSize.width - subviewSize.width) / 2.0;
|
|
|
|
}
|
|
|
|
if (subviewSize.height <= scrollViewSize.height) {
|
|
|
|
contentOffset.y = -(scrollViewSize.height - subviewSize.height) / 2.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
super.contentOffset = contentOffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setFrame:(CGRect)frame
|
|
|
|
{
|
|
|
|
// Preserving and revalidating `contentOffset`.
|
|
|
|
CGPoint originalOffset = self.contentOffset;
|
|
|
|
|
|
|
|
[super setFrame:frame];
|
|
|
|
|
|
|
|
UIEdgeInsets contentInset = self.contentInset;
|
|
|
|
CGSize contentSize = self.contentSize;
|
|
|
|
|
|
|
|
// If contentSize has not been measured yet we can't check bounds.
|
|
|
|
if (CGSizeEqualToSize(contentSize, CGSizeZero)) {
|
|
|
|
self.contentOffset = originalOffset;
|
|
|
|
} else {
|
|
|
|
// Make sure offset don't exceed bounds. This could happen on screen rotation.
|
|
|
|
CGSize boundsSize = self.bounds.size;
|
|
|
|
self.contentOffset = CGPointMake(
|
|
|
|
MAX(-contentInset.left, MIN(contentSize.width - boundsSize.width + contentInset.right, originalOffset.x)),
|
|
|
|
MAX(-contentInset.top, MIN(contentSize.height - boundsSize.height + contentInset.bottom, originalOffset.y)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
- (void)setRctRefreshControl:(RCTRefreshControl *)refreshControl
|
|
|
|
{
|
|
|
|
if (_rctRefreshControl) {
|
|
|
|
[_rctRefreshControl removeFromSuperview];
|
|
|
|
}
|
|
|
|
_rctRefreshControl = refreshControl;
|
|
|
|
[self addSubview:_rctRefreshControl];
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setPinchGestureEnabled:(BOOL)pinchGestureEnabled
|
|
|
|
{
|
|
|
|
self.pinchGestureRecognizer.enabled = pinchGestureEnabled;
|
|
|
|
_pinchGestureEnabled = pinchGestureEnabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)didMoveToWindow
|
|
|
|
{
|
|
|
|
[super didMoveToWindow];
|
|
|
|
// ScrollView enables pinch gesture late in its lifecycle. So simply setting it
|
|
|
|
// in the setter gets overriden when the view loads.
|
|
|
|
self.pinchGestureRecognizer.enabled = _pinchGestureEnabled;
|
|
|
|
}
|
|
|
|
#endif //TARGET_OS_TV
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
@interface RCTMJScrollView () <RCTUIManagerObserver>
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
@implementation RCTMJScrollView
|
|
|
|
{
|
|
|
|
RCTEventDispatcher *_eventDispatcher;
|
|
|
|
CGRect _prevFirstVisibleFrame;
|
|
|
|
__weak UIView *_firstVisibleView;
|
|
|
|
RCTMJCustomScrollView *_scrollView;
|
|
|
|
UIView *_contentView;
|
|
|
|
NSTimeInterval _lastScrollDispatchTime;
|
|
|
|
NSMutableArray<NSValue *> *_cachedChildFrames;
|
|
|
|
BOOL _allowNextScrollNoMatterWhat;
|
|
|
|
CGRect _lastClippedToRect;
|
|
|
|
uint16_t _coalescingKey;
|
|
|
|
NSString *_lastEmittedEventName;
|
|
|
|
NSHashTable *_scrollListeners;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (instancetype)initWithEventDispatcher:(RCTEventDispatcher *)eventDispatcher
|
|
|
|
{
|
|
|
|
RCTAssertParam(eventDispatcher);
|
|
|
|
|
|
|
|
if ((self = [super initWithFrame:CGRectZero])) {
|
|
|
|
_eventDispatcher = eventDispatcher;
|
|
|
|
|
|
|
|
_scrollView = [[RCTMJCustomScrollView alloc] initWithFrame:CGRectZero];
|
|
|
|
_scrollView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
|
|
|
|
_scrollView.delegate = self;
|
|
|
|
_scrollView.delaysContentTouches = NO;
|
|
|
|
|
|
|
|
#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* __IPHONE_11_0 */
|
|
|
|
// `contentInsetAdjustmentBehavior` is only available since iOS 11.
|
|
|
|
// We set the default behavior to "never" so that iOS
|
|
|
|
// doesn't do weird things to UIScrollView insets automatically
|
|
|
|
// and keeps it as an opt-in behavior.
|
|
|
|
if ([_scrollView respondsToSelector:@selector(setContentInsetAdjustmentBehavior:)]) {
|
|
|
|
_scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
_automaticallyAdjustContentInsets = YES;
|
|
|
|
_DEPRECATED_sendUpdatedChildFrames = NO;
|
|
|
|
_contentInset = UIEdgeInsetsZero;
|
|
|
|
_contentSize = CGSizeZero;
|
|
|
|
_lastClippedToRect = CGRectNull;
|
|
|
|
|
|
|
|
_scrollEventThrottle = 0.0;
|
|
|
|
_lastScrollDispatchTime = 0;
|
|
|
|
_cachedChildFrames = [NSMutableArray new];
|
|
|
|
|
|
|
|
_scrollListeners = [NSHashTable weakObjectsHashTable];
|
|
|
|
|
|
|
|
[self addSubview:_scrollView];
|
|
|
|
}
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
RCT_NOT_IMPLEMENTED(- (instancetype)initWithFrame:(CGRect)frame)
|
|
|
|
RCT_NOT_IMPLEMENTED(- (instancetype)initWithCoder:(NSCoder *)aDecoder)
|
|
|
|
|
|
|
|
static inline void RCTApplyTransformationAccordingLayoutDirection(UIView *view, UIUserInterfaceLayoutDirection layoutDirection) {
|
|
|
|
view.transform =
|
|
|
|
layoutDirection == UIUserInterfaceLayoutDirectionLeftToRight ?
|
|
|
|
CGAffineTransformIdentity :
|
|
|
|
CGAffineTransformMakeScale(-1, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setReactLayoutDirection:(UIUserInterfaceLayoutDirection)layoutDirection
|
|
|
|
{
|
|
|
|
[super setReactLayoutDirection:layoutDirection];
|
|
|
|
|
|
|
|
RCTApplyTransformationAccordingLayoutDirection(_scrollView, layoutDirection);
|
|
|
|
RCTApplyTransformationAccordingLayoutDirection(_contentView, layoutDirection);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setRemoveClippedSubviews:(__unused BOOL)removeClippedSubviews
|
|
|
|
{
|
|
|
|
// Does nothing
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)insertReactSubview:(UIView *)view atIndex:(NSInteger)atIndex
|
|
|
|
{
|
|
|
|
[super insertReactSubview:view atIndex:atIndex];
|
|
|
|
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
if ([view isKindOfClass:[RCTRefreshControl class]]) {
|
|
|
|
[_scrollView setRctRefreshControl:(RCTRefreshControl *)view];
|
|
|
|
} else if ([view isKindOfClass:[MJRefreshHeader class]]){
|
|
|
|
_scrollView.mj_header = (MJRefreshHeader *)view;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
RCTAssert(_contentView == nil, @"RCTScrollView may only contain a single subview");
|
|
|
|
_contentView = view;
|
|
|
|
RCTApplyTransformationAccordingLayoutDirection(_contentView, self.reactLayoutDirection);
|
|
|
|
[(RCTMJCustomScrollView *)_scrollView addSubview:view];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)removeReactSubview:(UIView *)subview
|
|
|
|
{
|
|
|
|
[super removeReactSubview:subview];
|
|
|
|
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
if ([subview isKindOfClass:[RCTRefreshControl class]]) {
|
|
|
|
[_scrollView setRctRefreshControl:nil];
|
|
|
|
} else if ([subview isKindOfClass:[MJRefreshHeader class]]){
|
|
|
|
_scrollView.mj_header = nil;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
RCTAssert(_contentView == subview, @"Attempted to remove non-existent subview");
|
|
|
|
_contentView = nil;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)didUpdateReactSubviews
|
|
|
|
{
|
|
|
|
// Do nothing, as subviews are managed by `insertReactSubview:atIndex:`
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)didSetProps:(NSArray<NSString *> *)changedProps
|
|
|
|
{
|
|
|
|
if ([changedProps containsObject:@"contentSize"]) {
|
|
|
|
[self updateContentOffsetIfNeeded];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (BOOL)centerContent
|
|
|
|
{
|
|
|
|
return _scrollView.centerContent;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setCenterContent:(BOOL)centerContent
|
|
|
|
{
|
|
|
|
_scrollView.centerContent = centerContent;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setClipsToBounds:(BOOL)clipsToBounds
|
|
|
|
{
|
|
|
|
super.clipsToBounds = clipsToBounds;
|
|
|
|
_scrollView.clipsToBounds = clipsToBounds;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)dealloc
|
|
|
|
{
|
|
|
|
_scrollView.delegate = nil;
|
|
|
|
if (_maintainVisibleContentPosition != nil) {
|
|
|
|
[_eventDispatcher.bridge.uiManager.observerCoordinator removeObserver:self];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)layoutSubviews
|
|
|
|
{
|
|
|
|
[super layoutSubviews];
|
|
|
|
RCTAssert(self.subviews.count == 1, @"we should only have exactly one subview");
|
|
|
|
RCTAssert([self.subviews lastObject] == _scrollView, @"our only subview should be a scrollview");
|
|
|
|
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
// Adjust the refresh control frame if the scrollview layout changes.
|
|
|
|
RCTRefreshControl *refreshControl = _scrollView.rctRefreshControl;
|
|
|
|
if (refreshControl && refreshControl.refreshing) {
|
|
|
|
refreshControl.frame = (CGRect){_scrollView.contentOffset, {_scrollView.frame.size.width, refreshControl.frame.size.height}};
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
[self updateClippedSubviews];
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)updateClippedSubviews
|
|
|
|
{
|
|
|
|
// Find a suitable view to use for clipping
|
|
|
|
UIView *clipView = [self react_findClipView];
|
|
|
|
if (!clipView) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const CGFloat leeway = 1.0;
|
|
|
|
|
|
|
|
const CGSize contentSize = _scrollView.contentSize;
|
|
|
|
const CGRect bounds = _scrollView.bounds;
|
|
|
|
const BOOL scrollsHorizontally = contentSize.width > bounds.size.width;
|
|
|
|
const BOOL scrollsVertically = contentSize.height > bounds.size.height;
|
|
|
|
|
|
|
|
const BOOL shouldClipAgain =
|
|
|
|
CGRectIsNull(_lastClippedToRect) ||
|
|
|
|
!CGRectEqualToRect(_lastClippedToRect, bounds) ||
|
|
|
|
(scrollsHorizontally && (bounds.size.width < leeway || fabs(_lastClippedToRect.origin.x - bounds.origin.x) >= leeway)) ||
|
|
|
|
(scrollsVertically && (bounds.size.height < leeway || fabs(_lastClippedToRect.origin.y - bounds.origin.y) >= leeway));
|
|
|
|
|
|
|
|
if (shouldClipAgain) {
|
|
|
|
const CGRect clipRect = CGRectInset(clipView.bounds, -leeway, -leeway);
|
|
|
|
[self react_updateClippedSubviewsWithClipRect:clipRect relativeToView:clipView];
|
|
|
|
_lastClippedToRect = bounds;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)setContentInset:(UIEdgeInsets)contentInset
|
|
|
|
{
|
|
|
|
if (UIEdgeInsetsEqualToEdgeInsets(contentInset, _contentInset)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
CGPoint contentOffset = _scrollView.contentOffset;
|
|
|
|
|
|
|
|
_contentInset = contentInset;
|
|
|
|
[RCTView autoAdjustInsetsForView:self
|
|
|
|
withScrollView:_scrollView
|
|
|
|
updateOffset:NO];
|
|
|
|
|
|
|
|
_scrollView.contentOffset = contentOffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (BOOL)isHorizontal:(UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
return scrollView.contentSize.width > self.frame.size.width;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollToOffset:(CGPoint)offset
|
|
|
|
{
|
|
|
|
[self scrollToOffset:offset animated:YES];
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollToOffset:(CGPoint)offset animated:(BOOL)animated
|
|
|
|
{
|
|
|
|
if (!CGPointEqualToPoint(_scrollView.contentOffset, offset)) {
|
|
|
|
// Ensure at least one scroll event will fire
|
|
|
|
_allowNextScrollNoMatterWhat = YES;
|
|
|
|
[_scrollView setContentOffset:offset animated:animated];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If this is a vertical scroll view, scrolls to the bottom.
|
|
|
|
* If this is a horizontal scroll view, scrolls to the right.
|
|
|
|
*/
|
|
|
|
- (void)scrollToEnd:(BOOL)animated
|
|
|
|
{
|
|
|
|
BOOL isHorizontal = [self isHorizontal:_scrollView];
|
|
|
|
CGPoint offset;
|
|
|
|
if (isHorizontal) {
|
|
|
|
CGFloat offsetX = _scrollView.contentSize.width - _scrollView.bounds.size.width + _scrollView.contentInset.right;
|
|
|
|
offset = CGPointMake(fmax(offsetX, 0), 0);
|
|
|
|
} else {
|
|
|
|
CGFloat offsetY = _scrollView.contentSize.height - _scrollView.bounds.size.height + _scrollView.contentInset.bottom;
|
|
|
|
offset = CGPointMake(0, fmax(offsetY, 0));
|
|
|
|
}
|
|
|
|
if (!CGPointEqualToPoint(_scrollView.contentOffset, offset)) {
|
|
|
|
// Ensure at least one scroll event will fire
|
|
|
|
_allowNextScrollNoMatterWhat = YES;
|
|
|
|
[_scrollView setContentOffset:offset animated:animated];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)zoomToRect:(CGRect)rect animated:(BOOL)animated
|
|
|
|
{
|
|
|
|
[_scrollView zoomToRect:rect animated:animated];
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)refreshContentInset
|
|
|
|
{
|
|
|
|
[RCTView autoAdjustInsetsForView:self
|
|
|
|
withScrollView:_scrollView
|
|
|
|
updateOffset:YES];
|
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - ScrollView delegate
|
|
|
|
|
|
|
|
#define RCT_SEND_SCROLL_EVENT(_eventName, _userData) { \
|
|
|
|
NSString *eventName = NSStringFromSelector(@selector(_eventName)); \
|
|
|
|
[self sendScrollEventWithName:eventName scrollView:_scrollView userData:_userData]; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define RCT_FORWARD_SCROLL_EVENT(call) \
|
|
|
|
for (NSObject<UIScrollViewDelegate> *scrollViewListener in _scrollListeners) { \
|
|
|
|
if ([scrollViewListener respondsToSelector:_cmd]) { \
|
|
|
|
[scrollViewListener call]; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define RCT_SCROLL_EVENT_HANDLER(delegateMethod, eventName) \
|
|
|
|
- (void)delegateMethod:(UIScrollView *)scrollView \
|
|
|
|
{ \
|
|
|
|
RCT_SEND_SCROLL_EVENT(eventName, nil); \
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(delegateMethod:scrollView); \
|
|
|
|
}
|
|
|
|
|
|
|
|
RCT_SCROLL_EVENT_HANDLER(scrollViewWillBeginDecelerating, onMomentumScrollBegin)
|
|
|
|
RCT_SCROLL_EVENT_HANDLER(scrollViewDidZoom, onScroll)
|
|
|
|
|
|
|
|
- (void)addScrollListener:(NSObject<UIScrollViewDelegate> *)scrollListener
|
|
|
|
{
|
|
|
|
[_scrollListeners addObject:scrollListener];
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)removeScrollListener:(NSObject<UIScrollViewDelegate> *)scrollListener
|
|
|
|
{
|
|
|
|
[_scrollListeners removeObject:scrollListener];
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewDidScroll:(UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
[self updateClippedSubviews];
|
|
|
|
NSTimeInterval now = CACurrentMediaTime();
|
|
|
|
/**
|
|
|
|
* TODO: this logic looks wrong, and it may be because it is. Currently, if _scrollEventThrottle
|
|
|
|
* is set to zero (the default), the "didScroll" event is only sent once per scroll, instead of repeatedly
|
|
|
|
* while scrolling as expected. However, if you "fix" that bug, ScrollView will generate repeated
|
|
|
|
* warnings, and behave strangely (ListView works fine however), so don't fix it unless you fix that too!
|
|
|
|
*/
|
|
|
|
if (_allowNextScrollNoMatterWhat ||
|
|
|
|
(_scrollEventThrottle > 0 && _scrollEventThrottle < (now - _lastScrollDispatchTime))) {
|
|
|
|
|
|
|
|
if (_DEPRECATED_sendUpdatedChildFrames) {
|
|
|
|
// Calculate changed frames
|
|
|
|
RCT_SEND_SCROLL_EVENT(onScroll, (@{@"updatedChildFrames": [self calculateChildFramesData]}));
|
|
|
|
} else {
|
|
|
|
RCT_SEND_SCROLL_EVENT(onScroll, nil);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update dispatch time
|
|
|
|
_lastScrollDispatchTime = now;
|
|
|
|
_allowNextScrollNoMatterWhat = NO;
|
|
|
|
}
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewDidScroll:scrollView);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (NSArray<NSDictionary *> *)calculateChildFramesData
|
|
|
|
{
|
|
|
|
NSMutableArray<NSDictionary *> *updatedChildFrames = [NSMutableArray new];
|
|
|
|
[[_contentView reactSubviews] enumerateObjectsUsingBlock:
|
|
|
|
^(UIView *subview, NSUInteger idx, __unused BOOL *stop) {
|
|
|
|
|
|
|
|
// Check if new or changed
|
|
|
|
CGRect newFrame = subview.frame;
|
|
|
|
BOOL frameChanged = NO;
|
|
|
|
if (self->_cachedChildFrames.count <= idx) {
|
|
|
|
frameChanged = YES;
|
|
|
|
[self->_cachedChildFrames addObject:[NSValue valueWithCGRect:newFrame]];
|
|
|
|
} else if (!CGRectEqualToRect(newFrame, [self->_cachedChildFrames[idx] CGRectValue])) {
|
|
|
|
frameChanged = YES;
|
|
|
|
self->_cachedChildFrames[idx] = [NSValue valueWithCGRect:newFrame];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create JS frame object
|
|
|
|
if (frameChanged) {
|
|
|
|
[updatedChildFrames addObject: @{
|
|
|
|
@"index": @(idx),
|
|
|
|
@"x": @(newFrame.origin.x),
|
|
|
|
@"y": @(newFrame.origin.y),
|
|
|
|
@"width": @(newFrame.size.width),
|
|
|
|
@"height": @(newFrame.size.height),
|
|
|
|
}];
|
|
|
|
}
|
|
|
|
}];
|
|
|
|
|
|
|
|
return updatedChildFrames;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
_allowNextScrollNoMatterWhat = YES; // Ensure next scroll event is recorded, regardless of throttle
|
|
|
|
RCT_SEND_SCROLL_EVENT(onScrollBeginDrag, nil);
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewWillBeginDragging:scrollView);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset
|
|
|
|
{
|
|
|
|
// snapToInterval
|
|
|
|
// An alternative to enablePaging which allows setting custom stopping intervals,
|
|
|
|
// smaller than a full page size. Often seen in apps which feature horizonally
|
|
|
|
// scrolling items. snapToInterval does not enforce scrolling one interval at a time
|
|
|
|
// but guarantees that the scroll will stop at an interval point.
|
|
|
|
if (self.snapToInterval) {
|
|
|
|
CGFloat snapToIntervalF = (CGFloat)self.snapToInterval;
|
|
|
|
|
|
|
|
// Find which axis to snap
|
|
|
|
BOOL isHorizontal = [self isHorizontal:scrollView];
|
|
|
|
|
|
|
|
// What is the current offset?
|
|
|
|
CGFloat velocityAlongAxis = isHorizontal ? velocity.x : velocity.y;
|
|
|
|
CGFloat targetContentOffsetAlongAxis = isHorizontal ? targetContentOffset->x : targetContentOffset->y;
|
|
|
|
|
|
|
|
// Offset based on desired alignment
|
|
|
|
CGFloat frameLength = isHorizontal ? self.frame.size.width : self.frame.size.height;
|
|
|
|
CGFloat alignmentOffset = 0.0f;
|
|
|
|
if ([self.snapToAlignment isEqualToString: @"center"]) {
|
|
|
|
alignmentOffset = (frameLength * 0.5f) + (snapToIntervalF * 0.5f);
|
|
|
|
} else if ([self.snapToAlignment isEqualToString: @"end"]) {
|
|
|
|
alignmentOffset = frameLength;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pick snap point based on direction and proximity
|
|
|
|
CGFloat fractionalIndex = (targetContentOffsetAlongAxis + alignmentOffset) / snapToIntervalF;
|
|
|
|
NSInteger snapIndex =
|
|
|
|
velocityAlongAxis > 0.0 ?
|
|
|
|
ceil(fractionalIndex) :
|
|
|
|
velocityAlongAxis < 0.0 ?
|
|
|
|
floor(fractionalIndex) :
|
|
|
|
round(fractionalIndex);
|
|
|
|
CGFloat newTargetContentOffset = (snapIndex * snapToIntervalF) - alignmentOffset;
|
|
|
|
|
|
|
|
// Set new targetContentOffset
|
|
|
|
if (isHorizontal) {
|
|
|
|
targetContentOffset->x = newTargetContentOffset;
|
|
|
|
} else {
|
|
|
|
targetContentOffset->y = newTargetContentOffset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NSDictionary *userData = @{
|
|
|
|
@"velocity": @{
|
|
|
|
@"x": @(velocity.x),
|
|
|
|
@"y": @(velocity.y)
|
|
|
|
},
|
|
|
|
@"targetContentOffset": @{
|
|
|
|
@"x": @(targetContentOffset->x),
|
|
|
|
@"y": @(targetContentOffset->y)
|
|
|
|
}
|
|
|
|
};
|
|
|
|
RCT_SEND_SCROLL_EVENT(onScrollEndDrag, userData);
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewWillEndDragging:scrollView withVelocity:velocity targetContentOffset:targetContentOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
|
|
|
|
{
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewDidEndDragging:scrollView willDecelerate:decelerate);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewWillBeginZooming:(UIScrollView *)scrollView withView:(UIView *)view
|
|
|
|
{
|
|
|
|
RCT_SEND_SCROLL_EVENT(onScrollBeginDrag, nil);
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewWillBeginZooming:scrollView withView:view);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewDidEndZooming:(UIScrollView *)scrollView withView:(UIView *)view atScale:(CGFloat)scale
|
|
|
|
{
|
|
|
|
RCT_SEND_SCROLL_EVENT(onScrollEndDrag, nil);
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewDidEndZooming:scrollView withView:view atScale:scale);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
// Fire a final scroll event
|
|
|
|
_allowNextScrollNoMatterWhat = YES;
|
|
|
|
[self scrollViewDidScroll:scrollView];
|
|
|
|
|
|
|
|
// Fire the end deceleration event
|
|
|
|
RCT_SEND_SCROLL_EVENT(onMomentumScrollEnd, nil);
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewDidEndDecelerating:scrollView);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
// Fire a final scroll event
|
|
|
|
_allowNextScrollNoMatterWhat = YES;
|
|
|
|
[self scrollViewDidScroll:scrollView];
|
|
|
|
|
|
|
|
// Fire the end deceleration event
|
|
|
|
RCT_SEND_SCROLL_EVENT(onMomentumScrollEnd, nil);
|
|
|
|
RCT_FORWARD_SCROLL_EVENT(scrollViewDidEndScrollingAnimation:scrollView);
|
|
|
|
}
|
|
|
|
|
|
|
|
- (BOOL)scrollViewShouldScrollToTop:(UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
for (NSObject<UIScrollViewDelegate> *scrollListener in _scrollListeners) {
|
|
|
|
if ([scrollListener respondsToSelector:_cmd] &&
|
|
|
|
![scrollListener scrollViewShouldScrollToTop:scrollView]) {
|
|
|
|
return NO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return YES;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (UIView *)viewForZoomingInScrollView:(__unused UIScrollView *)scrollView
|
|
|
|
{
|
|
|
|
return _contentView;
|
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - Setters
|
|
|
|
|
|
|
|
- (CGSize)_calculateViewportSize
|
|
|
|
{
|
|
|
|
CGSize viewportSize = self.bounds.size;
|
|
|
|
if (_automaticallyAdjustContentInsets) {
|
|
|
|
UIEdgeInsets contentInsets = [RCTView contentInsetsForView:self];
|
|
|
|
viewportSize = CGSizeMake(self.bounds.size.width - contentInsets.left - contentInsets.right,
|
|
|
|
self.bounds.size.height - contentInsets.top - contentInsets.bottom);
|
|
|
|
}
|
|
|
|
return viewportSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (CGPoint)calculateOffsetForContentSize:(CGSize)newContentSize
|
|
|
|
{
|
|
|
|
CGPoint oldOffset = _scrollView.contentOffset;
|
|
|
|
CGPoint newOffset = oldOffset;
|
|
|
|
|
|
|
|
CGSize oldContentSize = _scrollView.contentSize;
|
|
|
|
CGSize viewportSize = [self _calculateViewportSize];
|
|
|
|
|
|
|
|
BOOL fitsinViewportY = oldContentSize.height <= viewportSize.height && newContentSize.height <= viewportSize.height;
|
|
|
|
if (newContentSize.height < oldContentSize.height && !fitsinViewportY) {
|
|
|
|
CGFloat offsetHeight = oldOffset.y + viewportSize.height;
|
|
|
|
if (oldOffset.y < 0) {
|
|
|
|
// overscrolled on top, leave offset alone
|
|
|
|
} else if (offsetHeight > oldContentSize.height) {
|
|
|
|
// overscrolled on the bottom, preserve overscroll amount
|
|
|
|
newOffset.y = MAX(0, oldOffset.y - (oldContentSize.height - newContentSize.height));
|
|
|
|
} else if (offsetHeight > newContentSize.height) {
|
|
|
|
// offset falls outside of bounds, scroll back to end of list
|
|
|
|
newOffset.y = MAX(0, newContentSize.height - viewportSize.height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL fitsinViewportX = oldContentSize.width <= viewportSize.width && newContentSize.width <= viewportSize.width;
|
|
|
|
if (newContentSize.width < oldContentSize.width && !fitsinViewportX) {
|
|
|
|
CGFloat offsetHeight = oldOffset.x + viewportSize.width;
|
|
|
|
if (oldOffset.x < 0) {
|
|
|
|
// overscrolled at the beginning, leave offset alone
|
|
|
|
} else if (offsetHeight > oldContentSize.width && newContentSize.width > viewportSize.width) {
|
|
|
|
// overscrolled at the end, preserve overscroll amount as much as possible
|
|
|
|
newOffset.x = MAX(0, oldOffset.x - (oldContentSize.width - newContentSize.width));
|
|
|
|
} else if (offsetHeight > newContentSize.width) {
|
|
|
|
// offset falls outside of bounds, scroll back to end
|
|
|
|
newOffset.x = MAX(0, newContentSize.width - viewportSize.width);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// all other cases, offset doesn't change
|
|
|
|
return newOffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Once you set the `contentSize`, to a nonzero value, it is assumed to be
|
|
|
|
* managed by you, and we'll never automatically compute the size for you,
|
|
|
|
* unless you manually reset it back to {0, 0}
|
|
|
|
*/
|
|
|
|
- (CGSize)contentSize
|
|
|
|
{
|
|
|
|
if (!CGSizeEqualToSize(_contentSize, CGSizeZero)) {
|
|
|
|
return _contentSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return _contentView.frame.size;
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)updateContentOffsetIfNeeded
|
|
|
|
{
|
|
|
|
CGSize contentSize = self.contentSize;
|
|
|
|
if (!CGSizeEqualToSize(_scrollView.contentSize, contentSize)) {
|
|
|
|
// When contentSize is set manually, ScrollView internals will reset
|
|
|
|
// contentOffset to {0, 0}. Since we potentially set contentSize whenever
|
|
|
|
// anything in the ScrollView updates, we workaround this issue by manually
|
|
|
|
// adjusting contentOffset whenever this happens
|
|
|
|
CGPoint newOffset = [self calculateOffsetForContentSize:contentSize];
|
|
|
|
_scrollView.contentSize = contentSize;
|
|
|
|
_scrollView.contentOffset = newOffset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// maintainVisibleContentPosition is used to allow seamless loading of content from both ends of
|
|
|
|
// the scrollview without the visible content jumping in position.
|
|
|
|
- (void)setMaintainVisibleContentPosition:(NSDictionary *)maintainVisibleContentPosition
|
|
|
|
{
|
|
|
|
if (maintainVisibleContentPosition != nil && _maintainVisibleContentPosition == nil) {
|
|
|
|
[_eventDispatcher.bridge.uiManager.observerCoordinator addObserver:self];
|
|
|
|
} else if (maintainVisibleContentPosition == nil && _maintainVisibleContentPosition != nil) {
|
|
|
|
[_eventDispatcher.bridge.uiManager.observerCoordinator removeObserver:self];
|
|
|
|
}
|
|
|
|
_maintainVisibleContentPosition = maintainVisibleContentPosition;
|
|
|
|
}
|
|
|
|
|
|
|
|
#pragma mark - RCTUIManagerObserver
|
|
|
|
|
|
|
|
- (void)uiManagerWillPerformMounting:(RCTUIManager *)manager
|
|
|
|
{
|
|
|
|
RCTAssertUIManagerQueue();
|
|
|
|
[manager prependUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
|
|
|
|
BOOL horz = [self isHorizontal:self->_scrollView];
|
|
|
|
NSUInteger minIdx = [self->_maintainVisibleContentPosition[@"minIndexForVisible"] integerValue];
|
|
|
|
for (NSUInteger ii = minIdx; ii < self->_contentView.subviews.count; ++ii) {
|
|
|
|
// Find the first entirely visible view. This must be done after we update the content offset
|
|
|
|
// or it will tend to grab rows that were made visible by the shift in position
|
|
|
|
UIView *subview = self->_contentView.subviews[ii];
|
|
|
|
if ((horz
|
|
|
|
? subview.frame.origin.x >= self->_scrollView.contentOffset.x
|
|
|
|
: subview.frame.origin.y >= self->_scrollView.contentOffset.y) ||
|
|
|
|
ii == self->_contentView.subviews.count - 1) {
|
|
|
|
self->_prevFirstVisibleFrame = subview.frame;
|
|
|
|
self->_firstVisibleView = subview;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}];
|
|
|
|
[manager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
|
|
|
|
if (self->_maintainVisibleContentPosition == nil) {
|
|
|
|
return; // The prop might have changed in the previous UIBlocks, so need to abort here.
|
|
|
|
}
|
|
|
|
NSNumber *autoscrollThreshold = self->_maintainVisibleContentPosition[@"autoscrollToTopThreshold"];
|
|
|
|
// TODO: detect and handle/ignore re-ordering
|
|
|
|
if ([self isHorizontal:self->_scrollView]) {
|
|
|
|
CGFloat deltaX = self->_firstVisibleView.frame.origin.x - self->_prevFirstVisibleFrame.origin.x;
|
|
|
|
if (ABS(deltaX) > 0.1) {
|
|
|
|
self->_scrollView.contentOffset = CGPointMake(
|
|
|
|
self->_scrollView.contentOffset.x + deltaX,
|
|
|
|
self->_scrollView.contentOffset.y
|
|
|
|
);
|
|
|
|
if (autoscrollThreshold != nil) {
|
|
|
|
// If the offset WAS within the threshold of the start, animate to the start.
|
|
|
|
if (self->_scrollView.contentOffset.x - deltaX <= [autoscrollThreshold integerValue]) {
|
|
|
|
[self scrollToOffset:CGPointMake(0, self->_scrollView.contentOffset.y) animated:YES];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
CGRect newFrame = self->_firstVisibleView.frame;
|
|
|
|
CGFloat deltaY = newFrame.origin.y - self->_prevFirstVisibleFrame.origin.y;
|
|
|
|
if (ABS(deltaY) > 0.1) {
|
|
|
|
self->_scrollView.contentOffset = CGPointMake(
|
|
|
|
self->_scrollView.contentOffset.x,
|
|
|
|
self->_scrollView.contentOffset.y + deltaY
|
|
|
|
);
|
|
|
|
if (autoscrollThreshold != nil) {
|
|
|
|
// If the offset WAS within the threshold of the start, animate to the start.
|
|
|
|
if (self->_scrollView.contentOffset.y - deltaY <= [autoscrollThreshold integerValue]) {
|
|
|
|
[self scrollToOffset:CGPointMake(self->_scrollView.contentOffset.x, 0) animated:YES];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note: setting several properties of UIScrollView has the effect of
|
|
|
|
// resetting its contentOffset to {0, 0}. To prevent this, we generate
|
|
|
|
// setters here that will record the contentOffset beforehand, and
|
|
|
|
// restore it after the property has been set.
|
|
|
|
|
|
|
|
#define RCT_SET_AND_PRESERVE_OFFSET(setter, getter, type) \
|
|
|
|
- (void)setter:(type)value \
|
|
|
|
{ \
|
|
|
|
CGPoint contentOffset = _scrollView.contentOffset; \
|
|
|
|
[_scrollView setter:value]; \
|
|
|
|
_scrollView.contentOffset = contentOffset; \
|
|
|
|
} \
|
|
|
|
- (type)getter \
|
|
|
|
{ \
|
|
|
|
return [_scrollView getter]; \
|
|
|
|
}
|
|
|
|
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setAlwaysBounceHorizontal, alwaysBounceHorizontal, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setAlwaysBounceVertical, alwaysBounceVertical, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setBounces, bounces, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setBouncesZoom, bouncesZoom, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setCanCancelContentTouches, canCancelContentTouches, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setDecelerationRate, decelerationRate, CGFloat)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setDirectionalLockEnabled, isDirectionalLockEnabled, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setIndicatorStyle, indicatorStyle, UIScrollViewIndicatorStyle)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setKeyboardDismissMode, keyboardDismissMode, UIScrollViewKeyboardDismissMode)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setMaximumZoomScale, maximumZoomScale, CGFloat)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setMinimumZoomScale, minimumZoomScale, CGFloat)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setScrollEnabled, isScrollEnabled, BOOL)
|
|
|
|
#if !TARGET_OS_TV
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setPagingEnabled, isPagingEnabled, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setScrollsToTop, scrollsToTop, BOOL)
|
|
|
|
#endif
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setShowsHorizontalScrollIndicator, showsHorizontalScrollIndicator, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setShowsVerticalScrollIndicator, showsVerticalScrollIndicator, BOOL)
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setZoomScale, zoomScale, CGFloat);
|
|
|
|
RCT_SET_AND_PRESERVE_OFFSET(setScrollIndicatorInsets, scrollIndicatorInsets, UIEdgeInsets);
|
|
|
|
|
|
|
|
#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* __IPHONE_11_0 */
|
|
|
|
- (void)setContentInsetAdjustmentBehavior:(UIScrollViewContentInsetAdjustmentBehavior)behavior
|
|
|
|
{
|
|
|
|
// `contentInsetAdjustmentBehavior` is available since iOS 11.
|
|
|
|
if ([_scrollView respondsToSelector:@selector(setContentInsetAdjustmentBehavior:)]) {
|
|
|
|
CGPoint contentOffset = _scrollView.contentOffset;
|
|
|
|
_scrollView.contentInsetAdjustmentBehavior = behavior;
|
|
|
|
_scrollView.contentOffset = contentOffset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
- (void)sendScrollEventWithName:(NSString *)eventName
|
|
|
|
scrollView:(UIScrollView *)scrollView
|
|
|
|
userData:(NSDictionary *)userData
|
|
|
|
{
|
|
|
|
if (![_lastEmittedEventName isEqualToString:eventName]) {
|
|
|
|
_coalescingKey++;
|
|
|
|
_lastEmittedEventName = [eventName copy];
|
|
|
|
}
|
|
|
|
RCTMJScrollEvent *scrollEvent = [[RCTMJScrollEvent alloc] initWithEventName:eventName
|
|
|
|
reactTag:self.reactTag
|
|
|
|
scrollViewContentOffset:scrollView.contentOffset
|
|
|
|
scrollViewContentInset:scrollView.contentInset
|
|
|
|
scrollViewContentSize:scrollView.contentSize
|
|
|
|
scrollViewFrame:scrollView.frame
|
|
|
|
scrollViewZoomScale:scrollView.zoomScale
|
|
|
|
userData:userData
|
|
|
|
coalescingKey:_coalescingKey];
|
|
|
|
[_eventDispatcher sendEvent:scrollEvent];
|
|
|
|
}
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
|
|
|
@implementation RCTEventDispatcher (RCTMJScrollView)
|
|
|
|
|
|
|
|
- (void)sendFakeScrollEvent:(NSNumber *)reactTag
|
|
|
|
{
|
|
|
|
// Use the selector here in case the onScroll block property is ever renamed
|
|
|
|
NSString *eventName = NSStringFromSelector(@selector(onScroll));
|
|
|
|
RCTMJScrollEvent *fakeScrollEvent = [[RCTMJScrollEvent alloc] initWithEventName:eventName
|
|
|
|
reactTag:reactTag
|
|
|
|
scrollViewContentOffset:CGPointZero
|
|
|
|
scrollViewContentInset:UIEdgeInsetsZero
|
|
|
|
scrollViewContentSize:CGSizeZero
|
|
|
|
scrollViewFrame:CGRectZero
|
|
|
|
scrollViewZoomScale:0
|
|
|
|
userData:nil
|
|
|
|
coalescingKey:0];
|
|
|
|
[self sendEvent:fakeScrollEvent];
|
|
|
|
}
|
|
|
|
|
|
|
|
@end
|
|
|
|
|
...
|
...
|
|
