Fixed caret and selection handling in horizontal rule

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

   final CaretPainter _caretPainter = new CaretPainter();
 
   void _paintCaret(PaintingContext context, Offset offset) {
-    final TextPosition caret = new TextPosition(
-      offset: _selection.extentOffset - node.documentOffset,
-    );
-    Offset caretOffset = getOffsetForCaret(caret, _caretPainter.prototype);
+    Offset caretOffset =
+        getOffsetForCaret(_selection.extent, _caretPainter.prototype);
     _caretPainter.paint(context.canvas, caretOffset + offset);
   }
 

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

     return documentSelection.copyWith(baseOffset: base, extentOffset: extent);
   }
 
+  @override
+  TextPosition getPositionForOffset(Offset offset) {
+    final position = super.getPositionForOffset(offset);
+    return new TextPosition(
+      offset: _node.documentOffset + position.offset,
+      affinity: position.affinity,
+    );
+  }
+
+  @override
+  TextRange getWordBoundary(TextPosition position) {
+    final localPosition = new TextPosition(
+      offset: position.offset - _node.offset,
+      affinity: position.affinity,
+    );
+    final localRange = super.getWordBoundary(localPosition);
+    return new TextRange(
+      start: _node.documentOffset + localRange.start,
+      end: _node.documentOffset + localRange.end,
+    );
+  }
+
+  @override
+  Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
+    final localPosition = new TextPosition(
+      offset: position.offset - _node.documentOffset,
+      affinity: position.affinity,
+    );
+    return super.getOffsetForCaret(localPosition, caretPrototype);
+  }
+
   // This method works around some issues in getBoxesForSelection and handles
   // edge-case with our TextSpan objects not having last line-break character.
   @override

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

     @required this.selection,
     @required this.showCursor,
     @required this.renderContext,
-  })  : _activeParagraphs = new Set.from(renderContext.active),
+  })  : _activeBoxes = new Set.from(renderContext.active),
         super(key: key, child: child);
 
   final TextSelection selection;
   final ValueNotifier<bool> showCursor;
   final ZefyrRenderContext renderContext;
-  final Set<RenderEditableBox> _activeParagraphs;
+  final Set<RenderEditableBox> _activeBoxes;
 
   @override
   bool updateShouldNotify(ZefyrEditableTextScope oldWidget) {
     return selection != oldWidget.selection ||
         showCursor != oldWidget.showCursor ||
-        !_kEquality.equals(_activeParagraphs, oldWidget._activeParagraphs);
+        !_kEquality.equals(_activeBoxes, oldWidget._activeBoxes);
   }
 }
 

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

 
   @override
   List<ui.TextBox> getEndpointsForSelection(TextSelection selection) {
-    TextSelection local =  getLocalSelection(selection);
+    TextSelection local = getLocalSelection(selection);
     if (local.isCollapsed) {
+      final dx = local.extentOffset == 0 ? 0.0 : size.width;
       return [
-        new ui.TextBox.fromLTRBD(0.0, 0.0, 0.0, size.height, TextDirection.ltr),
+        new ui.TextBox.fromLTRBD(dx, 0.0, dx, size.height, TextDirection.ltr),
       ];
     }
 
   }
 
   @override
-  ui.TextPosition getPositionForOffset(ui.Offset offset) {
-    return new ui.TextPosition(offset: _node.documentOffset);
+  TextPosition getPositionForOffset(Offset offset) {
+    int position = _node.documentOffset;
+
+    if (offset.dx > size.width / 2) {
+      position++;
+    }
+    return new TextPosition(offset: position);
   }
 
   @override
   TextRange getWordBoundary(TextPosition position) {
-    return new TextRange(start: position.offset, end: position.offset + 1);
+    final start = _node.documentOffset;
+    return new TextRange(start: start, end: start + 1);
   }
 
   @override
   void paintSelection(PaintingContext context, Offset offset,
       TextSelection selection, Color selectionColor) {
-    final Paint paint = new Paint()..color = selectionColor;
-    final rect = new Rect.fromLTWH(0.0, 0.0, size.width, _kHeight);
-    context.canvas.drawRect(rect.shift(offset), paint);
+    final localSelection = getLocalSelection(selection);
+    assert(localSelection != null);
+    if (!localSelection.isCollapsed) {
+      final Paint paint = new Paint()..color = selectionColor;
+      final rect = new Rect.fromLTWH(0.0, 0.0, size.width, _kHeight);
+      context.canvas.drawRect(rect.shift(offset), paint);
+    }
   }
 
   @override

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

 import 'editable_text.dart';
 import 'editor.dart';
 
-RenderEditableBox _getRenderParagraph(HitTestResult result) {
+RenderEditableBox _getEditableBox(HitTestResult result) {
   for (var entry in result.path) {
     if (entry.target is RenderEditableBox) {
       return entry.target;
     HitTestResult result = new HitTestResult();
     WidgetsBinding.instance.hitTest(result, globalPoint);
 
-    final paragraph = _getRenderParagraph(result);
-    if (paragraph == null) return;
+    final box = _getEditableBox(result);
+    if (box == null) return;
 
-    final localPoint = paragraph.globalToLocal(globalPoint);
-    final position = paragraph.getPositionForOffset(localPoint);
-    final selection = new TextSelection.collapsed(
-        offset: paragraph.node.documentOffset + position.offset);
+    final localPoint = box.globalToLocal(globalPoint);
+    final position = box.getPositionForOffset(localPoint);
+    final selection = new TextSelection.collapsed(offset: position.offset);
     if (_didCaretTap && _selection == selection) {
       _didCaretTap = false;
       hideToolbar();
     _longPressPosition = null;
     HitTestResult result = new HitTestResult();
     WidgetsBinding.instance.hitTest(result, globalPoint);
-    final paragraph = _getRenderParagraph(result);
-    if (paragraph == null) {
+    final box = _getEditableBox(result);
+    if (box == null) {
       return;
     }
-    final localPoint = paragraph.globalToLocal(globalPoint);
-    final position = paragraph.getPositionForOffset(localPoint);
-    final word = paragraph.getWordBoundary(position);
+    final localPoint = box.globalToLocal(globalPoint);
+    final position = box.getPositionForOffset(localPoint);
+    final word = box.getWordBoundary(position);
     final selection = new TextSelection(
-      baseOffset: paragraph.node.documentOffset + word.start,
-      extentOffset: paragraph.node.documentOffset + word.end,
+      baseOffset: word.start,
+      extentOffset: word.end,
     );
     widget.controller.updateSelection(selection, source: ChangeSource.local);
   }
     assert(localSelection != null);
 
     final boxes = block.getEndpointsForSelection(selection);
-    if (boxes.isEmpty) {
-      print('Got empty boxes for selection ${selection}');
-      return null;
-    }
+    assert(boxes.isNotEmpty, 'Got empty boxes for selection ${selection}');
+
     final box = isBaseHandle ? boxes.first : boxes.last;
     final dx = isBaseHandle ? box.start : box.end;
     return new Offset(dx, box.bottom);
     final globalPoint = _dragPosition;
     final editor = ZefyrEditor.of(context);
     final editable = ZefyrEditableText.of(context);
-    final paragraph =
-        editable.renderContext.boxForGlobalPoint(globalPoint);
+    final paragraph = editable.renderContext.boxForGlobalPoint(globalPoint);
     if (paragraph == null) {
       return;
     }
 
     final localPoint = paragraph.globalToLocal(globalPoint);
     final position = paragraph.getPositionForOffset(localPoint);
-    final documentOffset = paragraph.node.documentOffset + position.offset;
     final newSelection = selection.copyWith(
-      baseOffset: isBaseHandle ? documentOffset : selection.baseOffset,
-      extentOffset: isBaseHandle ? selection.extentOffset : documentOffset,
+      baseOffset: isBaseHandle ? position.offset : selection.baseOffset,
+      extentOffset: isBaseHandle ? selection.extentOffset : position.offset,
     );
     if (newSelection.baseOffset >= newSelection.extentOffset) {
       // Don't allow reversed or collapsed selection.
 
 class _SelectionToolbarState extends State<_SelectionToolbar> {
   ZefyrEditableTextScope get editable => widget.editable;
+  TextSelection get selection => widget.delegate.textEditingValue.selection;
 
   @override
   Widget build(BuildContext context) {
   }
 
   Widget _buildToolbar(BuildContext context) {
-    final base = editable.selection.baseOffset;
+    final base = selection.baseOffset;
+    // TODO: Editable is not refreshed and may contain stale renderContext instance.
     final block = editable.renderContext.boxForTextOffset(base);
     if (block == null) {
       return Container();
     }
-
-    final boxes = block.getEndpointsForSelection(editable.selection);
+    final boxes = block.getEndpointsForSelection(selection);
 
     // Find the horizontal midpoint, just above the selected text.
     final Offset midpoint = new Offset(