feat: find dialog 1760

lib/src/history/undo_manager.dart

@@ -149,4 +149,12 @@ class UndoManager {
       ),
     );
   }
+
+  void forgetRecentUndo() {
+    Log.editor.debug('forgetRecentUndo');
+    if (state == null) {
+      return;
+    }
+    undoStack.pop();
+  }
 }

lib/src/render/find_replace_menu/find_menu_service.dart

@@ -0,0 +1,107 @@
+import 'package:appflowy_editor/appflowy_editor.dart';
+import 'package:appflowy_editor/src/render/find_replace_menu/find_replace_widget.dart';
+import 'package:flutter/material.dart';
+import '../../editor_state.dart';
+
+abstract class FindReplaceService {
+  void show();
+  void dismiss();
+}
+
+class FindReplaceMenu implements FindReplaceService {
+  FindReplaceMenu({
+    required this.context,
+    required this.editorState,
+    required this.replaceFlag,
+  });
+
+  final BuildContext context;
+  final EditorState editorState;
+  final bool replaceFlag;
+  final double topOffset = 52;
+  final double rightOffset = 40;
+
+  OverlayEntry? _findReplaceMenuEntry;
+  bool _selectionUpdateByInner = false;
+
+  @override
+  void dismiss() {
+    if (_findReplaceMenuEntry != null) {
+      editorState.service.keyboardService?.enable();
+      editorState.service.scrollService?.enable();
+    }
+
+    _findReplaceMenuEntry?.remove();
+    _findReplaceMenuEntry = null;
+
+    final isSelectionDisposed =
+        editorState.service.selectionServiceKey.currentState == null;
+    if (!isSelectionDisposed) {
+      final selectionService = editorState.service.selectionService;
+      selectionService.currentSelection.removeListener(_onSelectionChange);
+    }
+  }
+
+  @override
+  void show() {
+    dismiss();
+
+    final selectionService = editorState.service.selectionService;
+    final selectionRects = selectionService.selectionRects;
+    if (selectionRects.isEmpty) {
+      return;
+    }
+
+    _findReplaceMenuEntry = OverlayEntry(
+      builder: (context) {
+        return Positioned(
+          top: topOffset,
+          right: rightOffset,
+          child: Material(
+            borderRadius: BorderRadius.circular(8.0),
+            child: DecoratedBox(
+              decoration: BoxDecoration(
+                color: editorState.editorStyle.selectionMenuBackgroundColor ??
+                    Colors.white,
+                boxShadow: [
+                  BoxShadow(
+                    blurRadius: 5,
+                    spreadRadius: 1,
+                    color: Colors.black.withOpacity(0.1),
+                  ),
+                ],
+                borderRadius: BorderRadius.circular(6.0),
+              ),
+              child: FindMenuWidget(
+                dismiss: dismiss,
+                editorState: editorState,
+                replaceFlag: replaceFlag,
+              ),
+            ),
+          ),
+        );
+      },
+    );
+
+    Overlay.of(context).insert(_findReplaceMenuEntry!);
+  }
+
+  void _onSelectionChange() {
+    // workaround: SelectionService has been released after hot reload.
+    final isSelectionDisposed =
+        editorState.service.selectionServiceKey.currentState == null;
+    if (!isSelectionDisposed) {
+      final selectionService = editorState.service.selectionService;
+      if (selectionService.currentSelection.value == null) {
+        return;
+      }
+    }
+
+    if (_selectionUpdateByInner) {
+      _selectionUpdateByInner = false;
+      return;
+    }
+
+    dismiss();
+  }
+}

lib/src/render/find_replace_menu/find_replace_widget.dart

@@ -0,0 +1,152 @@
+import 'package:appflowy_editor/appflowy_editor.dart';
+import 'package:appflowy_editor/src/render/find_replace_menu/search_service.dart';
+import 'package:flutter/material.dart';
+
+class FindMenuWidget extends StatefulWidget {
+  const FindMenuWidget({
+    super.key,
+    required this.dismiss,
+    required this.editorState,
+    required this.replaceFlag,
+  });
+
+  final VoidCallback dismiss;
+  final EditorState editorState;
+  final bool replaceFlag;
+
+  @override
+  State<FindMenuWidget> createState() => _FindMenuWidgetState();
+}
+
+class _FindMenuWidgetState extends State<FindMenuWidget> {
+  final findController = TextEditingController();
+  final replaceController = TextEditingController();
+  String queriedPattern = '';
+  bool replaceFlag = false;
+  late SearchService searchService;
+
+  @override
+  void initState() {
+    super.initState();
+    replaceFlag = widget.replaceFlag;
+    searchService = SearchService(
+      editorState: widget.editorState,
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      children: [
+        Row(
+          children: [
+            IconButton(
+              onPressed: () => setState(() {
+                replaceFlag = !replaceFlag;
+              }),
+              icon: replaceFlag
+                  ? const Icon(Icons.expand_less)
+                  : const Icon(Icons.expand_more),
+            ),
+            Padding(
+              padding: const EdgeInsets.all(6.0),
+              child: SizedBox(
+                width: 200,
+                height: 50,
+                child: TextField(
+                  key: const Key('findTextField'),
+                  autofocus: true,
+                  controller: findController,
+                  onSubmitted: (_) => _searchPattern(),
+                  decoration: const InputDecoration(
+                    border: OutlineInputBorder(),
+                    hintText: 'Enter text to search',
+                  ),
+                ),
+              ),
+            ),
+            IconButton(
+              key: const Key('previousMatchButton'),
+              onPressed: () => searchService.navigateToMatch(moveUp: true),
+              icon: const Icon(Icons.arrow_upward),
+              tooltip: 'Previous Match',
+            ),
+            IconButton(
+              key: const Key('nextMatchButton'),
+              onPressed: () => searchService.navigateToMatch(),
+              icon: const Icon(Icons.arrow_downward),
+              tooltip: 'Next Match',
+            ),
+            IconButton(
+              key: const Key('closeButton'),
+              onPressed: () {
+                widget.dismiss();
+                searchService.findAndHighlight(queriedPattern);
+                setState(() {
+                  queriedPattern = '';
+                });
+              },
+              icon: const Icon(Icons.close),
+              tooltip: 'Close',
+            ),
+          ],
+        ),
+        replaceFlag
+            ? Row(
+                children: [
+                  Padding(
+                    padding: const EdgeInsets.all(6.0),
+                    child: SizedBox(
+                      width: 200,
+                      height: 50,
+                      child: TextField(
+                        key: const Key('replaceTextField'),
+                        autofocus: false,
+                        controller: replaceController,
+                        onSubmitted: (_) => _replaceSelectedWord(),
+                        decoration: const InputDecoration(
+                          border: OutlineInputBorder(),
+                          hintText: 'Replace',
+                        ),
+                      ),
+                    ),
+                  ),
+                  IconButton(
+                    onPressed: () => _replaceSelectedWord(),
+                    icon: const Icon(Icons.find_replace),
+                    tooltip: 'Replace',
+                  ),
+                  IconButton(
+                    key: const Key('replaceAllButton'),
+                    onPressed: () => _replaceAllMatches(),
+                    icon: const Icon(Icons.change_circle_outlined),
+                    tooltip: 'Replace All',
+                  ),
+                ],
+              )
+            : const SizedBox.shrink(),
+      ],
+    );
+  }
+
+  void _searchPattern() {
+    searchService.findAndHighlight(findController.text);
+    setState(() {
+      queriedPattern = findController.text;
+    });
+  }
+
+  void _replaceSelectedWord() {
+    if (findController.text != queriedPattern) {
+      _searchPattern();
+    }
+    searchService.replaceSelectedWord(replaceController.text);
+  }
+
+  void _replaceAllMatches() {
+    if (findController.text != queriedPattern) {
+      _searchPattern();
+    }
+    searchService.replaceAllMatches(replaceController.text);
+  }
+}

lib/src/render/find_replace_menu/search_algorithm.dart

@@ -0,0 +1,47 @@
+import 'dart:math' as math;
+
+class BayerMooreAlgorithm {
+  //This is a standard algorithm used for searching patterns in long text samples
+  //It is more efficient than brute force searching because it is able to skip
+  //characters that will never possibly match with required pattern.
+  List<int> boyerMooreSearch(String pattern, String text) {
+    int m = pattern.length;
+    int n = text.length;
+
+    Map<String, int> badchar = {};
+    List<int> matches = [];
+
+    _badCharHeuristic(pattern, m, badchar);
+
+    int s = 0;
+
+    while (s <= (n - m)) {
+      int j = m - 1;
+
+      while (j >= 0 && pattern[j] == text[s + j]) {
+        j--;
+      }
+
+      //if pattern is present at current shift, the index will become -1
+      if (j < 0) {
+        matches.add(s);
+        s += (s + m < n) ? m - (badchar[text[s + m]] ?? -1) : 1;
+      } else {
+        s += math.max(1, j - (badchar[text[s + j]] ?? -1));
+      }
+    }
+
+    return matches;
+  }
+
+  void _badCharHeuristic(String pat, int size, Map<String, int> badchar) {
+    badchar.clear();
+
+    // Fill the actual value of last occurrence of a character
+    // (indices of table are characters and values are index of occurrence)
+    for (int i = 0; i < size; i++) {
+      String ch = pat[i];
+      badchar[ch] = i;
+    }
+  }
+}