fix scrollable offset lose

packages/zefyr/example/lib/src/full_page.dart

               ],
             ),
           ),
+          // Expanded(
+          //   child: Container(
+          //     margin: EdgeInsets.only(bottom: MediaQuery.of(context).viewInsets.bottom),
+          //     child: TextField(
+          //       // config: TextFieldConfig(
+          //       //   maxLines: null,
+          //       // ),
+          //       // style: TextFieldStyle(
+          //       //   padding: EdgeInsets.symmetric(
+          //       //     vertical: Dimens.gap_dp16,
+          //       //     horizontal: Dimens.gap_dp20,
+          //       //   ),
+          //       // ),
+          //       maxLines: null,
+          //       controller: TextEditingController(text: _controller.document.toString()),
+          //     ),
+          //   ),
+          // ),
           Expanded(
             child: ZefyrScaffold(
               child: ZefyrTheme(
   }
 
   void handlePopupItemSelected(value) {
+    FocusScope.of(context).unfocus();
+    print(FocusScope.of(context));
     if (!mounted) return;
     setState(() {
       if (value == _Options.darkTheme) {

packages/zefyr/lib/src/widgets/common.dart

         node: widget.node,
         text: buildText(context),
       );
-      // content = RichText(
-      //   text: TextSpan(
-      //     text: '123',
-      //   )
-      // );
     }
 
     if (scope.isEditable) {
 
   void ensureVisible(BuildContext context, ZefyrScope scope) {
     if (scope.selection.isCollapsed &&
-        widget.node.containsOffset(scope.selection.extentOffset)) {
+        widget.node.containsOffset(scope.selection.extentOffset) && scope.selection.extentOffset != 0) {
       WidgetsBinding.instance.addPostFrameCallback((_) {
         bringIntoView(context);
       });
     assert(object.attached);
     final RenderAbstractViewport viewport = RenderAbstractViewport.of(object);
     assert(viewport != null);
+    final lineTheme = ZefyrTheme.of(context).defaultLineTheme;
 
     final double offset = scrollable.position.pixels;
     double target = viewport.getOffsetToReveal(object, 0.0).offset;
     if (target - offset < 0.0) {
-      scrollable.position.jumpTo(target);
+      scrollable.position.jumpTo(target + lineTheme.textStyle.fontSize);
       return;
     }
     target = viewport.getOffsetToReveal(object, 1.0).offset;
     if (target - offset > 0.0) {
-      scrollable.position.jumpTo(target);
+      scrollable.position.jumpTo(target + lineTheme.textStyle.fontSize);
     }
   }
 

packages/zefyr/lib/src/widgets/controller.dart

   /// Zefyr document managed by this controller.
   NotusDocument get document => _document;
   NotusDocument _document;
+  set document(NotusDocument value) {
+    _document = value;
+  }
 
   /// Currently selected text within the [document].
   TextSelection get selection => _selection;

packages/zefyr/lib/src/widgets/editable_text.dart

     this.selectionControls,
     this.autofocus = true,
     this.mode = ZefyrMode.edit,
-    @required this.input,
+    // @required this.input,
     this.padding = const EdgeInsets.symmetric(horizontal: 16.0),
     this.physics,
     this.keyboardAppearance = Brightness.light,
   /// Editing mode of this text field.
   final ZefyrMode mode;
 
-  final InputConnectionController input;
+  // final InputConnectionController input;
 
   /// Controls physics of scrollable text field.
   final ScrollPhysics physics;
   final Brightness keyboardAppearance;
 
   @override
-  _ZefyrEditableTextState createState() => _ZefyrEditableTextState();
+  ZefyrEditableTextState createState() => ZefyrEditableTextState();
 }
 
-class _ZefyrEditableTextState extends State<ZefyrEditableText>
+class ZefyrEditableTextState extends State<ZefyrEditableText>
     with AutomaticKeepAliveClientMixin {
   //
   // New public members
     _focusNode = widget.focusNode;
     super.initState();
     _focusAttachment = _focusNode.attach(context);
+    // widget.controller.updateSelection(TextSelection.collapsed(offset: widget.controller.plainTextEditingValue.text.length));
+    _input = InputConnectionController(_handleRemoteValueChange);
+    // ..openConnection(widget.controller.plainTextEditingValue, widget.keyboardAppearance, showKeyboard: false);
+    
     _updateSubscriptions();
   }
 
       _cursorTimer = scope.cursorTimer;
       _cursorTimer.startOrStop(_focusNode, selection);
     }
+    print(FocusScope.of(context));
     focusOrUnfocusIfNeeded();
   }
 
   final ScrollController _scrollController = ScrollController();
   ZefyrRenderContext _renderContext;
   CursorTimer _cursorTimer;
-  InputConnectionController get _input => widget.input;
+  InputConnectionController _input;
+  // InputConnectionController get _input => widget.input;
   bool _didAutoFocus = false;
 
   List<Widget> _buildChildren(BuildContext context) {
         return ZefyrHeading(node: node);
       }
       return ZefyrParagraph(node: node);
-      //  else if (node.style.contains(NotusAttribute.line)) {
-      //   return ZefyrLineDecoration(node: node);
-      // }
     }
 
     final BlockNode block = node;
     if (widget.focusNode != oldWidget.focusNode) {
       oldWidget.focusNode.removeListener(_handleFocusChange);
       widget.focusNode.addListener(_handleFocusChange);
-      updateKeepAlive();
+      // updateKeepAlive();
     }
   }
 
     _input.openOrCloseConnection(_focusNode,
         widget.controller.plainTextEditingValue, widget.keyboardAppearance, showKeyboard: showKeyboard);
     _cursorTimer.startOrStop(_focusNode, selection);
-    updateKeepAlive();
+    // updateKeepAlive();
   }
 
   void _handleRemoteValueChange(

packages/zefyr/lib/src/widgets/editor.dart

         : fallbackTheme;
 
     if (_scope == null) {
+      // FocusScope.of(context).requestFocus(widget.focusNode);
+      // FocusScope.of(context).setFirstFocus(FocusScope.of(context));
       _scope = ZefyrScope.editable(
         mode: widget.mode,
         imageDelegate: _imageDelegate,
       selectionControls: widget.selectionControls,
       autofocus: widget.autofocus,
       mode: widget.mode,
-      input: _scope.input,
+      // input: _scope.input,
       padding: widget.padding,
       physics: widget.physics,
       keyboardAppearance: keyboardAppearance,
     );
+    // Widget editable = SingleChildScrollView(
+    //       physics: widget.physics,
+    //       child: Column(
+    //         children: List.generate(100, (index) => Container(
+    //           height: 50,
+    //           color: Colors.black.withOpacity(index / 100),
+    //         ),),
+    //       ),
+    //     );
 
     return ZefyrTheme(
       data: _themeData,

packages/zefyr/lib/src/widgets/scaffold.dart

   const ZefyrScaffold({Key key, this.child}) : super(key: key);
 
   static ZefyrScaffoldState of(BuildContext context) {
-    final _ZefyrScaffoldAccess widget =
-        context.dependOnInheritedWidgetOfExactType<_ZefyrScaffoldAccess>();
-    return widget.scaffold;
+    final widget = context.dependOnInheritedWidgetOfExactType<_ZefyrScaffoldAccess>();
+    return widget?.scaffold;
   }
 
   @override
 class _ZefyrScaffoldAccess extends InheritedWidget {
   final ZefyrScaffoldState scaffold;
 
-  _ZefyrScaffoldAccess({Widget child, this.scaffold}) : super(child: child);
+  _ZefyrScaffoldAccess({Key key, Widget child, this.scaffold}) : super(key: key, child: child);
 
   @override
   bool updateShouldNotify(_ZefyrScaffoldAccess oldWidget) {
-    return oldWidget.scaffold != scaffold;
+    return true;//oldWidget.scaffold != scaffold;
   }
 }

packages/zefyr/lib/src/widgets/scope.dart

         _focusNode = focusNode,
         _focusScope = focusScope,
         _cursorTimer = CursorTimer(),
-        _input = InputConnectionController((int start, String deleted, String inserted, TextSelection selection) {
-          controller.replaceText(start, deleted.length, inserted, selection: selection);
-        }),
+        // _input = InputConnectionController((int start, String deleted, String inserted, TextSelection selection) {
+        //   controller.replaceText(start, deleted.length, inserted, selection: selection);
+        // }),
         _renderContext = ZefyrRenderContext() {
     _selectionStyle = _controller.getSelectionStyle();
     _selection = _controller.selection;
     return widget.scope;
   }
 
-  InputConnectionController _input;
-  InputConnectionController get input => _input;
+  // InputConnectionController _input;
+  // InputConnectionController get input => _input;
 
   bool _keepOverlay = false;
   bool get keepOverlay => _keepOverlay;

packages/zefyr/lib/src/widgets/theme.dart

 
   /// The default editor theme.
   factory ZefyrThemeData.fallback(BuildContext context) {
+    final theme = Theme.of(context);
     final defaultStyle = DefaultTextStyle.of(context);
     final defaultLineTheme = LineTheme(
       textStyle: defaultStyle.style.copyWith(
         fontSize: 16.0,
         height: 1.3,
-        color: Color(0xFF595959),
+        color: theme.brightness == Brightness.light ? Color(0xFF595959) : Color(0xFFA8A8A8),
       ),
       padding: EdgeInsets.symmetric(vertical: 8.0),
     );
           height: 1.5,
           fontWeight: FontWeight.w500,
         ),
-        padding: EdgeInsets.only(top: 16.0),
+        padding: EdgeInsets.only(top: 8.0),
       ),
       heading2: LineTheme(
         textStyle: defaultLineTheme.textStyle.copyWith(

packages/zefyr/lib/src/widgets/toolbar.dart

 
 const kDefaultButtonTexts = {};
 
-final kToolbarDivider = Container(
-  width: 1,
-  color: Color(0xFFE2E2E2),
-  height: 28,
-  margin: EdgeInsets.symmetric(horizontal: 10),
-);
-
 const kTextColors = [
   Color(0xFFFA6400),
   Color(0xFFF7B500),
       _keyboardHeight = MediaQuery.of(context).viewInsets.bottom;
     }
     final theme = ZefyrTheme.of(context).toolbarTheme;
-    
+
+    final kToolbarDivider = Container(
+      width: 1,
+      color: theme.dividerColor,
+      height: 28,
+      margin: EdgeInsets.symmetric(horizontal: 10),
+    );
     final layers = <Widget>[];
     Widget overlay;