feat: history-undo-redo (unstable)

lib/canvas_setup_page.dart

                       context: context, 
                       builder: (context) => AlertDialog(
                         title: Text('Update Label Size'),
-                        content: Text('updating to smaller label size may cause element lost, Are you sure want to update label size ?'),
+                        content: Text('updating label size will remove all history you have changed, Are you sure want to update label size ?'),
                         actions: [
                           TextButton(
                             onPressed: () => Navigator.pop(context, true), 

lib/history.dart

+
+import 'package:flutter_canvas_editor/widgets/elements.dart';
+
+enum CanvasHistoryModifyType { add, remove, move, resize, lock, rotate, textEdit, redo}
+
+class CanvasHistory {
+  final CanvasHistoryModifyType type;
+  List<ElementProperty> elementPropeties;
+
+  CanvasHistory(this.type, this.elementPropeties);
+
+  List<ElementProperty> get getState => elementPropeties;
+}

lib/main.dart

 import 'package:defer_pointer/defer_pointer.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_canvas_editor/canvas_setup_page.dart';
+import 'package:flutter_canvas_editor/history.dart';
 import 'package:flutter_canvas_editor/providers/editor.dart';
 import 'package:flutter_canvas_editor/snaptest_page.dart';
 import 'package:flutter_canvas_editor/test_page.dart';
   // functions
   void setInitialZoom() {
     Provider.of<Editor>(context, listen: false).setCanvasTransformationInitialZoom(context);
-
-    // double deviceWidth = MediaQuery.of(context).size.width;
-    // double deviceHeight = MediaQuery.of(context).size.height;
-
-    // print('device width: $deviceWidth');
-    // print('device height: $deviceHeight');
-
-    // initialScale = deviceWidth / Provider.of<Editor>(context, listen: false).canvasProperty.width * 0.9;
-    
-    // print('initialScale $initialScale');
-
-    // _transformationController.value = Matrix4.identity()..scale(initialScale);
-    
   }
 
   void setTransformControllerListener() {
           title: Text('Template Editor'),
           actions: [
 
+            IconButton(
+              onPressed: Provider.of<Editor>(context, listen: false).undoStack.isEmpty ? null : () {
+                Provider.of<Editor>(context, listen: false).undo();
+              },
+              icon: Icon(Icons.undo)
+            ),
+            IconButton(
+              onPressed: Provider.of<Editor>(context, listen: false).redoStack.isEmpty ? null : () {
+                Provider.of<Editor>(context, listen: false).redo();
+              },
+              icon: Icon(Icons.redo)
+            ),
+
             // ! DEBUG BUTTON
             IconButton(
               onPressed: () {

lib/providers/editor.dart

 
 import 'package:defer_pointer/defer_pointer.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_canvas_editor/history.dart';
 import 'package:flutter_canvas_editor/style/canvas_style.dart';
 import 'package:flutter_canvas_editor/widgets/elements.dart';
 import 'package:toastification/toastification.dart';
 import 'package:uuid/uuid.dart';
+import 'package:collection/collection.dart';
 
 import '../main.dart';
 
       qrScale: 3
     )
   ];
-  // int _reservedIdUntil = 0;
+
+
+
+
+  // ? History stack
+  List<CanvasHistory> undoStack = [];
+  List<List<ElementProperty>> redoStack = [];
+
+
+  void addUndoEntry(CanvasHistoryModifyType canvasHistoryType, List<ElementProperty> elementProperties) {
+    undoStack.add(CanvasHistory(canvasHistoryType, _cloneCurrentState(elementProperties)));
+
+    redoStack.clear();
+
+    notifyListeners();
+  }
+
+  void undo() {
+    addRedoEntry(elementProperties);
+
+    // apply to current state
+    if (undoStack.last.type == CanvasHistoryModifyType.textEdit && undoStack.last.getState != elementProperties) {
+      undoStack.removeLast();
+    }
+
+    elementProperties = undoStack.last.getState;
+
+    // unselect element
+    if (elementProperties.firstWhereOrNull((e) => e.id == selectedElmId) == null) {
+      unSelectElm();
+    }
+
+    undoStack.removeLast();
+
+    notifyListeners();
+  }
+
+
+  void addRedoEntry(List<ElementProperty> elementProperties) {
+    redoStack.add(_cloneCurrentState(elementProperties));
+
+    notifyListeners();
+  }
+
+  void redo() {
+    undoStack.add(CanvasHistory(CanvasHistoryModifyType.redo, _cloneCurrentState(elementProperties)));
+     
+    // apply to current state
+    elementProperties = redoStack.last;
+
+    redoStack.removeLast();
+
+    notifyListeners();
+  }
+
+  List<ElementProperty> _cloneCurrentState(List<ElementProperty> elementProperties) {
+    List<ElementProperty> clonedElementProperties = elementProperties.map((elementProperty) {
+      return ElementProperty(
+        id: elementProperty.id,
+        valueController: TextEditingController(text: elementProperty.valueController.text),
+        type: elementProperty.type,
+        position: ElementPosition(top: elementProperty.position.top, left: elementProperty.position.left),
+        width: elementProperty.width,
+        quarterTurns: elementProperty.quarterTurns,
+        elementKey: elementProperty.elementKey,
+        qrScale: elementProperty.qrScale,
+        fontScale: elementProperty.fontScale,
+        variableType: elementProperty.variableType,
+        isLocked: elementProperty.isLocked
+      );
+    }).toList();
+
+    return clonedElementProperties;
+  }
+
+
+
 
   // ? udpate canvas
   void updateCanvasProperty(BuildContext context, double width, double height) {
     canvasProperty.height = height;
     canvasProperty.width = width;
+    
+    undoStack.clear();
+    redoStack.clear();
 
     _adjustOutOfBoundElement();
 
     );
 
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
+
     elementProperties.add(element);
     // _reservedIdUntil = elementProperties.length - 1;r
     notifyListeners();
       elementKey: GlobalKey()
     );
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
     elementProperties.add(element);
     notifyListeners();
 
       elementKey: GlobalKey()
     );
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
     elementProperties.add(element);
     notifyListeners();
 
       elementKey: GlobalKey()
     );
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
     elementProperties.add(element);
     notifyListeners();
 
       elementKey: GlobalKey()
     );
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
     elementProperties.add(element);
     notifyListeners();
 
       elementKey: GlobalKey()
     );
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
     elementProperties.add(element);
     notifyListeners();
 
       elementKey: GlobalKey()
     );
 
+    // Save History
+    addUndoEntry(CanvasHistoryModifyType.add, elementProperties);
+
     elementProperties.add(element);
     notifyListeners();
 
   void toggleLockElement() {
     if (selectedElm == null) return;
 
+    // ? Save History
+    addUndoEntry(CanvasHistoryModifyType.lock, elementProperties);
+
     selectedElm!.isLocked = !selectedElm!.isLocked;
     notifyListeners();
   }
     }
     
     if (![ElementType.text, ElementType.textbox].contains(element.type)) return;
-
+    
+    // ? Save history
+    addUndoEntry(CanvasHistoryModifyType.rotate, elementProperties);
 
     if (element.type == ElementType.text) _rotateText(element);
 
       return;
     }
 
+    // ? Save History
+    addUndoEntry(CanvasHistoryModifyType.resize, elementProperties);
+
     selectedElm!.fontScale = fontSize;
     notifyListeners();
   }
     }
     // check if value is allowed for resize
     if (CanvasStyle.fontSizeMap.containsKey(incrementTo)) {
+      // ? Save History
+      addUndoEntry(CanvasHistoryModifyType.resize, elementProperties);
+
       selectedElm!.fontScale = incrementTo;
       print('kepenjet increase');
     } else {
     }
     // check if value is allowed for resize
     if (CanvasStyle.fontSizeMap.containsKey(decrementTo)) {
+      // ? Save History
+      addUndoEntry(CanvasHistoryModifyType.resize, elementProperties);
+
       selectedElm!.fontScale = decrementTo;
     } else {
       print('cant decrement');
 
     if (!shouldDelete) return;
 
+    // ? Save History
+    addUndoEntry(CanvasHistoryModifyType.remove, elementProperties);
+
     elementProperties.removeWhere((e) => e.id == selectedElm!.id);
     unSelectElm();
 

lib/test.dart

+// void main() {
+//   List<ElementProperty>elementProperties = [
+//     ElementProperty(top: 0, left: 0)
+//   ];
+
+//   print('Original:');
+//   elementProperties[0].printAll();
+//   print('\n\n\n');
+
+
+//   List<List<ElementProperty>> undoStack = [];
+
+//   // Add to undoStack
+//   undoStack.add(cloneState(elementProperties));
+
+//   // State changes
+//   elementProperties.first.top = 10;
+
+//   print('Original:');
+//   elementProperties[0].printAll();
+//   print('UndoStack:');
+//   undoStack.first.first.printAll();
+
+//   // Add to undoStack
+//   undoStack.add(cloneState(elementProperties));
+
+//   // State changes
+//   elementProperties.first.top = 20;
+
+//   print('Original2:');
+//   elementProperties[0].printAll();
+//   print('UndoStack2:');
+//   undoStack.first.first.printAll();
+//   undoStack.last.first.printAll();
+// }
+
+// List<ElementProperty> cloneState(List<ElementProperty> elementProperties) {
+//   List<ElementProperty> clonedElementProperties = elementProperties.map((elementProperty) {
+//     return ElementProperty(
+//       top: elementProperty.top,
+//       left: elementProperty.left,
+//     );
+//   }).toList();
+
+//   return clonedElementProperties;
+// }
+
+// class ElementProperty {
+//   double top;
+//   double left;
+
+//   ElementProperty({
+//     required this.top,
+//     required this.left,
+//   });
+
+//   void printAll() {
+//     print('top: $top, left: $left');
+//   }
+// }

lib/text_debouncer_test.dart

+import 'package:easy_debounce/easy_throttle.dart';
+
+void main() {
+  EasyThrottle.throttle(
+    'my-debouncer', 
+    Duration(milliseconds: 1000), 
+    () => {
+      print('Executed !!!')
+    },
+    onAfter: () => {
+      print('After !!!')
+    }
+  );
+}

lib/widgets/elements.dart

+import 'dart:developer';
+
 import 'package:defer_pointer/defer_pointer.dart';
+import 'package:easy_debounce/easy_debounce.dart';
+import 'package:easy_debounce/easy_throttle.dart';
 import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_canvas_editor/history.dart';
 import 'package:flutter_canvas_editor/providers/editor.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
   int fontScale;
   int? qrScale; 
   bool isLocked;
+  String? lastSavedText;
 
   ElementProperty({
     required this.id,
     this.fontScale = 3,
     this.qrScale,
     this.isLocked = false,
-    this.variableType
+    this.variableType,
+    this.lastSavedText
   });
 
 }
 
   late TransformationController _transformController;
 
+  // // TODO: pindhkan ke state element property agar bisa dipake di widget Toolbar
+  // String? _lastSavedText;
+
+  FocusNode? _focus = FocusNode();
+
   @override
   void initState() {
     super.initState();
 
     _setInitialScale();
     _listenTransformationChanges();
+    _addFocusNodeListener();
   }
 
 
     _transformController.removeListener(_updateScale);
   }
 
+  void _addFocusNodeListener() {
+    if ([ElementType.text, ElementType.textbox].contains(widget.elementProperty.type)) {
+      _focus!.addListener(_onTextFieldFocusChange);
+    }
+  }
+
+  void _onTextFieldFocusChange() {
+    if (widget.elementProperty.lastSavedText != widget.elementProperty.valueController.text) {
+      print('executed');
+      Provider.of<Editor>(context, listen: false).addUndoEntry(CanvasHistoryModifyType.textEdit, Provider.of<Editor>(context, listen:  false).elementProperties);
+      widget.elementProperty.lastSavedText = widget.elementProperty.valueController.text;
+    }
+  }
+
+  void _removeFocusNodeListener() {
+    if ([ElementType.text, ElementType.textbox].contains(widget.elementProperty.type)) {
+      _focus!.removeListener(_onTextFieldFocusChange);
+    }
+  }
+
 
 
 
   @override
   void dispose() {
    _removeTransformationListener();
+   _removeFocusNodeListener();
     super.dispose();
   }
 
       _height = element.elementKey.currentContext!.size!.height;
     });
 
+    List<ElementProperty> currentCanvasState = editorProvider.elementProperties;
+
     return Positioned(
       top: element.position.top,
       left: element.position.left,
           print('Element Gesture Detector Tapped!');
           Provider.of<Editor>(context, listen: false).selectElmById(element.id);
         },
+        onPanStart: (details) {
+          log('Pan Start');
+          inspect(editorProvider.elementProperties);
+          editorProvider.addUndoEntry(CanvasHistoryModifyType.move, editorProvider.elementProperties);
+        },
         onPanUpdate: (details) {
           if (!Provider.of<Editor>(context, listen: false).isSelected(element.id)) {
             return;
             }
 
 
-          Provider.of<Editor>(context, listen: false).updateElmPosition(Offset(adjustedElementPosition.left - element.position.left, adjustedElementPosition.top - element.position.top));
+          Provider.of<Editor>(context, listen: false).updateElmPosition(
+            Offset(adjustedElementPosition.left - element.position.left, adjustedElementPosition.top - element.position.top),
+            // Provider.of<Editor>(context, listen: false).elementProperties
+          );
         },
         child: Stack(
           clipBehavior: Clip.none,
     if (Provider.of<Editor>(context, listen: true).isEditing && (Provider.of<Editor>(context, listen: true).selectedElmId == element.id)) {
       return IntrinsicWidth(
         child: TextField(
+          focusNode: _focus,
           controller: Provider.of<Editor>(context).selectedElm!.valueController,
           autofocus: true,
           keyboardType: TextInputType.multiline,
             contentPadding: EdgeInsets.zero,
             border: InputBorder.none,
           ),
-          onChanged: (_) {
-            setState(() {
-              
-            });
-          }
+          onChanged: (newText) {
+
+            if (widget.elementProperty.lastSavedText != null && newText != widget.elementProperty.lastSavedText) {
+              EasyDebounce.debounce(
+                'text-debounce${element.id}', 
+                const Duration(milliseconds: 500), 
+                () {
+                  Provider.of<Editor>(context, listen: false).addUndoEntry(CanvasHistoryModifyType.textEdit, Provider.of<Editor>(context, listen: false).elementProperties);
+                  widget.elementProperty.lastSavedText = newText;
+                }
+              );
+
+            }
+
+            setState(() {});
+          },
         ),
       );
     }

lib/widgets/toolbar.dart

+import 'package:easy_debounce/easy_debounce.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_canvas_editor/history.dart';
 import 'package:flutter_canvas_editor/providers/editor.dart';
 import 'package:flutter_canvas_editor/style/canvas_style.dart';
 import 'package:flutter_canvas_editor/widgets/elements.dart';
 
   List<DropdownMenuItem<int>> qrSizeDropdownItems= [];
 
+  FocusNode? _focus = FocusNode();
+
+  // String? _lastSavedText;
+
 
   @override
   void initState() {
 
     populateFontSizeDropdownItems();
     populateQrSizeDropdownItems();
+
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      _addFocusNodeListener();
+    });
   }
 
   //functions
     });
   }
 
+  void _addFocusNodeListener() {
+    if (Provider.of<Editor>(context, listen: false).selectedElmKey != null && [ElementType.text, ElementType.textbox].contains(Provider.of<Editor>(context, listen: false).selectedElm!.type)) {
+      _focus!.addListener(_onTextFieldFocusChange);
+    }
+  }
+
+  void _onTextFieldFocusChange() {
+    print('toolbar onfocus change');
+
+    if (Provider.of<Editor>(context, listen: false).selectedElm?.lastSavedText != Provider.of<Editor>(context, listen: false).selectedElm?.valueController.text) {
+      Provider.of<Editor>(context, listen: false).addUndoEntry(CanvasHistoryModifyType.textEdit, Provider.of<Editor>(context, listen: false).elementProperties);
+      Provider.of<Editor>(context, listen: false).selectedElm?.lastSavedText = Provider.of<Editor>(context, listen: false).selectedElm?.valueController.text;
+    }
+  }
+
+  void _removeFocusNodeListener() {
+    if ([ElementType.text, ElementType.textbox].contains(Provider.of<Editor>(context).selectedElm!.type)) {
+      _focus!.removeListener(_onTextFieldFocusChange);
+    }
+  }
+
+
+  @override
+  void dispose() {
+    // TODO: implement dispose
+
+    _removeFocusNodeListener();
+    super.dispose();
+  }
+
+
   @override
   Widget build(BuildContext context) {
     final editorProvider = Provider.of<Editor>(context);
     return [
       // ? Value Editor
       if([ElementType.text, ElementType.textbox].contains(editorProvider.selectedElm!.type)) TextField(
+        focusNode: _focus,
         readOnly: element!.isLocked, 
         controller: element!.valueController,
         onTap: editorProvider.enableEdit,
 
           print('kepenjet');
         },
-        onChanged: (value) {
-          setState(() {
-            
-          });
+        onChanged: (newText) {
+          if (element.lastSavedText != null && newText != element.lastSavedText) {
+            EasyDebounce.debounce(
+              'text-debounce-toolbar${element.id}',
+              const Duration(milliseconds: 500),
+              () {
+                editorProvider.addUndoEntry(CanvasHistoryModifyType.textEdit, editorProvider.elementProperties);
+                element.lastSavedText = newText;
+              },
+              
+            );
+
+          }
+
+
+          setState(() {});
         },
       ),
       

pubspec.lock

       url: "https://pub.dev"
     source: hosted
     version: "0.0.2"
+  easy_debounce:
+    dependency: "direct main"
+    description:
+      name: easy_debounce
+      sha256: f082609cfb8f37defb9e37fc28bc978c6712dedf08d4c5a26f820fa10165a236
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.3"
   equatable:
     dependency: transitive
     description:

pubspec.yaml

   uuid: ^4.5.1
   toastification: ^2.3.0
   intl: ^0.20.2
+  easy_debounce: ^2.0.3
 
 dev_dependencies:
   flutter_lints: ^3.0.0