Merge pull request #8 from wix/update-offset-and-cursor-calculation-fix

Fix update offset and cursor position calculation

src/RichTextEditor.js

 import WebViewBridge from 'react-native-webview-bridge-updated';
 import {InjectedMessageHandler} from './WebviewMessageHandler';
 import {actions, messages} from './const';
-import {Modal, View, Text, StyleSheet, TextInput, TouchableOpacity, Platform, PixelRatio, Keyboard} from 'react-native';
+import {Modal, View, Text, StyleSheet, TextInput, TouchableOpacity, Platform, PixelRatio, Keyboard, Dimensions} from 'react-native';
 
 const injectScript = `
   (function () {
   }());
 `;
 
-const PlatfomIOS = Platform.OS === 'ios';
+const PlatformIOS = Platform.OS === 'ios';
 
 export default class RichTextEditor extends Component {
   static propTypes = {
     editorInitializedCallback: PropTypes.func,
     customCSS: PropTypes.string,
     hiddenTitle: PropTypes.bool,
-    enableOnChange: PropTypes.bool
+    enableOnChange: PropTypes.bool,
+    footerHeight: PropTypes.number
   };
 
   constructor(props) {
   }
 
   componentWillMount() {
-    if(PlatfomIOS) {
+    if(PlatformIOS) {
       this.keyboardEventListeners = [
         Keyboard.addListener('keyboardWillShow', this._onKeyboardWillShow),
         Keyboard.addListener('keyboardWillHide', this._onKeyboardWillHide)
     if (this.state.keyboardHeight === newKeyboardHeight) {
       return;
     }
+    if (newKeyboardHeight) {
+      this.setEditorAvailableHeightBasedOnKeyboardHeight(newKeyboardHeight);
+    }
     this.setState({keyboardHeight: newKeyboardHeight});
   }
 
   _onKeyboardWillHide(event) {
     this.setState({keyboardHeight: 0});
   }
+
+  setEditorAvailableHeightBasedOnKeyboardHeight(keyboardHeight) {
+    const {top = 0, bottom = 0} = this.props.contentInset;
+    const {marginTop = 0, marginBottom = 0} = this.props.style;
+    const spacing = marginTop + marginBottom + top + bottom;
+
+    const editorAvailableHeight = Dimensions.get('window').height - keyboardHeight - spacing;
+    this.setEditorHeight(editorAvailableHeight);
+  }
   
   onBridgeMessage(str){
     try {
             onRequestClose={() => this.setState({showLinkDialog: false})}
         >
           <View style={styles.modal}>
-            <View style={[styles.innerModal, {marginBottom: PlatfomIOS ? this.state.keyboardHeight : 0}]}>
+            <View style={[styles.innerModal, {marginBottom: PlatformIOS ? this.state.keyboardHeight : 0}]}>
               <Text style={styles.inputTitle}>Title</Text>
               <View style={styles.inputWrapper}>
                 <TextInput
                     autoCorrect={false}
                 />
               </View>
-              {PlatfomIOS && <View style={styles.lineSeparator}/>}
+              {PlatformIOS && <View style={styles.lineSeparator}/>}
               {this._renderModalButtons()}
             </View>
           </View>
 
   _renderModalButtons() {
     const insertUpdateDisabled = this.state.linkTitle.trim().length <= 0 || this.state.linkUrl.trim().length <= 0;
-    const containerPlatformStyle = PlatfomIOS ? {justifyContent: 'space-between'} : {paddingTop: 15};
-    const buttonPlatformStyle = PlatfomIOS ? {flex: 1, height: 45, justifyContent: 'center'} : {};
+    const containerPlatformStyle = PlatformIOS ? {justifyContent: 'space-between'} : {paddingTop: 15};
+    const buttonPlatformStyle = PlatformIOS ? {flex: 1, height: 45, justifyContent: 'center'} : {};
     return (
       <View style={[{alignSelf: 'stretch', flexDirection: 'row'}, containerPlatformStyle]}>
-        {!PlatfomIOS && <View style={{flex: 1}}/>}
+        {!PlatformIOS && <View style={{flex: 1}}/>}
         <TouchableOpacity
             onPress={() => this._hideModal()}
             style={buttonPlatformStyle}
   }
 
   _upperCaseButtonTextIfNeeded(buttonText) {
-    return PlatfomIOS ? buttonText : buttonText.toUpperCase();
+    return PlatformIOS ? buttonText : buttonText.toUpperCase();
   }
 
   render() {
     //in release build, external html files in Android can't be required, so they must be placed in the assets folder and accessed via uri
-    const pageSource = PlatfomIOS ? require('./editor.html') : { uri: 'file:///android_asset/editor.html' };
+    const pageSource = PlatformIOS ? require('./editor.html') : { uri: 'file:///android_asset/editor.html' };
     return (
       <View style={{flex: 1}}>
         <WebViewBridge
-          style={{flex: 1}}
           {...this.props}
           hideKeyboardAccessoryView={true}
           keyboardDisplayRequiresUserAction={false}
 
   init() {
     this._sendAction(actions.init);
+    this.setPlatform();
+    if (this.props.footerHeight) {
+      this.setFooterHeight();
+    }
+  }
+
+  setEditorHeight(height) {
+    this._sendAction(actions.setEditorHeight, height);
+  }
+
+  setFooterHeight() {
+    this._sendAction(actions.setFooterHeight, this.props.footerHeight);
+  }
+
+  setPlatform() {
+    this._sendAction(actions.setPlatform, Platform.OS);
   }
 
   async getTitleHtml() {
   innerModal: {
     backgroundColor: 'rgba(255, 255, 255, 0.9)',
     paddingTop: 20,
-    paddingBottom: PlatfomIOS ? 0 : 20,
+    paddingBottom: PlatformIOS ? 0 : 20,
     paddingLeft: 20,
     paddingRight: 20,
     alignSelf: 'stretch',
     margin: 40,
-    borderRadius: PlatfomIOS ? 8 : 2
+    borderRadius: PlatformIOS ? 8 : 2
   },
   button: {
     fontSize: 16,
     marginTop: 5,
     marginBottom: 10,
     borderBottomColor: '#4a4a4a',
-    borderBottomWidth: PlatfomIOS ? 1 / PixelRatio.get() : 0
+    borderBottomWidth: PlatformIOS ? 1 / PixelRatio.get() : 0
   },
   inputTitle: {
     color: '#4a4a4a'
   },
   input: {
-    height: PlatfomIOS ? 20 : 40,
+    height: PlatformIOS ? 20 : 40,
     paddingTop: 0
   },
   lineSeparator: {

src/WebviewMessageHandler.js

         case '${actions.init}':
           zss_editor.init();
           break;
+        case '${actions.setEditorHeight}':
+          zss_editor.setEditorHeight(action.data);
+          break;
+        case '${actions.setFooterHeight}':
+          zss_editor.setFooterHeight(action.data);
+          break;
+        case '${actions.setPlatform}':
+          zss_editor.setPlatform(action.data);
+          break;
       }
     };
   }

src/const.js

   setCustomCSS: 'SET_CUSTOM_CSS',
   setTextColor: 'SET_TEXT_COLOR',
   setBackgroundColor: 'SET_BACKGROUND_COLOR',
-  init: 'ZSSS_INIT'
+  init: 'ZSSS_INIT',
+  setEditorHeight: 'SET_EDITOR_HEIGHT',
+  setFooterHeight: 'SET_FOOTER_HEIGHT',
+  setPlatform: 'SET_PLATFORM'
 };
 
 

src/editor.html

 			zss_editor.enabledItems = {};
 
 			// Height of content window, will be set by viewController
-			zss_editor.contentHeight = 244;
+			zss_editor.editorHeight = 244;
 
 			// Sets to true when extra footer gap shows and requires to hide
 			zss_editor.updateScrollOffset = false;
 				$(window).on('touchstart', function(e) {
 					zss_editor.isDragging = false;
 				});
+				$(window).on('scroll', function(e) {
+					if (zss_editor.platform === 'ios') {
+						zss_editor.updateOffset();
+					}
+				});
 
 				setupTouchEndFocus('zss_editor_title');
 				setupTouchEndFocus('zss_editor_content');
 
 				var offsetY = window.document.body.scrollTop;
 
-				var footer = $('#zss_editor_footer');
+				var footer = document.getElementById('zss_editor_footer');
 
-				var maxOffsetY = footer.offset().top - zss_editor.contentHeight;
+				var maxOffsetY = footer.offsetTop + footer.offsetHeight - zss_editor.editorHeight;
 
 				if (maxOffsetY < 0)
 					maxOffsetY = 0;
 			}
 
 			zss_editor.calculateEditorHeightWithCaretPosition = function() {
-
-				var padding = 50;
-				var c = zss_editor.getCaretYPosition();
-
+				var caretYPosition = zss_editor.getCaretYPosition();
+				var lineHeight = 20;
+				var halfLineHeight = lineHeight/2;
 				var offsetY = window.document.body.scrollTop;
-				var height = zss_editor.contentHeight;
-
-				var newPos = window.pageYOffset;
-
-				if (c < offsetY) {
-					newPos = c;
-				} else if (c > (offsetY + height - padding)) {
-					newPos = c - height + padding - 18;
+				var editorHeight = zss_editor.editorHeight;
+				var newPos;
+
+				var futureEditorHeight = caretYPosition + lineHeight;
+				if (caretYPosition < offsetY) {
+					newPos = caretYPosition;
+				} else if (futureEditorHeight > editorHeight + offsetY) {
+					newPos = futureEditorHeight - editorHeight + halfLineHeight;
 				}
 
-				window.scrollTo(0, newPos);
+				if (newPos) {
+					window.scrollTo(0, newPos);
+				}
 			}
 
 			zss_editor.backuprange = function(){
 				});
 			}
 
+			zss_editor.setEditorHeight = function(editorHeight) {
+				zss_editor.editorHeight = editorHeight;
+			}
+
+			zss_editor.setPlatform = function(platform) {
+				zss_editor.platform = platform;
+			}
+
 			//end
 		</script>