constructor(props, defaultProps) {
super(props, defaultProps);
const { pressDragRelease, reverse } = props;
this.state = {
pan:new Animated.ValueXY(),
_value:{x: 0, y: 0}
};
this.panResponder = PanResponder.create({
onMoveShouldSetPanResponder: (evt, gestureState) => true,
onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
onPanResponderGrant: (e, gestureState) => {
if(reverse == false) {
this.state.pan.setOffset({x: this.state._value.x, y: this.state._value.y});
this.state.pan.setValue({x: 0, y: 0});
}
},
onPanResponderMove: Animated.event([null,{
dx:this.state.pan.x,
dy:this.state.pan.y
}]),
onPanResponderRelease: (e, gestureState) => {
if(pressDragRelease)
pressDragRelease(e, gestureState);
if(reverse == false)
this.state.pan.flattenOffset();
else
this.reversePosition();
}
});
}
buildGestures = () =>
PanResponder.create({
onResponderTerminationRequest: this.props.onResponderTerminationRequest,
onStartShouldSetPanResponderCapture: this.props.onStartShouldSetPanResponderCapture,
onPanResponderGrant: ({ nativeEvent }, gestureState) => {
const event = this._transformEvent({ ...nativeEvent, gestureState });
this._emit('touchstart', event);
this.props.onTouchesBegan(event);
},
onPanResponderMove: ({ nativeEvent }, gestureState) => {
const event = this._transformEvent({ ...nativeEvent, gestureState });
this._emit('touchmove', event);
this.props.onTouchesMoved(event);
},
onPanResponderRelease: ({ nativeEvent }, gestureState) => {
const event = this._transformEvent({ ...nativeEvent, gestureState });
this._emit('touchend', event);
this.props.onTouchesEnded(event);
},
onPanResponderTerminate: ({ nativeEvent }, gestureState) => {
const event = this._transformEvent({ ...nativeEvent, gestureState });
this._emit('touchcancel', event);
this.props.onTouchesCancelled
? this.props.onTouchesCancelled(event)
: this.props.onTouchesEnded(event);
},
});
componentWillMount: function() {
this.styles = StyleSheet.create({...DEFAULT_STYLES, ...this.props.styles})
if(this.props.styles != undefined && this.props.styles.board.top != undefined){
Top = this.props.styles.board.top;
}
this._panResponder = PanResponder.create({
// 要求成为响应者：
onStartShouldSetPanResponder: (event, gestureState) => true,
onStartShouldSetPanResponderCapture: (event, gestureState) => true,
onMoveShouldSetPanResponder: (event, gestureState) => true,
onMoveShouldSetPanResponderCapture: (event, gestureState) => true,
// 开始手势操作
onPanResponderGrant: (event, gestureState) => {
this.onStart(event, gestureState);
},
// 移动操作
onPanResponderMove: (event, gestureState) => {
this.onMove(event, gestureState);
},
// 释放手势
onPanResponderRelease: (event, gestureState) => {
this.onEnd(event, gestureState);
}
});
},
componentWillMount() {
this.panresponders = PanResponder.create({
onMoveShouldSetPanResponder: (evt, gestureState) => {
if (!this.props.disabled && gestureState.dx > 0) {
return true;
}
return false;
},
onMoveShouldSetResponderCapture: () => true,
onPanResponderMove: Animated.event([
null, { dx: this.position },
]),
onPanResponderRelease: (evt, gestureState) => {
if (gestureState.dx > this.props.gestureStartPosition) {
Animated.timing(this.position, {
toValue: ScreenWidth,
duration: 150,
}).start();
this.props.onSwipe();
setTimeout(() => {
Animated.timing(this.position, {
toValue: 0,
duration: 150,
}).start();
}, 700);
} else {
Animated.timing(this.position, {
toValue: 0,
duration: 150,
}).start();
}
},
});
}
componentWillMount() {
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: e => true,
onMoveShouldSetPanResponder: e => true,
onPanResponderMove: (e, g) => {
this._isMove = true;
this._marginLeft = g.dx + (-this._index * width);
this._marginLeft > 0 && (this._marginLeft = 0);
this._marginLeft < (-this._maxMarginLeft) && (this._marginLeft = -this._maxMarginLeft);
this.setState({
marginLeftAnim: this._marginLeft
});
},
onPanResponderRelease: (e, g) => {
if (!this._isMove) return;
this._index -= Math.abs(g.dx) > (width / 4) ? (1 * g.dx > 0 ? 1 : -1) : 0;
this._index < 0 && (this._index = 0);
let len = this.props.children.length - 1;
this._index > len && (this._index = len);
this.setState({
marginLeftAnim: new Animated.Value(this._marginLeft)
});
setTimeout(() => {
Animated.spring(
this.state.marginLeftAnim, {
toValue: -this._index * width
},
).start();
})
this._isMove = false;
}
})
}
componentWillMount: function() {
// TODO(t7489503): Don't need this once ES6 Class landed.
this.__defineGetter__('navigationContext', this._getNavigationContext);
this._subRouteFocus = [];
this.parentNavigator = this.props.navigator;
this._handlers = {};
this.springSystem = new rebound.SpringSystem();
this.spring = this.springSystem.createSpring();
this.spring.setRestSpeedThreshold(0.05);
this.spring.setCurrentValue(0).setAtRest();
this.spring.addListener({
onSpringEndStateChange: () => {
if (!this._interactionHandle) {
this._interactionHandle = this.createInteractionHandle();
}
},
onSpringUpdate: () => {
this._handleSpringUpdate();
},
onSpringAtRest: () => {
this._completeTransition();
},
});
this.panGesture = PanResponder.create({
onMoveShouldSetPanResponder: this._handleMoveShouldSetPanResponder,
onPanResponderRelease: this._handlePanResponderRelease,
onPanResponderMove: this._handlePanResponderMove,
onPanResponderTerminate: this._handlePanResponderTerminate,
});
this._interactionHandle = null;
this._emitWillFocus(this.state.routeStack[this.state.presentedIndex]);
},
componentWillMount() {
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: () => true,
onMoveShouldSetPanResponder: () => true,
onPanResponderGrant: () => {
this._top = this.state.top;
this._left = this.state.left;
this.setState({bg: 'red'});
},
onPanResponderMove: (evt,gs) => {
console.log(gs.dx+''+gs.dy)
this.setState({
top: this._top + gs.dy,
left: this._left + gs.dx,
})
},
onPanResponderRelease: (evt,gs) => {
this.setState({
bg: 'white',
top: this._top + gs.dy,
left: this._left + gs.dx
})
}
})
}
componentWillMount() {
const { entityCardId, card } = this.props;
const { id, tmpId, uri, url, dimensions } = card;
const color = card.tmp.color || card.color;
const opacity = card.tmp.opacity || card.opacity;
const isCover = entityCardId === id || entityCardId === tmpId;
if (!!dimensions.height && !!dimensions.width) {
// $FlowFixMe ~> dimensions
this.setState({ dimensions, color, opacity, isCover });
} else {
Image.getSize(uri || url, (width, height) => {
if (this.mounted) {
this.setState({ dimensions: { width, height }, color, opacity, isCover });
}
});
}
this.panResponder = PanResponder.create({
onStartShouldSetPanResponder: () => true,
onStartShouldSetPanResponderCapture: () => true,
// onStartShouldSetPanResponder: evt => this.handleStartShouldSetPanResponder(evt),
// onStartShouldSetPanResponderCapture: evt => this.handleStartShouldSetPanResponder(evt),
// onMoveShouldSetPanResponder: () => true,
// onMoveShouldSetPanResponderCapture: () => true,
// onPanResponderMove: (evt, gs) => this.handlePanResponderMove(evt, gs),
onPanResponderRelease: (evt, gs) => this.handlePanResponderRelease(gs),
// onPanResponderTerminationRequest: () => false,
});
}
componentWillMount(){
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: this._handleStartShouldSetPanResponder,
onMoveShouldSetPanResponder: this._handleMoveShouldSetPanResponder,
onPanResponderGrant: this._handlePanResponderGrant,
onPanResponderMove: this._handlePanResponderMove.bind(this),
onPanResponderRelease: this._handlePanResponderEnd.bind(this),
onPanResponderTerminate: this._handlePanResponderEnd.bind(this),
});
this._panOverlayResponder = PanResponder.create({
onStartShouldSetPanResponder: this._handleStartShouldSetPanResponderOverlay,
onMoveShouldSetPanResponder: this._handleMoveShouldSetPanResponderOverlay,
onPanResponderGrant: this._handlePanResponderGrantOverlay.bind(this),
});
}
componentWillMount() {
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: (evt, gestureState) => false,
onStartShouldSetPanResponderCapture: (evt, gestureState) => false,
onMoveShouldSetPanResponder: (evt, gestureState) => true,
onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
onPanResponderGrant: (evt, gestureState) => {
this.setState({touchState: 'grant'})
},
onPanResponderMove: (evt, gestureState) => {
this.setState({touchState: 'move'})
this._move(gestureState.dx)
},
onPanResponderTerminationRequest: (evt, gestureState) => true,
onPanResponderRelease: (evt, gestureState) => {
this._release(gestureState.dx)
},
onPanResponderTerminate: (evt, gestureState) => {
this.setState({touchState: 'terminate'})
console.log('terminated');
},
onShouldBlockNativeResponder: (evt, gestureState) => {
this.setState({touchState: 'block'})
console.log('block');
return true;
},
});
}
_setupPanResponder(dimensions) {
this._panResponder = PanResponder.create({
onMoveShouldSetPanResponder: (event, gestureState) => true,
onMoveShouldSetPanResponderCapture: (event, gestureState) => true,
onPanResponderMove: (event, gestureState) => {
this._vMoveY.setValue(gestureState.moveY)
},
onPanResponderRelease: (event, gestureState) => {
const { visibleHeight } = dimensions
const { moveY, vy } = gestureState
const velocityThreshold = 1e-6
if (vy < -velocityThreshold) {
this._upwardsAnimation.start()
} else if (vy > velocityThreshold) {
this._downwardsAnimation.start()
} else {
const animation = moveY < visibleHeight / 2 ?
this._upwardsAnimation : this._downwardsAnimation
animation.start()
}
},
})
}
componentWillMount() {
const { openValue } = this.state;
openValue.addListener(({ value }) => {
const drawerShown = value > 0;
const accessibilityViewIsModal = drawerShown;
if (drawerShown !== this.state.drawerShown) {
this.setState({ drawerShown, accessibilityViewIsModal });
}
if (this.props.keyboardDismissMode === 'on-drag') {
Keyboard.dismiss();
}
this._lastOpenValue = value;
if (this.props.onDrawerSlide) {
this.props.onDrawerSlide({ nativeEvent: { offset: value } });
}
});
this._panResponder = PanResponder.create({
onMoveShouldSetPanResponder: this._shouldSetPanResponder,
onPanResponderGrant: this._panResponderGrant,
onPanResponderMove: this._panResponderMove,
onPanResponderTerminationRequest: () => false,
onPanResponderRelease: this._panResponderRelease,
onPanResponderTerminate: () => {},
});
}
componentWillMount() {
this._panResponder = PanResponder.create({
onMoveShouldSetResponderCapture: () => true,
onMoveShouldSetPanResponderCapture: () => true,
onPanResponderGrant: (e, gestureState) => {
// Set the initial value to the current state
this.state.pan.setOffset({x: this.state.pan.x._value, y: this.state.pan.y._value});
this.state.pan.setValue({x: 0, y: 0});
Animated.spring(
this.state.scale,
{ toValue: 1.1, friction: 3 }
).start();
},
// When we drag/pan the object, set the delate to the states pan position
onPanResponderMove: Animated.event([
null, {dx: this.state.pan.x, dy: this.state.pan.y},
]),
onPanResponderRelease: (e, {vx, vy}) => {
// Flatten the offset to avoid erratic behavior
this.state.pan.flattenOffset();
Animated.spring(
this.state.scale,
{ toValue: 1, friction: 3 }
).start();
}
});
}
constructor(props) {
super(props);
this.theme = getTheme();
this._value = 0;
this._trackTotalLength = 0;
this._prevPointerX = 0;
this._animatedTrackLength = new Animated.Value(0);
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: () => true,
onStartShouldSetPanResponderCapture: () => true,
onMoveShouldSetPanResponder: () => true,
onMoveShouldSetPanResponderCapture: () => true,
onPanResponderGrant: (evt) => {
this._prevPointerX = evt.nativeEvent.locationX;
this._onTouchEvent({
type: 'TOUCH_DOWN',
x: this._prevPointerX,
});
},
onPanResponderMove: (evt, gestureState) => {
this._onTouchEvent({
type: 'TOUCH_MOVE',
x: this._prevPointerX + gestureState.dx,
});
},
onPanResponderTerminationRequest: () => false,
onPanResponderRelease: (evt, gestureState) => {
this._onPanResponderEnd(gestureState);
},
onPanResponderTerminate: (evt, gestureState) => {
this._onPanResponderEnd(gestureState, true);
},
onShouldBlockNativeResponder: () => true,
});
}
componentWillMount() {
console.log('WILL MOUNT');
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: (evt, gestureState) => true,
onStartShouldSetPanResponderCapture: (evt, gestureState) => true,
onMoveShouldSetPanResponder: (evt, gestureState) => true,
onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
onPanResponderGrant: (evt, gestureState) => {
this.setState({ isMoving: true, pointsDelta: 0 });
},
onPanResponderMove: (evt, gestureState) => {
// For each 2 pixels add or subtract 1 point
this.setState({ pointsDelta: Math.round(-gestureState.dy / 2) });
},
onPanResponderTerminationRequest: (evt, gestureState) => true,
onPanResponderRelease: (evt, gestureState) => {
let points = this.state.points + this.state.pointsDelta;
console.log(Math.min(points, MAX_POINTS));
this.setState({
isMoving: false,
points: points > 0 ? Math.min(points, MAX_POINTS) : 0,
pointsDelta: 0
});
},
});
}
constructor(props) {
super(props);
this.state = {
previousMonkeyPosition: {
left: 0,
top: 0
}
};
this.panResponder = PanResponder.create({
onStartShouldSetPanResponder: () => true,
onMoveShouldSetPanResponder: () => true,
onPanResponderGrant: () => this.setState({
monkeyPosition: {
...this.state.monkeyPosition,
opacity: .5
}
}),
onPanResponderMove: (e, gestureState) => this.setState({
monkeyPosition: {
...this.state.monkeyPosition,
left: this.state.previousMonkeyPosition.left + gestureState.dx,
top: this.state.previousMonkeyPosition.top + gestureState.dy
}
}),
onPanResponderRelease: this.stopPanResponder.bind(this),
onPanResponderTerminate: this.stopPanResponder.bind(this),
});
}
componentWillMount() {
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: (evt, gestureState) => true,
onMoveShouldSetPanResponder: (evt, gestureState) => {
// return gestureState.dy/gestureState.dx!=0;
return true
},
onPanResponderGrant: (evt, gestureState) => {
console.log("1")
},
onPanResponderMove: (evt, gestureState) => {
this._mainStyles.style.left = this._previousLeft + gestureState.dx;
if (this._mainStyles.style.left > this._maxLeft) {
this._mainStyles.style.left = this._maxLeft;
};
if (this._mainStyles.style.left < 0) {
this._mainStyles.style.left = 0;
};
this._updatePosition();
LayoutAnimation.configureNext(this._CustomLayoutLinear);
},
onPanResponderTerminationRequest: (evt, gestureState) => true,
onPanResponderRelease: (evt, gestureState) => this._endMove(evt, gestureState),
onPanResponderTerminate: (evt, gestureState) => this._endMove(evt, gestureState),
onShouldBlockNativeResponder: (event, gestureState) => true,
});
this._mainStyles = {
style: {
left: this._previousLeft,
},
};
}
UNSAFE_componentWillMount() {
this.state.dismissY = new Animated.Value(0);
this.state.dismissResponder = PanResponder.create({
onStartShouldSetPanResponder: () => this.props.isActive,
onPanResponderGrant: () => {
Animated.spring(this.props.openVal, {
// Animated value passed in.
toValue: this.state.dismissY.interpolate({
// Track dismiss gesture
inputRange: [0, 300], // and interpolate pixel distance
outputRange: [1, 0], // to a fraction.
}),
}).start();
},
onPanResponderMove: Animated.event(
[null, {dy: this.state.dismissY}], // track pan gesture
),
onPanResponderRelease: (e, gestureState) => {
if (gestureState.dy > 100) {
this.props.onDismiss(gestureState.vy); // delegates dismiss action to parent
} else {
Animated.spring(this.props.openVal, {
toValue: 1, // animate back open if released early
}).start();
}
},
});
}
constructor(props) {
super(props);
this.defaultScrollEnabled = !(this.props.onPulling || this.props.onPullOk || this.props.onPullRelease); //定义onPull***属性时scrollEnabled为false
var topIndicatorHeight = this.props.topIndicatorHeight ? this.props.topIndicatorHeight : defaultTopIndicatorHeight;
this.defaultXY = {x: 0, y: topIndicatorHeight * -1};
this.pullOkMargin = this.props.pullOkMargin ? this.props.pullOkMargin : pullOkMargin;
this.state = Object.assign({}, props, {
pullPan: new Animated.ValueXY(this.defaultXY),
scrollEnabled: this.defaultScrollEnabled,
height: 0,
topIndicatorHeight: topIndicatorHeight,
});
this.onScroll = this.onScroll.bind(this);
this.onLayout = this.onLayout.bind(this);
this.isPullState = this.isPullState.bind(this);
this.resetDefaultXYHandler = this.resetDefaultXYHandler.bind(this);
this.panResponder = PanResponder.create({
onStartShouldSetPanResponder: this.onShouldSetPanResponder.bind(this),
onMoveShouldSetPanResponder: this.onShouldSetPanResponder.bind(this),
onPanResponderGrant: () => {},
// onPanResponderMove: Animated.event([null, {dy: this.state.pullPan.y}]),
onPanResponderMove: this.onPanResponderMove.bind(this),
onPanResponderRelease: this.onPanResponderRelease.bind(this),
onPanResponderTerminate: this.onPanResponderRelease.bind(this),
});
}
componentWillMount() {
this.holderPanResponder = PanResponder.create({
onStartShouldSetPanResponder: (evt, gestureState) => true,
onMoveShouldSetPanResponder: (evt, gestureState) => true,
onPanResponderGrant: (e, gestureState) => {
let {slideX} = this.state;
this.setState({moving: true});
slideX.setOffset(slideX._value);
slideX.setValue(0);
},
onPanResponderMove: (e, gestureState) => {
let totalX = this.state.slideX._offset + gestureState.dx;
let newPercent = (totalX / this.state.width) * 100;
this.notifyPercentChange(newPercent, true);
Animated.event([
null, {dx: this.state.slideX}
])(e, gestureState);
},
onPanResponderRelease: (e, gesture) => {
this.state.slideX.flattenOffset();
let newPercent = (this.state.slideX._value / this.state.width) * 100;
this.setState({moving: false});
this.notifyPercentChange(newPercent, false);
}
});
}
componentWillMount() {
let { viewPosition: position, onDragEnd, onTap } = this.props;
position = position.toJS();
this._value = position;
this._animatedValue = new Animated.ValueXY();
this._animatedValue.setValue(position);
console.log('position', position);
this._animatedValue.addListener((value) => { this._value = value;});
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: () => true,
onMoveShouldSetResponderCapture: () => true,
onMoveShouldSetPanResponderCapture: () => true,
onPanResponderGrant: (e, gestureState) => {
onTap();
this._animatedValue.setOffset(this._value);
this._animatedValue.setValue({ x: 0, y: 0 });
console.log('start drag', this._animatedValue.y);
},
onPanResponderMove: Animated.event([null, { dx: this._animatedValue.x, dy: this._animatedValue.y }]),
onPanResponderRelease: () => {
this._animatedValue.flattenOffset();
console.log('on drag end');
onDragEnd(this._animatedValue.x, this._animatedValue.y);
}
});
}
componentWillMount () {
let release = (e, gestureState) => {
const width = this.state.width
const relativeDistance = gestureState.dx / width
const vx = gestureState.vx
let change = 0
if (relativeDistance < -0.5 || (relativeDistance < 0 && vx <= 0.5)) {
change = 1
} else if (relativeDistance > 0.5 || (relativeDistance > 0 && vx >= 0.5)) {
change = -1
}
const position = this._getPosition()
if (position === 0 && change === -1) {
change = 0
} else if (position + change >= this.props.images.length) {
change = (this.props.images.length) - (position + change)
}
this._move(position + change)
return true
}
this._panResponder = PanResponder.create({
onPanResponderRelease: release
})
this._interval = setInterval(() => {
const newWidth = Dimensions.get('window').width
if (newWidth !== this.state.width) {
this.setState({width: newWidth})
}
}, 16)
}
constructor(props) {
super(props);
this.state = {
showDraggable: true,
dropZoneValues: null,
pan: new Animated.ValueXY()
};
this.panResponder = PanResponder.create({
onStartShouldSetPanResponder: () => true,
onPanResponderMove: Animated.event([null, {
dx: this.state.pan.x,
dy: this.state.pan.y
}]),
onPanResponderRelease: (e, gesture) => {
if(this.isDropZone(gesture)){
this.setState({
showDraggable: false
})
} else {
Animated.spring(
this.state.pan,
{toValue: { x:0, y:0 }}
).start();
}
}
});
}
initialize = (props) => {
let fullLength = this.getDeviceLength();
this._offsetClosed = this.getClosedOffset(props, this.state.viewport)
this._offsetOpen = this.getOpenOffset(props, this.state.viewport)
// add function options
this._prevLength = this._length
let styles = {
container: {
flex: 1,
justifyContent: 'center',
alignItems: 'center',
},
}
styles.main = Object.assign({
position: 'absolute',
borderWidth: 0,
}, this.isLeftOrRightSide() ? {top: 0} : {left: 0}, this.props.styles.main)
styles.drawer = Object.assign({
position: 'absolute',
borderWidth:0,
}, this.isLeftOrRightSide() ? {top: 0} : {left: 0}, this.props.styles.drawer)
if (props.initializeOpen || props.open) { // open
this._open = true
this._length = fullLength - this._offsetOpen
styles.main[this.props.side] = 0
styles.drawer[this.props.side] = 0
if (props.type === 'static') styles.main[this.props.side] = fullLength - this._offsetOpen
if (props.type === 'displace') styles.main[this.props.side] = fullLength - this._offsetOpen
} else { // closed
this._open = false
this._length = this._offsetClosed
styles.main[this.props.side] = this._offsetClosed
if (props.type === 'static') styles.drawer[this.props.side] = 0
if (props.type === 'overlay') styles.drawer[this.props.side] = this._offsetClosed + this._offsetOpen - fullLength
if (props.type === 'displace') styles.drawer[this.props.side] = - fullLength + this._offsetClosed + this._offsetOpen
}
if (this.main) {
this.drawer.setNativeProps({ style: {left: styles.drawer.left}})
this.main.setNativeProps({ style: {left: styles.main.left}})
} else {
this.stylesheet = StyleSheet.create(styles)
this.responder = PanResponder.create({
onStartShouldSetPanResponder: this.onStartShouldSetPanResponder,
onStartShouldSetPanResponderCapture: this.onStartShouldSetPanResponderCapture,
onMoveShouldSetPanResponder: this.onMoveShouldSetPanResponder,
onMoveShouldSetPanResponderCapture: this.onMoveShouldSetPanResponderCapture,
onPanResponderMove: this.onPanResponderMove,
onPanResponderRelease: this.onPanResponderRelease,
onPanResponderTerminate: this.onPanResponderTerminate
})
}
this.resync(null, props)
};
componentWillMount() {
this._panGesture = PanResponder.create({
onStartShouldSetPanResponder: (evt, gestureState) => { return false },
onStartShouldSetPanResponderCapture: (evt, gestureState) => { return false },
onMoveShouldSetPanResponder: (evt, gestureState) => { return false },
onMoveShouldSetPanResponderCapture: (evt, gestureState) => { return false },
});
}
componentWillMount() {
this.panResponder = PanResponder.create({
onPanResponderGrant: this.onPanResponderGrant,
onPanResponderRelease: this.onPanResponderRelease,
onMoveShouldSetPanResponder: (e, gestureState) =>
gestureState.dx > 0 || gestureState.dx < 0
});
}
componentWillMount() {
this.back = false
this.setData()
this.responder = PanResponder.create({
onMoveShouldSetPanResponder: this.handleMoveShouldSetPanResponder.bind(this)
})
this.interval = setInterval(() => this.setData(), 1000)
}
componentWillMount() {
this._panResponder = PanResponder.create({
onStartShouldSetPanResponder: (evt, gestureState) => true,
onStartShouldSetPanResponderCapture: (evt, gestureState) => true,
onMoveShouldSetPanResponder: (evt, gestureState) => true,
onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
});
}
value: function componentWillMount() {
var _this2 = this;
this.panResponder = _reactNative.PanResponder.create({
onStartShouldSetPanResponder: function onStartShouldSetPanResponder(_ref2, _ref3) {
var touches = _ref2.nativeEvent.touches;
var x0 = _ref3.x0;
var y0 = _ref3.y0;
var shouldSet = touches.length === 1;
if (shouldSet) {
var onPanBegin = _this2.props.onPanBegin;
onPanBegin && onPanBegin({ // eslint-disable-line no-unused-expressions
originX: x0,
originY: y0
});
}
return shouldSet;
},
onMoveShouldSetPanResponder: function onMoveShouldSetPanResponder(_ref4) {
var touches = _ref4.nativeEvent.touches;
return touches.length === 1;
},
onPanResponderMove: function onPanResponderMove(evt, _ref5) {
var dx = _ref5.dx;
var dy = _ref5.dy;
var onPan = _this2.props.onPan;
var panState = {
absoluteChangeX: _this2.lastX + dx,
absoluteChangeY: _this2.lastY + dy,
changeX: dx,
changeY: dy
};
onPan && onPan(panState); // eslint-disable-line no-unused-expressions
_this2.absoluteChangeX = panState.absoluteChangeX;
_this2.absoluteChangeY = panState.absoluteChangeY;
if (setGestureState) {
_this2.setState(panState);
}
},
onPanResponderTerminationRequest: function onPanResponderTerminationRequest() {
return true;
},
onPanResponderTerminate: this.handlePanResponderRelease,
onPanResponderRelease: this.handlePanResponderRelease
});
}
componentWillMount() {
this._panResponder = PanResponder.create({
onMoveShouldSetPanResponder: (e, gs) => this.handleOnMoveShouldSetPanResponder(e, gs),
onPanResponderMove: (e, gs) => this.handlePanResponderMove(e, gs),
onPanResponderRelease: (e, gs) => this.handlePanResponderEnd(e, gs),
onPanResponderTerminate: (e, gs) => this.handlePanResponderEnd(e, gs),
onShouldBlockNativeResponder: _ => false,
});
}