merged in master

.gitbook.yaml

+root: ./doc/
+
+structure:
+  readme: ./../README.md

.travis.yml

       - ubuntu-toolchain-r-test
     packages:
       - libstdc++6
-      - fonts-droid
+      - fonts-droid-fallback
 
 cache:
   directories:
     - $HOME/.pub-cache
 
-#env:
-#  - FLUTTER_VERSION=stable
-#  - FLUTTER_VERSION=master
-
-matrix:
-  include:
-    - name: "Master build"
-      if: branch = flutter-master
-      env: FLUTTER_VERSION=master
-    - name: "Stable build"
-      if: branch != flutter-master
-      env: FLUTTER_VERSION=stable
+env:
+  - FLUTTER_VERSION=stable
 
 before_script:
   - pwd

doc/images.md

 ## Images
 
-> Note that described API is considered experimental and is likely to be
+> Note that Image API is considered experimental and is likely to be
 > changed in backward incompatible ways. If this happens all changes will be
 > described in detail in the changelog to simplify upgrading.
 
-Zefyr (and Notus) supports embedded images. In order to handle images in
+Zefyr supports embedding images. In order to handle images in
 your application you need to implement `ZefyrImageDelegate` interface which
 looks like this:
 
 ```dart
 abstract class ZefyrImageDelegate<S> {
-  /// Builds image widget for specified [imageSource] and [context].
-  Widget buildImage(BuildContext context, String imageSource);
+  /// Unique key to identify camera source.
+  S get cameraSource;
+
+  /// Unique key to identify gallery source.
+  S get gallerySource;
+
+  /// Builds image widget for specified image [key].
+  ///
+  /// The [key] argument contains value which was previously returned from
+  /// [pickImage].
+  Widget buildImage(BuildContext context, String key);
 
   /// Picks an image from specified [source].
   ///
   /// Returns unique string key for the selected image. Returned key is stored
   /// in the document.
+  ///
+  /// Depending on your application returned key may represent a path to
+  /// an image file on user's device, an HTTP link, or an identifier generated
+  /// by a file hosting service like AWS S3 or Google Drive.
   Future<String> pickImage(S source);
 }
 ```
 
-Zefyr comes with default implementation which exists mostly to provide an
-example and a starting point for your own version.
+There is no default implementation of this interface since resolving image
+sources is always application-specific.
 
-It is recommended to always have your own implementation specific to your
-application.
+> Note that prior to 0.7.0 Zefyr did provide simple default implementation of
+> `ZefyrImageDelegate` however it was removed as it introduced unnecessary
+> dependency on `image_picker` plugin.
 
 ### Implementing ZefyrImageDelegate
 
+For this example we will use [image_picker](https://pub.dev/packages/image_picker)
+plugin which allows us to select images from device's camera or photo gallery.
+
 Let's start from the `pickImage` method:
 
 ```dart
-// Currently Zefyr depends on image_picker plugin to show camera or image gallery.
-// (note that in future versions this may change so that users can choose their
-// own plugin and define custom sources)
 import 'package:image_picker/image_picker.dart';
 
 class MyAppZefyrImageDelegate implements ZefyrImageDelegate<ImageSource> {
 which essentially serves as an identifier for the image.
 
 Returned value is stored in the document Delta and later on used to build the
-appropriate `Widget`.
+appropriate image widget.
 
 It is up to the developer to define what this value represents.
 
 In the above example we simply return a full path to the file on user's device,
 e.g. `file:///Users/something/something/image.jpg`. Some other examples
-may include a web link, `https://myapp.com/images/some.jpg` or just some
-arbitrary string like an ID.
+may include a web link, `https://myapp.com/images/some.jpg` or an
+arbitrary string like an identifier of an image in a cloud storage like AWS S3.
 
 For instance, if you upload files to your server you can initiate this task
-in `pickImage`, for instance:
+in `pickImage` as follows:
 
 ```dart
 class MyAppZefyrImageDelegate implements ZefyrImageDelegate<ImageSource> {
 
 Next we need to implement `buildImage`. This method takes `imageSource` argument
 which contains that same string you returned from `pickImage`. Here you can
-use this value to create a Flutter `Widget` which renders the image. Normally
+use this value to create a Flutter widget which renders the image. Normally
 you would return the standard `Image` widget from this method, but it is not
 a requirement. You are free to create a custom widget which, for instance,
 shows progress of upload operation that you initiated in the `pickImage` call.
   // ...
 
   @override
-  Widget buildImage(BuildContext context, String imageSource) {
-    final file = new File.fromUri(Uri.parse(imageSource));
-    /// Create standard [FileImage] provider. If [imageSource] was an HTTP link
+  Widget buildImage(BuildContext context, String key) {
+    final file = File.fromUri(Uri.parse(key));
+    /// Create standard [FileImage] provider. If [key] was an HTTP link
     /// we could use [NetworkImage] instead.
-    final image = new FileImage(file);
-    return new Image(image: image);
+    final image = FileImage(file);
+    return Image(image: image);
+  }
+}
+```
+
+There is two more overrides we need to implement which configure source types
+used by Zefyr toolbar:
+
+```dart
+class MyAppZefyrImageDelegate implements ZefyrImageDelegate<ImageSource> {
+  // ...
+  @override
+  ImageSource get cameraSource => ImageSource.camera;
+
+  @override
+  ImageSource get gallerySource => ImageSource.gallery;
+}
+```
+
+Now our image delegate is ready to be used by Zefyr so the last step is to
+pass it to Zefyr editor:
+
+```dart
+import 'package:zefyr/zefyr.dart'
+
+class MyAppPageState extends State<MyAppPage> {
+  FocueNode _focusNode = FocusNode();
+  ZefyrController _controller;
+
+  // ...
+
+  @override
+  Widget build(BuildContext context) {
+    final editor = new ZefyrEditor(
+      focusNode: _focusNode,
+      controller: _controller,
+      imageDelegate: MyAppZefyrImageDelegate(),
+    );
+
+    // ... do more with this page's layout
+
+    return ZefyrScaffold(
+      child: Container(
+        // ... customize
+        child: editor,
+      )
+    );
   }
 }
 ```
 
 * [Heuristics][heuristics]
 
-[heuristics]: /doc/heuristics.md
+[heuristics]: /doc/heuristics.md

packages/zefyr/CHANGELOG.md

+## 0.7.0
+
+This release contains breaking changes.
+
+* Breaking change: `ZefyrEditor.enabled` field replaced by `ZefyrEditor.mode` which can take
+  one of three default values:
+    - `ZefyrMode.edit`: the same as `enabled: true`, all editing controls are available to the user
+    - `ZefyrMode.select`: user can't modify text itself, but allowed to select it and optionally
+       apply formatting.
+    - `ZefyrMode.view`: the same as `enabled: false`, read-only.
+* Added optional `selectionControls` field to `ZefyrEditor` and `ZefyrEditableText`. If not provided
+  then by default uses platform-specific implementation.
+* Added support for "selectAll" action in selection toolbar.
+* Breaking change: removed `ZefyrDefaultImageDelegate` as well as dependency on
+  `image_picker` plugin. Users are required to provide their own implementation. If image delegate
+  is not provided then image toolbar button is disabled.
+* Breaking change: added `ZefyrImageDelegate.cameraSource` and `ZefyrImageDelegate.gallerySource`
+  fields. For users of `image_picker` plugin these should return `ImageSource.camera` and
+  `ImageSource.gallery` respectively. See documentation on implementing image support for more
+  details.
+
 ## 0.6.1
 
 * Relaxed dependency constraint on `image_picker` library to allow latest version. Note that

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

+// Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 import 'package:flutter/material.dart';
 import 'package:zefyr/zefyr.dart';
 
 import 'full_page.dart';
+import 'images.dart';
 
 class FormEmbeddedScreen extends StatefulWidget {
   @override

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

+// Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:quill_delta/quill_delta.dart';
 import 'package:zefyr/zefyr.dart';
 
+import 'images.dart';
+
 class ZefyrLogo extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
           child: ZefyrEditor(
             controller: _controller,
             focusNode: _focusNode,
-            enabled: _editing,
+            mode: _editing ? ZefyrMode.edit : ZefyrMode.select,
             imageDelegate: new CustomImageDelegate(),
           ),
         ),
     });
   }
 }
-
-/// Custom image delegate used by this example to load image from application
-/// assets.
-///
-/// Default image delegate only supports [FileImage]s.
-class CustomImageDelegate extends ZefyrDefaultImageDelegate {
-  @override
-  Widget buildImage(BuildContext context, String imageSource) {
-    // We use custom "asset" scheme to distinguish asset images from other files.
-    if (imageSource.startsWith('asset://')) {
-      final asset = new AssetImage(imageSource.replaceFirst('asset://', ''));
-      return new Image(image: asset);
-    } else {
-      return super.buildImage(context, imageSource);
-    }
-  }
-}

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

+// Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+
+import 'package:flutter/widgets.dart';
+import 'package:image_picker/image_picker.dart';
+import 'package:zefyr/zefyr.dart';
+
+/// Custom image delegate used by this example to load image from application
+/// assets.
+class CustomImageDelegate implements ZefyrImageDelegate<ImageSource> {
+  @override
+  ImageSource get cameraSource => ImageSource.camera;
+
+  @override
+  ImageSource get gallerySource => ImageSource.gallery;
+
+  @override
+  Future<String> pickImage(ImageSource source) async {
+    final file = await ImagePicker.pickImage(source: source);
+    if (file == null) return null;
+    return file.uri.toString();
+  }
+
+  @override
+  Widget buildImage(BuildContext context, String key) {
+    // We use custom "asset" scheme to distinguish asset images from other files.
+    if (key.startsWith('asset://')) {
+      final asset = AssetImage(key.replaceFirst('asset://', ''));
+      return Image(image: asset);
+    } else {
+      // Otherwise assume this is a file stored locally on user's device.
+      final file = File.fromUri(Uri.parse(key));
+      final image = FileImage(file);
+      return new Image(image: image);
+    }
+  }
+}

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

+// Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
 import 'dart:convert';
 
 import 'package:flutter/material.dart';
 import 'package:zefyr/zefyr.dart';
 
 import 'full_page.dart';
+import 'images.dart';
 
 class ViewScreen extends StatefulWidget {
   @override
     );
   }
 }
-
-/// Custom image delegate used by this example to load image from application
-/// assets.
-///
-/// Default image delegate only supports [FileImage]s.
-class CustomImageDelegate extends ZefyrDefaultImageDelegate {
-  @override
-  Widget buildImage(BuildContext context, String imageSource) {
-    // We use custom "asset" scheme to distinguish asset images from other files.
-    if (imageSource.startsWith('asset://')) {
-      final asset = new AssetImage(imageSource.replaceFirst('asset://', ''));
-      return new Image(image: asset);
-    } else {
-      return super.buildImage(context, imageSource);
-    }
-  }
-}

packages/zefyr/example/pubspec.yaml

   # The following adds the Cupertino Icons font to your application.
   # Use with the CupertinoIcons class for iOS style icons.
   cupertino_icons: ^0.1.2
+  image_picker: ^0.6.1
   zefyr:
     path: ../
 

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

 // BSD-style license that can be found in the LICENSE file.
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
-import 'package:image_picker/image_picker.dart';
 import 'package:notus/notus.dart';
 import 'package:url_launcher/url_launcher.dart';
 
       );
     } else {
       assert(_text != null);
-      var style = _textStyle ?? new TextStyle();
+      var style = _textStyle ?? TextStyle();
       style = style.copyWith(color: iconColor);
       return RawZefyrButton(
         action: action,
-        child: new Text(_text, style: style),
+        child: Text(_text, style: style),
         color: _getColor(editor, toolbarTheme),
         onPressed: _getPressedHandler(editor, toolbar),
       );
     Color iconColor,
     @required this.color,
     @required this.onPressed,
-  })  : child = new Icon(icon, size: size, color: iconColor),
+  })  : child = Icon(icon, size: size, color: iconColor),
         super();
 
   /// Toolbar action associated with this button.
 
   void _pickFromCamera() async {
     final editor = ZefyrToolbar.of(context).editor;
-    final image = await editor.imageDelegate.pickImage(ImageSource.camera);
+    final image =
+        await editor.imageDelegate.pickImage(editor.imageDelegate.cameraSource);
     if (image != null)
       editor.formatSelection(NotusAttribute.embed.image(image));
   }
 
   void _pickFromGallery() async {
     final editor = ZefyrToolbar.of(context).editor;
-    final image = await editor.imageDelegate.pickImage(ImageSource.gallery);
+    final image = await editor.imageDelegate
+        .pickImage(editor.imageDelegate.gallerySource);
     if (image != null)
       editor.formatSelection(NotusAttribute.embed.image(image));
   }
   void edit() {
     final toolbar = ZefyrToolbar.of(context);
     setState(() {
-      _inputKey = new UniqueKey();
+      _inputKey = UniqueKey();
       _inputController.text = getLink('https://');
       _inputController.addListener(_handleInputChange);
       toolbar.markNeedsRebuild();
   void copyToClipboard() {
     var link = getLink();
     assert(link != null);
-    Clipboard.setData(new ClipboardData(text: link));
+    Clipboard.setData(ClipboardData(text: link));
   }
 
   void openInBrowser() async {
 
   @override
   _LinkInputState createState() {
-    return new _LinkInputState();
+    return _LinkInputState();
   }
 }
 
       focusNode: _focusNode,
       controller: widget.controller,
       autofocus: true,
-      decoration: new InputDecoration(
+      decoration: InputDecoration(
         hintText: 'https://',
         filled: true,
         fillColor: toolbarTheme.color,
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final toolbarTheme = ZefyrTheme.of(context).toolbarTheme;
-    Widget widget = new ClipRect(
+    Widget widget = ClipRect(
       child: ListView(
         scrollDirection: Axis.horizontal,
         children: <Widget>[

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

   static const double _kCaretWidth = 1.0; // pixels
 
   static Rect buildPrototype(double lineHeight) {
-    return new Rect.fromLTWH(
+    return Rect.fromLTWH(
         0.0, 0.0, _kCaretWidth, lineHeight - _kCaretHeightOffset);
   }
 
   }
 
   void paint(Canvas canvas, Offset offset) {
-    final Paint paint = new Paint()..color = _color;
+    final Paint paint = Paint()..color = _color;
     final Rect caretRect = _prototype.shift(offset);
     canvas.drawRect(caretRect, paint);
   }

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

       items.add(_buildLine(line, theme.blockTheme.code.textStyle));
     }
 
-    return new Padding(
+    return Padding(
       padding: theme.blockTheme.code.padding,
-      child: new Container(
+      child: Container(
         // TODO: make decorations configurable
         decoration: BoxDecoration(
           color: Colors.blueGrey.shade50,
           borderRadius: BorderRadius.circular(3.0),
         ),
         padding: const EdgeInsets.all(16.0),
-        child: new Column(
+        child: Column(
           crossAxisAlignment: CrossAxisAlignment.stretch,
           children: items,
         ),
 
   Widget _buildLine(Node node, TextStyle style) {
     LineNode line = node;
-    return new RawZefyrLine(node: line, style: style);
+    return RawZefyrLine(node: line, style: style);
   }
 }

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

   final EdgeInsets padding;
 
   @override
-  _RawZefyrLineState createState() => new _RawZefyrLineState();
+  _RawZefyrLineState createState() => _RawZefyrLineState();
 }
 
 class _RawZefyrLineState extends State<RawZefyrLine> {
-  final LayerLink _link = new LayerLink();
+  final LayerLink _link = LayerLink();
 
   @override
   Widget build(BuildContext context) {
     final List<TextSpan> children = widget.node.children
         .map((node) => _segmentToTextSpan(node, theme))
         .toList(growable: false);
-    return new TextSpan(style: widget.style, children: children);
+    return TextSpan(style: widget.style, children: children);
   }
 
   TextSpan _segmentToTextSpan(Node node, ZefyrThemeData theme) {
     final TextNode segment = node;
     final attrs = segment.style;
 
-    return new TextSpan(
+    return TextSpan(
       text: segment.value,
       style: _getTextStyle(attrs, theme),
     );
   }
 
   TextStyle _getTextStyle(NotusStyle style, ZefyrThemeData theme) {
-    TextStyle result = new TextStyle();
+    TextStyle result = TextStyle();
     if (style.containsSame(NotusAttribute.bold)) {
       result = result.merge(theme.boldStyle);
     }
     } else if (embed.type == EmbedType.image) {
       return ZefyrImage(node: node, delegate: scope.imageDelegate);
     } else {
-      throw new UnimplementedError('Unimplemented embed type ${embed.type}');
+      throw UnimplementedError('Unimplemented embed type ${embed.type}');
     }
   }
 }

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

     notifyListeners();
   }
 
+  /// Replaces [length] characters in the document starting at [index] with
+  /// provided [text].
+  ///
+  /// Resulting change is registered as produced by user action, e.g.
+  /// using [ChangeSource.local].
+  ///
+  /// Optionally updates selection if provided.
   void replaceText(int index, int length, String text,
       {TextSelection selection}) {
     Delta delta;
       } else {
         // need to transform selection position in case actual delta
         // is different from user's version (in deletes and inserts).
-        Delta user = new Delta()
+        Delta user = Delta()
           ..retain(index)
           ..insert(text)
           ..delete(length);
     // the change. This is needed in cases when format operation actually
     // inserts data into the document (e.g. embeds).
     final base = change.transformPosition(_selection.baseOffset);
-    final extent =
-        change.transformPosition(_selection.extentOffset);
+    final extent = change.transformPosition(_selection.extentOffset);
     final adjustedSelection =
         _selection.copyWith(baseOffset: base, extentOffset: extent);
     if (_selection != adjustedSelection) {
   }
 
   TextEditingValue get plainTextEditingValue {
-    return new TextEditingValue(
+    return TextEditingValue(
       text: document.toPlainText(),
       selection: selection,
-      composing: new TextRange.collapsed(0),
+      composing: TextRange.collapsed(0),
     );
   }
 

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

 
   @override
   RenderEditableProxyBox createRenderObject(BuildContext context) {
-    return new RenderEditableProxyBox(
+    return RenderEditableProxyBox(
       node: node,
       layerLink: layerLink,
       renderContext: renderContext,
   @override
   bool hitTest(HitTestResult result, {Offset position}) {
     if (size.contains(position)) {
-      result.add(new BoxHitTestEntry(this, position));
+      result.add(BoxHitTestEntry(this, position));
       return true;
     }
     return false;

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

 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
 import 'package:flutter/widgets.dart';
 import 'package:notus/notus.dart';
 
 import 'image.dart';
 import 'input.dart';
 import 'list.dart';
+import 'mode.dart';
 import 'paragraph.dart';
 import 'quote.dart';
 import 'render_context.dart';
     @required this.controller,
     @required this.focusNode,
     @required this.imageDelegate,
+    this.selectionControls,
     this.autofocus: true,
-    this.enabled: true,
+    this.mode: ZefyrMode.edit,
     this.padding: const EdgeInsets.symmetric(horizontal: 16.0),
     this.physics,
-  }) : super(key: key);
+  })  : assert(mode != null),
+        assert(controller != null),
+        assert(focusNode != null),
+        super(key: key);
 
+  /// Controls the document being edited.
   final ZefyrController controller;
+
+  /// Controls whether this editor has keyboard focus.
   final FocusNode focusNode;
   final ZefyrImageDelegate imageDelegate;
+
+  /// Whether this text field should focus itself if nothing else is already
+  /// focused.
+  ///
+  /// If true, the keyboard will open as soon as this text field obtains focus.
+  /// Otherwise, the keyboard is only shown after the user taps the text field.
+  ///
+  /// Defaults to true. Cannot be null.
   final bool autofocus;
-  final bool enabled;
+
+  /// Editing mode of this text field.
+  final ZefyrMode mode;
+
+  /// Controls physics of scrollable text field.
   final ScrollPhysics physics;
 
+  /// Optional delegate for building the text selection handles and toolbar.
+  ///
+  /// If not provided then platform-specific implementation is used by default.
+  final TextSelectionControls selectionControls;
+
   /// Padding around editable area.
   final EdgeInsets padding;
 
   @override
-  _ZefyrEditableTextState createState() => new _ZefyrEditableTextState();
+  _ZefyrEditableTextState createState() => _ZefyrEditableTextState();
 }
 
 class _ZefyrEditableTextState extends State<ZefyrEditableText>
   }
 
   void focusOrUnfocusIfNeeded() {
-    if (!_didAutoFocus && widget.autofocus && widget.enabled) {
+    if (!_didAutoFocus && widget.autofocus && widget.mode.canEdit) {
       FocusScope.of(context).autofocus(_focusNode);
       _didAutoFocus = true;
     }
-    if (!widget.enabled && _focusNode.hasFocus) {
+    if (!widget.mode.canEdit && _focusNode.hasFocus) {
       _didAutoFocus = false;
       _focusNode.unfocus();
     }
   }
 
+  TextSelectionControls defaultSelectionControls(BuildContext context) {
+    TargetPlatform platform = Theme.of(context).platform;
+    if (platform == TargetPlatform.iOS) {
+      return cupertinoTextSelectionControls;
+    }
+    return materialTextSelectionControls;
+  }
+
   //
   // Overridden members of State
   //
 
     Widget body = ListBody(children: _buildChildren(context));
     if (widget.padding != null) {
-      body = new Padding(padding: widget.padding, child: body);
+      body = Padding(padding: widget.padding, child: body);
     }
-    final scrollable = SingleChildScrollView(
+
+    body = SingleChildScrollView(
       physics: widget.physics,
       controller: _scrollController,
       child: body,
     );
 
-    final overlay = Overlay.of(context, debugRequiredFor: widget);
-    final layers = <Widget>[scrollable];
-    if (widget.enabled) {
-      layers.add(ZefyrSelectionOverlay(
-        controller: widget.controller,
-        controls: cupertinoTextSelectionControls,
-        overlay: overlay,
-      ));
-    }
+    final layers = <Widget>[body];
+    layers.add(ZefyrSelectionOverlay(
+      controls: widget.selectionControls ?? defaultSelectionControls(context),
+    ));
 
     return Stack(fit: StackFit.expand, children: layers);
   }
     _focusNode = widget.focusNode;
     super.initState();
     _focusAttachment = _focusNode.attach(context);
-    _input = new InputConnectionController(_handleRemoteValueChange);
+    _input = InputConnectionController(_handleRemoteValueChange);
     _updateSubscriptions();
   }
 
   Widget _defaultChildBuilder(BuildContext context, Node node) {
     if (node is LineNode) {
       if (node.hasEmbed) {
-        return new RawZefyrLine(node: node);
+        return RawZefyrLine(node: node);
       } else if (node.style.contains(NotusAttribute.heading)) {
-        return new ZefyrHeading(node: node);
+        return ZefyrHeading(node: node);
       }
-      return new ZefyrParagraph(node: node);
+      return ZefyrParagraph(node: node);
     }
 
     final BlockNode block = node;
     final blockStyle = block.style.get(NotusAttribute.block);
     if (blockStyle == NotusAttribute.block.code) {
-      return new ZefyrCode(node: block);
+      return ZefyrCode(node: block);
     } else if (blockStyle == NotusAttribute.block.bulletList) {
-      return new ZefyrList(node: block);
+      return ZefyrList(node: block);
     } else if (blockStyle == NotusAttribute.block.numberList) {
-      return new ZefyrList(node: block);
+      return ZefyrList(node: block);
     } else if (blockStyle == NotusAttribute.block.quote) {
-      return new ZefyrQuote(node: block);
+      return ZefyrQuote(node: block);
     }
 
-    throw new UnimplementedError('Block format $blockStyle.');
+    throw UnimplementedError('Block format $blockStyle.');
   }
 
   void _updateSubscriptions([ZefyrEditableText oldWidget]) {
 
   // Triggered for both text and selection changes.
   void _handleLocalValueChange() {
-    if (widget.enabled &&
+    if (widget.mode.canEdit &&
         widget.controller.lastChangeSource == ChangeSource.local) {
       // Only request keyboard for user actions.
       requestKeyboard();

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

 // Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
 import 'package:flutter/widgets.dart';
 
 import 'controller.dart';
 import 'editable_text.dart';
 import 'image.dart';
+import 'mode.dart';
 import 'scaffold.dart';
 import 'scope.dart';
 import 'theme.dart';
     @required this.controller,
     @required this.focusNode,
     this.autofocus: true,
-    this.enabled: true,
+    this.mode: ZefyrMode.edit,
     this.padding: const EdgeInsets.symmetric(horizontal: 16.0),
     this.toolbarDelegate,
     this.imageDelegate,
+    this.selectionControls,
     this.physics,
-  }) : super(key: key);
+  })  : assert(mode != null),
+        assert(controller != null),
+        assert(focusNode != null),
+        super(key: key);
 
+  /// Controls the document being edited.
   final ZefyrController controller;
+
+  /// Controls whether this editor has keyboard focus.
   final FocusNode focusNode;
+
+  /// Whether this editor should focus itself if nothing else is already
+  /// focused.
+  ///
+  /// If true, the keyboard will open as soon as this text field obtains focus.
+  /// Otherwise, the keyboard is only shown after the user taps the text field.
+  ///
+  /// Defaults to true. Cannot be null.
   final bool autofocus;
-  final bool enabled;
+
+  /// Editing mode of this editor.
+  final ZefyrMode mode;
+
+  /// Optional delegate for customizing this editor's toolbar.
   final ZefyrToolbarDelegate toolbarDelegate;
+
+  /// Delegate for resolving embedded images.
+  ///
+  /// This delegate is required if embedding images is allowed.
   final ZefyrImageDelegate imageDelegate;
+
+  /// Optional delegate for building the text selection handles and toolbar.
+  ///
+  /// If not provided then platform-specific implementation is used by default.
+  final TextSelectionControls selectionControls;
+
+  /// Controls physics of scrollable editor.
   final ScrollPhysics physics;
 
   /// Padding around editable area.
   final EdgeInsets padding;
 
   @override
-  _ZefyrEditorState createState() => new _ZefyrEditorState();
+  _ZefyrEditorState createState() => _ZefyrEditorState();
 }
 
 class _ZefyrEditorState extends State<ZefyrEditor> {
   @override
   void initState() {
     super.initState();
-    _imageDelegate = widget.imageDelegate ?? new ZefyrDefaultImageDelegate();
+    _imageDelegate = widget.imageDelegate;
   }
 
   @override
   void didUpdateWidget(ZefyrEditor oldWidget) {
     super.didUpdateWidget(oldWidget);
+    _scope.mode = widget.mode;
     _scope.controller = widget.controller;
     _scope.focusNode = widget.focusNode;
     if (widget.imageDelegate != oldWidget.imageDelegate) {
-      _imageDelegate = widget.imageDelegate ?? new ZefyrDefaultImageDelegate();
+      _imageDelegate = widget.imageDelegate;
       _scope.imageDelegate = _imageDelegate;
     }
   }
 
     if (_scope == null) {
       _scope = ZefyrScope.editable(
+        mode: widget.mode,
         imageDelegate: _imageDelegate,
         controller: widget.controller,
         focusNode: widget.focusNode,
 
   @override
   Widget build(BuildContext context) {
-    Widget editable = new ZefyrEditableText(
+    Widget editable = ZefyrEditableText(
       controller: _scope.controller,
       focusNode: _scope.focusNode,
       imageDelegate: _scope.imageDelegate,
+      selectionControls: widget.selectionControls,
       autofocus: widget.autofocus,
-      enabled: widget.enabled,
+      mode: widget.mode,
       padding: widget.padding,
       physics: widget.physics,
     );

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

 import 'controller.dart';
 import 'editor.dart';
 import 'image.dart';
+import 'mode.dart';
 import 'toolbar.dart';
 
 /// Zefyr editor with material design decorations.
   final ZefyrController controller;
   final FocusNode focusNode;
   final bool autofocus;
-  final bool enabled;
+  final ZefyrMode mode;
   final ZefyrToolbarDelegate toolbarDelegate;
   final ZefyrImageDelegate imageDelegate;
   final ScrollPhysics physics;
     this.controller,
     this.focusNode,
     this.autofocus: false,
-    this.enabled,
+    this.mode,
     this.toolbarDelegate,
     this.imageDelegate,
     this.physics,
       controller: widget.controller,
       focusNode: widget.focusNode,
       autofocus: widget.autofocus,
-      enabled: widget.enabled ?? true,
+      mode: widget.mode ?? ZefyrMode.edit,
       toolbarDelegate: widget.toolbarDelegate,
       imageDelegate: widget.imageDelegate,
       physics: widget.physics,
         (widget.decoration ?? const InputDecoration())
             .applyDefaults(Theme.of(context).inputDecorationTheme)
             .copyWith(
-              enabled: widget.enabled ?? true,
+              enabled: widget.mode == ZefyrMode.edit,
             );
 
     return effectiveDecoration;

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

 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 import 'dart:async';
-import 'dart:io';
 import 'dart:math' as math;
 import 'dart:ui' as ui;
 
 import 'package:flutter/rendering.dart';
 import 'package:flutter/widgets.dart';
+import 'package:meta/meta.dart';
 import 'package:notus/notus.dart';
-import 'package:image_picker/image_picker.dart';
 
 import 'editable_box.dart';
 
+/// Provides interface for embedding images into Zefyr editor.
+// TODO: allow configuring image sources and related toolbar buttons.
+@experimental
 abstract class ZefyrImageDelegate<S> {
-  /// Builds image widget for specified [imageSource] and [context].
-  Widget buildImage(BuildContext context, String imageSource);
+  /// Unique key to identify camera source.
+  S get cameraSource;
+
+  /// Unique key to identify gallery source.
+  S get gallerySource;
+
+  /// Builds image widget for specified image [key].
+  ///
+  /// The [key] argument contains value which was previously returned from
+  /// [pickImage] method.
+  Widget buildImage(BuildContext context, String key);
 
   /// Picks an image from specified [source].
   ///
   /// Returns unique string key for the selected image. Returned key is stored
   /// in the document.
+  ///
+  /// Depending on your application returned key may represent a path to
+  /// an image file on user's device, an HTTP link, or an identifier generated
+  /// by a file hosting service like AWS S3 or Google Drive.
   Future<String> pickImage(S source);
 }
 
-class ZefyrDefaultImageDelegate implements ZefyrImageDelegate<ImageSource> {
-  @override
-  Widget buildImage(BuildContext context, String imageSource) {
-    final file = new File.fromUri(Uri.parse(imageSource));
-    final image = new FileImage(file);
-    return new Image(image: image);
-  }
-
-  @override
-  Future<String> pickImage(ImageSource source) async {
-    final file = await ImagePicker.pickImage(source: source);
-    if (file == null) return null;
-    return file.uri.toString();
-  }
-}
-
 class ZefyrImage extends StatefulWidget {
   const ZefyrImage({Key key, @required this.node, @required this.delegate})
       : super(key: key);
 
   @override
   RenderEditableImage createRenderObject(BuildContext context) {
-    return new RenderEditableImage(node: node);
+    return RenderEditableImage(node: node);
   }
 
   @override
     if (local.isCollapsed) {
       final dx = local.extentOffset == 0 ? _childOffset.dx : size.width;
       return [
-        new ui.TextBox.fromLTRBD(
+        ui.TextBox.fromLTRBD(
             dx, 0.0, dx, size.height - kPaddingBottom, TextDirection.ltr),
       ];
     }
 
     final rect = _childRect;
     return [
-      new ui.TextBox.fromLTRBD(
+      ui.TextBox.fromLTRBD(
           rect.left, rect.top, rect.left, rect.bottom, TextDirection.ltr),
-      new ui.TextBox.fromLTRBD(
+      ui.TextBox.fromLTRBD(
           rect.right, rect.top, rect.right, rect.bottom, TextDirection.ltr),
     ];
   }
     if (offset.dx > size.width / 2) {
       position++;
     }
-    return new TextPosition(offset: position);
+    return TextPosition(offset: position);
   }
 
   @override
   TextRange getWordBoundary(TextPosition position) {
     final start = _node.documentOffset;
-    return new TextRange(start: start, end: start + 1);
+    return TextRange(start: start, end: start + 1);
   }
 
   @override
   @override
   Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
     final pos = position.offset - node.documentOffset;
-    Offset caretOffset = _childOffset - new Offset(kHorizontalPadding, 0.0);
+    Offset caretOffset = _childOffset - Offset(kHorizontalPadding, 0.0);
     if (pos == 1) {
-      caretOffset = caretOffset +
-          new Offset(_lastChildSize.width + kHorizontalPadding, 0.0);
+      caretOffset =
+          caretOffset + Offset(_lastChildSize.width + kHorizontalPadding, 0.0);
     }
     return caretOffset;
   }
     final localSelection = getLocalSelection(selection);
     assert(localSelection != null);
     if (!localSelection.isCollapsed) {
-      final Paint paint = new Paint()
+      final Paint paint = Paint()
         ..color = selectionColor
         ..style = PaintingStyle.stroke
         ..strokeWidth = 3.0;
-      final rect = new Rect.fromLTWH(
-          0.0, 0.0, _lastChildSize.width, _lastChildSize.height);
+      final rect =
+          Rect.fromLTWH(0.0, 0.0, _lastChildSize.width, _lastChildSize.height);
       context.canvas.drawRect(rect.shift(offset + _childOffset), paint);
     }
   }
   Offset get _childOffset {
     final dx = (size.width - _lastChildSize.width) / 2 + kHorizontalPadding;
     final dy = (size.height - _lastChildSize.height - kPaddingBottom) / 2;
-    return new Offset(dx, dy);
+    return Offset(dx, dy);
   }
 
   Rect get _childRect {
-    return new Rect.fromLTWH(_childOffset.dx, _childOffset.dy,
-        _lastChildSize.width, _lastChildSize.height);
+    return Rect.fromLTWH(_childOffset.dx, _childOffset.dy, _lastChildSize.width,
+        _lastChildSize.height);
   }
 
   @override
       );
       child.layout(childConstraints, parentUsesSize: true);
       _lastChildSize = child.size;
-      size = new Size(
-          constraints.maxWidth, _lastChildSize.height + kPaddingBottom);
+      size = Size(constraints.maxWidth, _lastChildSize.height + kPaddingBottom);
     } else {
       performResize();
     }

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

       _lastKnownRemoteTextEditingValue = value;
       _textInputConnection = TextInput.attach(
         this,
-        new TextInputConfiguration(
+        TextInputConfiguration(
           inputType: TextInputType.multiline,
           obscureText: false,
           autocorrect: true,

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

         : theme.blockTheme.bulletList.padding;
     padding = padding.copyWith(left: theme.indentSize);
 
-    return new Padding(
+    return Padding(
       padding: padding,
-      child: new Column(children: items),
+      child: Column(children: items),
     );
   }
 
   Widget _buildItem(Node node, int index) {
     LineNode line = node;
-    return new ZefyrListItem(index: index, node: line);
+    return ZefyrListItem(index: index, node: line);
   }
 }
 
       final headingTheme = ZefyrHeading.themeOf(node, context);
       textStyle = headingTheme.textStyle;
       padding = headingTheme.padding;
-      content = new ZefyrHeading(node: node);
+      content = ZefyrHeading(node: node);
     } else {
       textStyle = theme.paragraphTheme.textStyle;
-      content = new RawZefyrLine(node: node, style: textStyle);
+      content = RawZefyrLine(node: node, style: textStyle);
     }
 
     Widget bullet =

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

+import 'package:meta/meta.dart';
+import 'package:quiver_hashcode/hashcode.dart';
+
+/// Controls level of interactions allowed by Zefyr editor.
+///
+// TODO: consider extending with following:
+//       - linkTapBehavior: none|launch
+//       - allowedStyles: ['bold', 'italic', 'image', ... ]
+class ZefyrMode {
+  /// Editing mode provides full access to all editing features: keyboard,
+  /// editor toolbar with formatting tools, selection controls and selection
+  /// toolbar with clipboard tools.
+  ///
+  /// Tapping on links in edit mode shows selection toolbar with contextual
+  /// actions instead of launching the link in a web browser.
+  static const edit =
+      ZefyrMode(canEdit: true, canSelect: true, canFormat: true);
+
+  /// Select-only mode allows users to select a range of text and have access
+  /// to selection toolbar including clipboard tools, any custom actions
+  /// registered by current text selection controls implementation.
+  ///
+  /// Tapping on links in select-only mode launches the link in a web browser.
+  static const select =
+      ZefyrMode(canEdit: false, canSelect: true, canFormat: true);
+
+  /// View-only mode disables almost all user interactions except the ability
+  /// to launch links in a web browser when tapped.
+  static const view =
+      ZefyrMode(canEdit: false, canSelect: false, canFormat: false);
+
+  /// Returns `true` if user is allowed to change text in a document.
+  final bool canEdit;
+
+  /// Returns `true` if user is allowed to select a range of text in a document.
+  final bool canSelect;
+
+  /// Returns `true` if user is allowed to change formatting styles in a
+  /// document.
+  final bool canFormat;
+
+  /// Creates new mode which describes allowed interactions in Zefyr editor.
+  const ZefyrMode({
+    @required this.canEdit,
+    @required this.canSelect,
+    @required this.canFormat,
+  });
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is! ZefyrMode) return false;
+    final ZefyrMode that = other;
+    return canEdit == that.canEdit &&
+        canSelect == that.canSelect &&
+        canFormat == that.canFormat;
+  }
+
+  @override
+  int get hashCode => hash3(canEdit, canSelect, canFormat);
+}

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

     if (blockStyle != null) {
       style = style.merge(blockStyle);
     }
-    return new RawZefyrLine(
+    return RawZefyrLine(
       node: node,
       style: style,
       padding: theme.paragraphTheme.padding,
     if (blockStyle != null) {
       style = style.merge(blockStyle);
     }
-    return new RawZefyrLine(
+    return RawZefyrLine(
       node: node,
       style: style,
       padding: theme.padding,
     } else if (style == NotusAttribute.heading.level3) {
       return theme.headingTheme.level3;
     }
-    throw new UnimplementedError('Unsupported heading style $style');
+    throw UnimplementedError('Unsupported heading style $style');
   }
 }

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

 
   @override
   RenderObject createRenderObject(BuildContext context) {
-    return new RenderZefyrParagraph(
+    return RenderZefyrParagraph(
       text,
       node: node,
       textDirection: Directionality.of(context),
     double textScaleFactor: 1.0,
     int maxLines,
   })  : _node = node,
-        _prototypePainter = new TextPainter(
-          text: new TextSpan(text: '.', style: text.style),
+        _prototypePainter = TextPainter(
+          text: TextSpan(text: '.', style: text.style),
           textAlign: textAlign,
           textDirection: textDirection,
           textScaleFactor: textScaleFactor,
   @override
   TextPosition getPositionForOffset(Offset offset) {
     final position = super.getPositionForOffset(offset);
-    return new TextPosition(
+    return TextPosition(
       offset: _node.documentOffset + position.offset,
       affinity: position.affinity,
     );
 
   @override
   TextRange getWordBoundary(TextPosition position) {
-    final localPosition = new TextPosition(
+    final localPosition = TextPosition(
       offset: position.offset - _node.documentOffset,
       affinity: position.affinity,
     );
     final localRange = super.getWordBoundary(localPosition);
-    return new TextRange(
+    return TextRange(
       start: _node.documentOffset + localRange.start,
       end: _node.documentOffset + localRange.end,
     );
 
   @override
   Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
-    final localPosition = new TextPosition(
+    final localPosition = TextPosition(
       offset: position.offset - _node.documentOffset,
       affinity: position.affinity,
     );
       final caret = CursorPainter.buildPrototype(preferredLineHeight);
       final offset = getOffsetForCaret(local.extent, caret);
       return [
-        new ui.TextBox.fromLTRBD(
+        ui.TextBox.fromLTRBD(
           offset.dx,
           offset.dy,
           offset.dx,
       final box = result.first;
       final dx = isBaseShifted == -1 ? box.right : box.left;
       result.removeAt(0);
-      result.insert(0,
-          new ui.TextBox.fromLTRBD(dx, box.top, dx, box.bottom, box.direction));
+      result.insert(
+          0, ui.TextBox.fromLTRBD(dx, box.top, dx, box.bottom, box.direction));
     }
     if (isExtentShifted) {
       final box = result.last;
       result.removeLast;
-      result.add(new ui.TextBox.fromLTRBD(
+      result.add(ui.TextBox.fromLTRBD(
           box.left, box.top, box.left, box.bottom, box.direction));
     }
     return result;
 
   @override
   void set text(InlineSpan value) {
-    _prototypePainter.text = new TextSpan(text: '.', style: value.style);
+    _prototypePainter.text = TextSpan(text: '.', style: value.style);
     _selectionRects = null;
     super.text = value;
   }

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

 import 'package:flutter/material.dart';
 
+import 'editor.dart';
+
+/// Provides necessary layout for [ZefyrEditor].
 class ZefyrScaffold extends StatefulWidget {
   final Widget child;
 

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

 import 'cursor_timer.dart';
 import 'editor.dart';
 import 'image.dart';
+import 'mode.dart';
 import 'render_context.dart';
 import 'view.dart';
 
   /// Creates a view-only scope.
   ///
   /// Normally used in [ZefyrView].
-  ZefyrScope.view({@required ZefyrImageDelegate imageDelegate})
-      : assert(imageDelegate != null),
-        isEditable = false,
+  ZefyrScope.view({ZefyrImageDelegate imageDelegate})
+      : isEditable = false,
+        _mode = ZefyrMode.view,
         _imageDelegate = imageDelegate;
 
   /// Creates editable scope.
   ///
   /// Normally used in [ZefyrEditor].
   ZefyrScope.editable({
+    @required ZefyrMode mode,
     @required ZefyrController controller,
-    @required ZefyrImageDelegate imageDelegate,
     @required FocusNode focusNode,
     @required FocusScopeNode focusScope,
-  })  : assert(controller != null),
-        assert(imageDelegate != null),
+    ZefyrImageDelegate imageDelegate,
+  })  : assert(mode != null),
+        assert(controller != null),
         assert(focusNode != null),
         assert(focusScope != null),
         isEditable = true,
+        _mode = mode,
         _controller = controller,
         _imageDelegate = imageDelegate,
         _focusNode = focusNode,
   ZefyrImageDelegate _imageDelegate;
   ZefyrImageDelegate get imageDelegate => _imageDelegate;
   set imageDelegate(ZefyrImageDelegate value) {
-    assert(value != null);
     if (_imageDelegate != value) {
       _imageDelegate = value;
       notifyListeners();
     }
   }
 
+  ZefyrMode _mode;
+  ZefyrMode get mode => _mode;
+  set mode(ZefyrMode value) {
+    assert(value != null);
+    if (_mode != value) {
+      _mode = value;
+      notifyListeners();
+    }
+  }
+
   ZefyrController _controller;
   ZefyrController get controller => _controller;
   set controller(ZefyrController value) {

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

 
 /// Selection overlay controls selection handles and other gestures.
 class ZefyrSelectionOverlay extends StatefulWidget {
-  const ZefyrSelectionOverlay({
-    Key key,
-    @required this.controller,
-    @required this.controls,
-    @required this.overlay,
-  }) : super(key: key);
+  const ZefyrSelectionOverlay({Key key, @required this.controls})
+      : super(key: key);
 
-  final ZefyrController controller;
   final TextSelectionControls controls;
-  final OverlayState overlay;
 
   @override
-  _ZefyrSelectionOverlayState createState() =>
-      new _ZefyrSelectionOverlayState();
+  _ZefyrSelectionOverlayState createState() => _ZefyrSelectionOverlayState();
 }
 
 class _ZefyrSelectionOverlayState extends State<ZefyrSelectionOverlay>
     implements TextSelectionDelegate {
+  TextSelectionControls _controls;
+  TextSelectionControls get controls => _controls;
+
+  /// Global position of last TapDown event.
+  Offset _lastTapDownPosition;
+
+  /// Global position of last TapDown which is potentially a long press.
+  Offset _longPressPosition;
+
+  OverlayState _overlay;
+  OverlayEntry _toolbar;
+  AnimationController _toolbarController;
+
+  ZefyrScope _scope;
+  ZefyrScope get scope => _scope;
+  TextSelection _selection;
+  FocusOwner _focusOwner;
+
+  bool _didCaretTap = false;
+
+  /// Whether selection controls should be hidden.
+  bool get shouldHideControls {
+    if (!_scope.mode.canSelect) return true;
+    final selection = _scope.selection;
+    final isSelectionCollapsed = selection == null || selection.isCollapsed;
+    if (_scope.mode.canEdit) {
+      return isSelectionCollapsed || _scope.focusOwner != FocusOwner.editor;
+    }
+    return isSelectionCollapsed;
+  }
+
+  void showToolbar() {
+    final toolbarOpacity = _toolbarController.view;
+    _toolbar = OverlayEntry(
+      builder: (context) => FadeTransition(
+        opacity: toolbarOpacity,
+        child: _SelectionToolbar(selectionOverlay: this),
+      ),
+    );
+    _overlay.insert(_toolbar);
+    _toolbarController.forward(from: 0.0);
+  }
+
+  bool get isToolbarVisible => _toolbar != null;
+  bool get isToolbarHidden => _toolbar == null;
+
   @override
   TextEditingValue get textEditingValue =>
-      widget.controller.plainTextEditingValue;
+      _scope.controller.plainTextEditingValue;
 
   set textEditingValue(TextEditingValue value) {
     final cursorPosition = value.selection.extentOffset;
-    final oldText = widget.controller.document.toPlainText();
+    final oldText = _scope.controller.document.toPlainText();
     final newText = value.text;
     final diff = fastDiff(oldText, newText, cursorPosition);
-    widget.controller.replaceText(
+    _scope.controller.replaceText(
         diff.start, diff.deleted.length, diff.inserted,
         selection: value.selection);
   }
     // TODO: implement bringIntoView
   }
 
-  bool get isToolbarVisible => _toolbar != null;
-  bool get isToolbarHidden => _toolbar == null;
-
   @override
   void hideToolbar() {
     _didCaretTap = false; // reset double tap.
     _toolbar?.remove();
     _toolbar = null;
-    _toolbarController.stop();
+    _toolbarController?.stop();
   }
 
-  void showToolbar() {
-    final toolbarOpacity = _toolbarController.view;
-    _toolbar = new OverlayEntry(
-      builder: (context) => new FadeTransition(
-        opacity: toolbarOpacity,
-        child: new _SelectionToolbar(
-          scope: _editor,
-          controls: widget.controls,
-          delegate: this,
-        ),
-      ),
-    );
-    widget.overlay.insert(_toolbar);
-    _toolbarController.forward(from: 0.0);
-  }
-
-  //
-  // Overridden members of State
-  //
+  static const Duration _kFadeDuration = const Duration(milliseconds: 150);
 
   @override
   void initState() {
     super.initState();
-    _toolbarController = new AnimationController(
-        duration: _kFadeDuration, vsync: widget.overlay);
+    _controls = widget.controls;
   }
 
-  static const Duration _kFadeDuration = const Duration(milliseconds: 150);
-
   @override
   void didUpdateWidget(ZefyrSelectionOverlay oldWidget) {
     super.didUpdateWidget(oldWidget);
-    if (oldWidget.overlay != widget.overlay) {
-      hideToolbar();
-      _toolbarController.dispose();
-      _toolbarController = new AnimationController(
-          duration: _kFadeDuration, vsync: widget.overlay);
-    }
+    _controls = widget.controls;
   }
 
   @override
   void didChangeDependencies() {
     super.didChangeDependencies();
-    final editor = ZefyrScope.of(context);
-    if (_editor != editor) {
-      _editor?.removeListener(_handleChange);
-      _editor = editor;
-      _editor.addListener(_handleChange);
-      _selection = _editor.selection;
-      _focusOwner = _editor.focusOwner;
+    final scope = ZefyrScope.of(context);
+    if (_scope != scope) {
+      _scope?.removeListener(_handleChange);
+      _scope = scope;
+      _scope.addListener(_handleChange);
+      _selection = _scope.selection;
+      _focusOwner = _scope.focusOwner;
+    }
+
+    final overlay = Overlay.of(context, debugRequiredFor: widget);
+    if (_overlay != overlay) {
+      hideToolbar();
+      _overlay = overlay;
+      _toolbarController?.dispose();
+      _toolbarController = null;
+    }
+    if (_toolbarController == null) {
+      _toolbarController = AnimationController(
+        duration: _kFadeDuration,
+        vsync: _overlay,
+      );
     }
+
+    _toolbar?.markNeedsBuild();
   }
 
   @override
   void dispose() {
-    _editor.removeListener(_handleChange);
+    _scope.removeListener(_handleChange);
     hideToolbar();
     _toolbarController.dispose();
     _toolbarController = null;
 
   @override
   Widget build(BuildContext context) {
-    final overlay = new GestureDetector(
+    final overlay = GestureDetector(
       behavior: HitTestBehavior.translucent,
       onTapDown: _handleTapDown,
       onTap: _handleTap,
       onTapCancel: _handleTapCancel,
       onLongPress: _handleLongPress,
-      child: new Stack(
+      child: Stack(
         fit: StackFit.expand,
         children: <Widget>[
-          new SelectionHandleDriver(
+          SelectionHandleDriver(
             position: _SelectionHandlePosition.base,
-            controls: widget.controls,
+            selectionOverlay: this,
           ),
-          new SelectionHandleDriver(
+          SelectionHandleDriver(
             position: _SelectionHandlePosition.extent,
-            controls: widget.controls,
+            selectionOverlay: this,
           ),
         ],
       ),
     );
-    return new Container(child: overlay);
+    return Container(child: overlay);
   }
 
   //
   // Private members
   //
 
-  /// Global position of last TapDown event.
-  Offset _lastTapDownPosition;
-
-  /// Global position of last TapDown which is potentially a long press.
-  Offset _longPressPosition;
-
-  OverlayEntry _toolbar;
-  AnimationController _toolbarController;
-
-  ZefyrScope _editor;
-  TextSelection _selection;
-  FocusOwner _focusOwner;
-
-  bool _didCaretTap = false;
-
   void _handleChange() {
-    if (_selection != _editor.selection || _focusOwner != _editor.focusOwner) {
+    if (_selection != _scope.selection || _focusOwner != _scope.focusOwner) {
       _updateToolbar();
     }
   }
       return;
     }
 
-    final selection = _editor.selection;
-    final focusOwner = _editor.focusOwner;
+    final selection = _scope.selection;
+    final focusOwner = _scope.focusOwner;
     setState(() {
-      if (focusOwner != FocusOwner.editor) {
+      if (shouldHideControls && isToolbarVisible) {
         hideToolbar();
       } else {
         if (_selection != selection) {
-          if (selection.isCollapsed && isToolbarVisible) hideToolbar();
+          if (selection.isCollapsed && isToolbarVisible) {
+            hideToolbar();
+          }
           _toolbar?.markNeedsBuild();
           if (!selection.isCollapsed && isToolbarHidden) showToolbar();
         } else {
     assert(_lastTapDownPosition != null);
     final globalPoint = _lastTapDownPosition;
     _lastTapDownPosition = null;
-    HitTestResult result = new HitTestResult();
+    HitTestResult result = HitTestResult();
     WidgetsBinding.instance.hitTest(result, globalPoint);
 
     RenderEditableProxyBox box = _getEditableBox(result);
     if (box == null) {
-      box = _editor.renderContext.closestBoxForGlobalPoint(globalPoint);
+      box = _scope.renderContext.closestBoxForGlobalPoint(globalPoint);
     }
     if (box == null) return null;
 
     final localPoint = box.globalToLocal(globalPoint);
     final position = box.getPositionForOffset(localPoint);
-    final selection = new TextSelection.collapsed(
+    final selection = TextSelection.collapsed(
       offset: position.offset,
       affinity: position.affinity,
     );
     } else {
       _didCaretTap = true;
     }
-    widget.controller.updateSelection(selection, source: ChangeSource.local);
+    _scope.controller.updateSelection(selection, source: ChangeSource.local);
   }
 
   void _handleLongPress() {
     final Offset globalPoint = _longPressPosition;
     _longPressPosition = null;
-    HitTestResult result = new HitTestResult();
+    HitTestResult result = HitTestResult();
     WidgetsBinding.instance.hitTest(result, globalPoint);
     final box = _getEditableBox(result);
     if (box == null) {
     final localPoint = box.globalToLocal(globalPoint);
     final position = box.getPositionForOffset(localPoint);
     final word = box.getWordBoundary(position);
-    final selection = new TextSelection(
+    final selection = TextSelection(
       baseOffset: word.start,
       extentOffset: word.end,
     );
-    widget.controller.updateSelection(selection, source: ChangeSource.local);
+    _scope.controller.updateSelection(selection, source: ChangeSource.local);
   }
 
-  // TODO: these methods should also take into account enabled state.
   @override
-  bool get copyEnabled => _editor.isEditable;
+  bool get copyEnabled => _scope.mode.canSelect && !_selection.isCollapsed;
 
   @override
-  bool get cutEnabled => _editor.isEditable;
+  bool get cutEnabled => _scope.mode.canEdit && !_selection.isCollapsed;
 
   @override
-  bool get pasteEnabled => _editor.isEditable;
+  bool get pasteEnabled => _scope.mode.canEdit;
 
   @override
-  bool get selectAllEnabled => _editor.isEditable;
+  bool get selectAllEnabled => _scope.mode.canSelect;
 }
 
 enum _SelectionHandlePosition { base, extent }
   const SelectionHandleDriver({
     Key key,
     @required this.position,
-    @required this.controls,
-  }) : super(key: key);
+    @required this.selectionOverlay,
+  })  : assert(selectionOverlay != null),
+        super(key: key);
 
   final _SelectionHandlePosition position;
-  final TextSelectionControls controls;
+  final _ZefyrSelectionOverlayState selectionOverlay;
 
   @override
-  _SelectionHandleDriverState createState() =>
-      new _SelectionHandleDriverState();
+  _SelectionHandleDriverState createState() => _SelectionHandleDriverState();
 }
 
 class _SelectionHandleDriverState extends State<SelectionHandleDriver>
 
   @override
   Widget build(BuildContext context) {
-    if (selection == null ||
-        selection.isCollapsed ||
-        widget.controls == null ||
-        _scope.focusOwner != FocusOwner.editor) {
-      return new Container();
+    if (widget.selectionOverlay.shouldHideControls) {
+      return Container();
     }
     final block = _scope.renderContext.boxForTextOffset(documentOffset);
     if (block == null) {
       point.dy.clamp(0.0, viewport.height),
     );
 
-    final Offset handleAnchor = widget.controls.getHandleAnchor(
+    final Offset handleAnchor =
+        widget.selectionOverlay.controls.getHandleAnchor(
       type,
       block.preferredLineHeight,
     );
-    final Size handleSize = widget.controls.getHandleSize(
+    final Size handleSize = widget.selectionOverlay.controls.getHandleSize(
       block.preferredLineHeight,
     );
     final Rect handleRect = Rect.fromLTWH(
               right: padding.right,
               bottom: padding.bottom,
             ),
-            child: widget.controls.buildHandle(
+            child: widget.selectionOverlay.controls.buildHandle(
               context,
               type,
               block.preferredLineHeight,
 class _SelectionToolbar extends StatefulWidget {
   const _SelectionToolbar({
     Key key,
-    @required this.scope,
-    @required this.controls,
-    @required this.delegate,
+    @required this.selectionOverlay,
   }) : super(key: key);
 
-  final ZefyrScope scope;
-  final TextSelectionControls controls;
-  final TextSelectionDelegate delegate;
+  final _ZefyrSelectionOverlayState selectionOverlay;
 
   @override
-  _SelectionToolbarState createState() => new _SelectionToolbarState();
+  _SelectionToolbarState createState() => _SelectionToolbarState();
 }
 
 class _SelectionToolbarState extends State<_SelectionToolbar> {
-  ZefyrScope get editable => widget.scope;
-  TextSelection get selection => widget.delegate.textEditingValue.selection;
+  TextSelectionControls get controls => widget.selectionOverlay.controls;
+  ZefyrScope get scope => widget.selectionOverlay.scope;
+  TextSelection get selection =>
+      widget.selectionOverlay.textEditingValue.selection;
 
   @override
   Widget build(BuildContext context) {
 
   Widget _buildToolbar(BuildContext context) {
     final base = selection.baseOffset;
-    // TODO: Editable is not refreshed and may contain stale renderContext instance.
-    final block = editable.renderContext.boxForTextOffset(base);
+    final block = scope.renderContext.boxForTextOffset(base);
     if (block == null) {
       return Container();
     }
     final boxes = block.getEndpointsForSelection(selection);
     // Find the horizontal midpoint, just above the selected text.
-    Offset midpoint = new Offset(
+    Offset midpoint = Offset(
       (boxes.length == 1)
           ? (boxes[0].start + boxes[0].end) / 2.0
           : (boxes[0].start + boxes[1].start) / 2.0,
       ];
     }
 
-    final Rect editingRegion = new Rect.fromPoints(
+    final Rect editingRegion = Rect.fromPoints(
       block.localToGlobal(Offset.zero),
       block.localToGlobal(block.size.bottomRight(Offset.zero)),
     );
 
-    final toolbar = widget.controls.buildToolbar(context, editingRegion,
-        block.preferredLineHeight, midpoint, endpoints, widget.delegate);
-    return new CompositedTransformFollower(
+    final toolbar = controls.buildToolbar(
+        context,
+        editingRegion,
+        block.preferredLineHeight,
+        midpoint,
+        endpoints,
+        widget.selectionOverlay);
+    return CompositedTransformFollower(
       link: block.layerLink,
       showWhenUnlinked: false,
       offset: -editingRegion.topLeft,

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

     } else if (autoImplyTrailing) {
       children.add(toolbar.buildButton(context, ZefyrToolbarAction.close));
     }
-    return new Container(
+    return Container(
       constraints: constraints,
       child: Material(color: theme.color, child: Row(children: children)),
     );
   ZefyrToolbarState createState() => ZefyrToolbarState();
 
   @override
-  ui.Size get preferredSize => new Size.fromHeight(ZefyrToolbar.kToolbarHeight);
+  ui.Size get preferredSize => Size.fromHeight(ZefyrToolbar.kToolbarHeight);
 }
 
 class _ZefyrToolbarScope extends InheritedWidget {
 
   Future<void> showOverlay(WidgetBuilder builder) async {
     assert(_overlayBuilder == null);
-    final completer = new Completer<void>();
+    final completer = Completer<void>();
     setState(() {
       _overlayBuilder = builder;
       _overlayCompleter = completer;
   @override
   void initState() {
     super.initState();
-    _delegate = widget.delegate ?? new _DefaultZefyrToolbarDelegate();
-    _overlayAnimation = new AnimationController(
-        vsync: this, duration: Duration(milliseconds: 100));
+    _delegate = widget.delegate ?? _DefaultZefyrToolbarDelegate();
+    _overlayAnimation =
+        AnimationController(vsync: this, duration: Duration(milliseconds: 100));
     _selection = editor.selection;
   }
 
   void didUpdateWidget(ZefyrToolbar oldWidget) {
     super.didUpdateWidget(oldWidget);
     if (widget.delegate != oldWidget.delegate) {
-      _delegate = widget.delegate ?? new _DefaultZefyrToolbarDelegate();
+      _delegate = widget.delegate ?? _DefaultZefyrToolbarDelegate();
     }
   }
 
     layers.add(toolbar);
 
     if (hasOverlay) {
-      Widget widget = new Builder(builder: _overlayBuilder);
+      Widget widget = Builder(builder: _overlayBuilder);
       assert(widget != null);
       final overlay = FadeTransition(
         key: _overlayKey,
       buildButton(context, ZefyrToolbarAction.quote),
       buildButton(context, ZefyrToolbarAction.code),
       buildButton(context, ZefyrToolbarAction.horizontalRule),
-      ImageButton(),
+      if (editor.imageDelegate != null) ImageButton(),
     ];
     return buttons;
   }
 }
 
 class _ZefyrButtonListState extends State<ZefyrButtonList> {
-  final ScrollController _controller = new ScrollController();
+  final ScrollController _controller = ScrollController();
   bool _showLeftArrow = false;
   bool _showRightArrow = false;
 

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

+// Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
 import 'package:flutter/material.dart';
 import 'package:meta/meta.dart';
 import 'package:notus/notus.dart';

packages/zefyr/lib/util.dart

 export 'src/fast_diff.dart';
 
 int getPositionDelta(Delta user, Delta actual) {
-  final userIter = new DeltaIterator(user);
-  final actualIter = new DeltaIterator(actual);
+  final userIter = DeltaIterator(user);
+  final actualIter = DeltaIterator(actual);
   int diff = 0;
   while (userIter.hasNext || actualIter.hasNext) {
     num length = math.min(userIter.peekLength(), actualIter.peekLength());
     } else if (userOp.isDelete && actualOp.isRetain) {
       diff += userOp.length;
     } else if (userOp.isRetain && actualOp.isInsert) {
-      if (actualOp.data.startsWith('\n') ) {
+      if (actualOp.data.startsWith('\n')) {
         // At this point user input reached its end (retain). If a heuristic
         // rule inserts a new line we should keep cursor on it's original position.
         continue;

packages/zefyr/lib/zefyr.dart

 export 'src/widgets/horizontal_rule.dart';
 export 'src/widgets/image.dart';
 export 'src/widgets/list.dart';
+export 'src/widgets/mode.dart';
 export 'src/widgets/paragraph.dart';
 export 'src/widgets/quote.dart';
 export 'src/widgets/scaffold.dart';

packages/zefyr/pubspec.yaml

 name: zefyr
 description: Clean, minimalistic and collaboration-ready rich text editor for Flutter.
-version: 0.6.1
+version: 0.7.0
 author: Anatoly Pulyaevskiy <anatoly.pulyaevskiy@gmail.com>
 homepage: https://github.com/memspace/zefyr
 
 environment:
-  sdk: '>=2.1.0 <3.0.0'
+  sdk: '>=2.2.2 <3.0.0'
 
 dependencies:
   flutter:
     sdk: flutter
   collection: ^1.14.6
   url_launcher: ^5.0.0
-  image_picker: '>=0.5.0 <0.7.0'
   quill_delta: ^1.0.0-dev.1.0
   notus: ^0.1.0
   meta: ^1.1.0
+  quiver_hashcode: ^2.0.0
 
 dev_dependencies:
   flutter_test:

packages/zefyr/test/rendering/render_zefyr_paragraph_test.dart

+// Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+import 'dart:ui';
+
+import 'package:flutter/material.dart';
+import 'package:flutter/rendering.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:zefyr/src/widgets/render_context.dart';
+import 'package:zefyr/src/widgets/rich_text.dart';
+import 'package:zefyr/zefyr.dart';
+
+void main() {
+  group('$RenderZefyrParagraph', () {
+    final doc = new NotusDocument();
+    doc.insert(0, 'This House Is A Circus');
+    final text = new TextSpan(text: 'This House Is A Circus');
+
+    ZefyrRenderContext renderContext;
+    RenderZefyrParagraph p;
+
+    setUp(() {
+      WidgetsFlutterBinding.ensureInitialized();
+      renderContext = new ZefyrRenderContext();
+      p = new RenderZefyrParagraph(
+        text,
+        node: doc.root.children.first as LineNode,
+        textDirection: TextDirection.ltr,
+      );
+    });
+
+    test('it registers with viewport', () {
+      var owner = new PipelineOwner();
+      expect(renderContext.active, isNot(contains(p)));
+      p.attach(owner);
+      expect(renderContext.dirty, contains(p));
+      p.layout(new BoxConstraints());
+      expect(renderContext.active, contains(p));
+    }, skip: 'TODO: move to RenderEditableProxyBox');
+  });
+}

packages/zefyr/test/testing.dart

     NotusDocument document,
     ZefyrThemeData theme,
     bool autofocus: false,
+    ZefyrImageDelegate imageDelegate,
   }) {
     focusNode ??= FocusNode();
     document ??= NotusDocument.fromDelta(delta);
       controller: controller,
       focusNode: focusNode,
       autofocus: autofocus,
+      imageDelegate: imageDelegate,
     );
 
     if (theme != null) {
 }
 
 class _ZefyrSandbox extends StatefulWidget {
-  const _ZefyrSandbox(
-      {Key key, this.controller, this.focusNode, this.autofocus})
-      : super(key: key);
+  const _ZefyrSandbox({
+    Key key,
+    this.controller,
+    this.focusNode,
+    this.autofocus,
+    this.imageDelegate,
+  }) : super(key: key);
   final ZefyrController controller;
   final FocusNode focusNode;
   final bool autofocus;
+  final ZefyrImageDelegate imageDelegate;
 
   @override
   _ZefyrSandboxState createState() => _ZefyrSandboxState();
     return new ZefyrEditor(
       controller: widget.controller,
       focusNode: widget.focusNode,
-      enabled: _enabled,
+      mode: _enabled ? ZefyrMode.edit : ZefyrMode.view,
       autofocus: widget.autofocus,
+      imageDelegate: widget.imageDelegate,
     );
   }
 

packages/zefyr/test/widgets/buttons_test.dart

 // Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
+import 'dart:io';
+
 import 'package:flutter/material.dart';
-import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:zefyr/src/widgets/buttons.dart';
 import 'package:zefyr/zefyr.dart';
   });
 
   group('$ImageButton', () {
-    const MethodChannel channel =
-        const MethodChannel('plugins.flutter.io/image_picker');
-
-    final List<MethodCall> log = <MethodCall>[];
-
-    setUp(() {
-      channel.setMockMethodCallHandler((MethodCall methodCall) async {
-        log.add(methodCall);
-        return '/tmp/test.jpg';
-      });
-      log.clear();
-    });
-
     testWidgets('toggle overlay', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
 
     });
 
     testWidgets('pick from camera', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
       await editor.tapButtonWithIcon(Icons.photo_camera);
-      expect(log, hasLength(1));
-      expect(
-        log.single,
-        isMethodCall(
-          'pickImage',
-          arguments: <String, dynamic>{
-            'source': 0,
-            'maxWidth': null,
-            'maxHeight': null,
-            'imageQuality': null,
-          },
-        ),
-      );
+      expect(find.byType(ZefyrImage), findsOneWidget);
     });
 
     testWidgets('pick from gallery', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
       await editor.tapButtonWithIcon(Icons.photo_library);
-      expect(log, hasLength(1));
-      expect(
-        log.single,
-        isMethodCall(
-          'pickImage',
-          arguments: <String, dynamic>{
-            'source': 1,
-            'maxWidth': null,
-            'maxHeight': null,
-            'imageQuality': null,
-          },
-        ),
-      );
+      expect(find.byType(ZefyrImage), findsOneWidget);
     });
   });
 }
+
+class _TestImageDelegate implements ZefyrImageDelegate<String> {
+  @override
+  Widget buildImage(BuildContext context, String key) {
+    return Image.file(File(key));
+  }
+
+  @override
+  String get cameraSource => "camera";
+
+  @override
+  String get gallerySource => "gallery";
+
+  @override
+  Future<String> pickImage(String source) {
+    return Future.value("file:///tmp/test.jpg");
+  }
+}

packages/zefyr/test/widgets/editor_test.dart

       await editor.updateSelection(base: 0, extent: 3);
       await editor.disable();
       ZefyrEditor widget = tester.widget(find.byType(ZefyrEditor));
-      expect(widget.enabled, isFalse);
+      expect(widget.mode, ZefyrMode.view);
     });
   });
 }

packages/zefyr/test/widgets/image_test.dart

 // Copyright (c) 2018, the Zefyr project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
+import 'dart:io';
+
 import 'package:flutter/material.dart';
-import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:image_picker/image_picker.dart';
 import 'package:zefyr/zefyr.dart';
 
 import '../testing.dart';
 
 void main() {
-  group('$ZefyrDefaultImageDelegate', () {
-    const MethodChannel channel =
-        const MethodChannel('plugins.flutter.io/image_picker');
-
-    final List<MethodCall> log = <MethodCall>[];
-
-    setUp(() {
-      channel.setMockMethodCallHandler((MethodCall methodCall) async {
-        log.add(methodCall);
-        return '/tmp/test.jpg';
-      });
-      log.clear();
-    });
-
-    test('pick image', () async {
-      final delegate = new ZefyrDefaultImageDelegate();
-      final result = await delegate.pickImage(ImageSource.gallery);
-      expect(result, 'file:///tmp/test.jpg');
-    });
-  });
-
   group('$ZefyrImage', () {
-    const MethodChannel channel =
-        const MethodChannel('plugins.flutter.io/image_picker');
-
-    final List<MethodCall> log = <MethodCall>[];
-
-    setUp(() {
-      channel.setMockMethodCallHandler((MethodCall methodCall) async {
-        log.add(methodCall);
-        return '/tmp/test.jpg';
-      });
-      log.clear();
-    });
-
     testWidgets('embed image', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
       await editor.tapButtonWithIcon(Icons.photo_camera);
 
     testWidgets('tap on left side of image puts caret before it',
         (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
       await editor.tapButtonWithIcon(Icons.photo_camera);
       expect(editor.selection.extentOffset, embed.documentOffset);
     });
 
-    testWidgets('tap right side of image puts caret after it',
-        (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+    testWidgets('tap right side of image puts caret after it', (tester) async {
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
       await editor.tapButtonWithIcon(Icons.photo_camera);
     });
 
     testWidgets('selects on long press', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = new EditorSandBox(
+        tester: tester,
+        imageDelegate: _TestImageDelegate(),
+      );
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.photo);
       await editor.tapButtonWithIcon(Icons.photo_camera);
       EmbedNode embed = line.children.single;
       expect(editor.selection.baseOffset, embed.documentOffset);
       expect(editor.selection.extentOffset, embed.documentOffset + 1);
-      expect(find.text('Paste'), findsOneWidget);
+      expect(find.text('PASTE'), findsOneWidget);
     });
   });
 }
+
+class _TestImageDelegate implements ZefyrImageDelegate<String> {
+  @override
+  Widget buildImage(BuildContext context, String key) {
+    return Image.file(File(key));
+  }
+
+  @override
+  String get cameraSource => "camera";
+
+  @override
+  String get gallerySource => "gallery";
+
+  @override
+  Future<String> pickImage(String source) {
+    return Future.value("file:///tmp/test.jpg");
+  }
+}

packages/zefyr/test/widgets/scope_test.dart

       WidgetsFlutterBinding.ensureInitialized();
       final doc = NotusDocument();
       scope = ZefyrScope.editable(
+        mode: ZefyrMode.edit,
         controller: ZefyrController(doc),
-        imageDelegate: ZefyrDefaultImageDelegate(),
         focusNode: FocusNode(),
         focusScope: FocusScopeNode(),
       );
       scope.addListener(() {
         notified = true;
       });
-      final delegate = ZefyrDefaultImageDelegate();
+      final delegate = _TestImageDelegate();
       scope.imageDelegate = delegate;
       expect(notified, isTrue);
       notified = false;
     });
   });
 }
+
+class _TestImageDelegate implements ZefyrImageDelegate<String> {
+  @override
+  Widget buildImage(BuildContext context, String key) {
+    return null;
+  }
+
+  @override
+  String get cameraSource => null;
+
+  @override
+  String get gallerySource => null;
+
+  @override
+  Future<String> pickImage(String source) {
+    return null;
+  }
+}

packages/zefyr/test/widgets/selection_test.dart

       await tester.pumpAndSettle();
       await tester.tapAt(offset);
       await tester.pumpAndSettle();
-      expect(find.text('Paste'), findsOneWidget);
+      expect(find.text('PASTE'), findsOneWidget);
     });
 
     testWidgets('hides when editor lost focus', (tester) async {