Implement scrolling through previous notes

lib/db.dart

@@ -21,13 +21,18 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_notes_date_unique ON notes (date);
 -- ie. they're not really a list but instead a string
 -- But we will also keep a history of all todos
 -- Because we might as well
-CREATE TABLE IF NOT EXISTS todos (
+CREATE TABLE IF NOT EXISTS scratches (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   date TEXT DEFAULT CURRENT_TIMESTAMP,
   content TEXT NOT NULL
 );
-CREATE INDEX IF NOT EXISTS idx_todos_date ON todos (date);
+CREATE INDEX IF NOT EXISTS idx_scratches_date ON scratches (date);
-CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_date_unique ON todos (date);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_scratches_date_unique ON scratches (date);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY NOT NULL,
+  value TEXT NOT NULL
+);
 ''';
 
   static Future<String> _getDatabasePath() async {
@@ -83,4 +88,27 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_date_unique ON todos (date);
       rethrow;
     }
   }
+
+  // Settings Management
+  static Future<String?> getSetting(String key) async {
+    final List<Map<String, dynamic>> maps = await db.query(
+      'settings',
+      columns: ['value'],
+      where: 'key = ?',
+      whereArgs: [key],
+    );
+    if (maps.isNotEmpty) {
+      return maps.first['value'] as String?;
+    }
+    return null;
+  }
+
+  static Future<void> setSetting(String key, String value) async {
+    await db.insert(
+      'settings',
+      {'key': key, 'value': value},
+      conflictAlgorithm: ConflictAlgorithm.replace,
+    );
+    debugPrint("Setting updated: $key = $value");
+  }
 }

lib/main.dart

@@ -6,9 +6,14 @@ import 'package:journaler/notes.dart';
 import 'package:system_tray/system_tray.dart';
 import 'package:window_manager/window_manager.dart';
 import 'package:audioplayers/audioplayers.dart';
+import 'package:flutter/gestures.dart';
 
-const Duration popupInterval = Duration(minutes: 20);
+// TODO: Add an icon to the executable, simply use the existing tray icon
-const String notificationSound = 'MeetTheSniper.mp3';
+// TODO: Implement some sort of scroll through notes
+
+// Default values - will be replaced by DB values if they exist
+const Duration _defaultPopupInterval = Duration(minutes: 20);
+const String _defaultNotificationSound = 'MeetTheSniper.mp3';
 
 void main() async {
   await DB.init();
@@ -116,19 +121,29 @@ class MainPage extends StatefulWidget {
   const MainPage({super.key});
 
   @override
-  State<MainPage> createState() => _MainPageState();
+  State<MainPage> createState() => MainPageState();
 }
 
-class _MainPageState extends State<MainPage> with WindowListener {
+class MainPageState extends State<MainPage> with WindowListener {
   final SystemTray _systemTray = SystemTray();
+  final Menu _menu = Menu();
   final AudioPlayer _audioPlayer = AudioPlayer();
 
   final TextEditingController _previousEntryController =
       TextEditingController();
   final TextEditingController _currentEntryController = TextEditingController();
-  final TextEditingController _todoController = TextEditingController();
+  final FocusNode _currentEntryFocusNode = FocusNode();
+  final TextEditingController _scratchController = TextEditingController();
+  final TextEditingController _intervalController = TextEditingController();
+  final TextEditingController _soundController = TextEditingController();
 
   Note? previousNote;
+  Note? _currentlyDisplayedNote;
+  Duration _currentPopupInterval = _defaultPopupInterval;
+  String _currentNotificationSound = _defaultNotificationSound;
+
+  bool _canGoPrevious = false;
+  bool _canGoNext = false;
 
   Timer? _popupTimer;
   Timer? _debounceTimer;
@@ -139,7 +154,6 @@ class _MainPageState extends State<MainPage> with WindowListener {
     windowManager.addListener(this);
     _initSystemTray();
     _loadData();
-    _startPopupTimer();
     windowManager.setPreventClose(true);
     _setWindowConfig();
   }
@@ -151,7 +165,10 @@ class _MainPageState extends State<MainPage> with WindowListener {
     _debounceTimer?.cancel();
     _previousEntryController.dispose();
     _currentEntryController.dispose();
-    _todoController.dispose();
+    _currentEntryFocusNode.dispose();
+    _scratchController.dispose();
+    _intervalController.dispose();
+    _soundController.dispose();
     _audioPlayer.dispose();
     super.dispose();
   }
@@ -172,16 +189,31 @@ class _MainPageState extends State<MainPage> with WindowListener {
 
     await _systemTray.initSystemTray(iconPath: iconPath, toolTip: "Journaler");
 
+    await _menu.buildFrom([
+      MenuItemLabel(
+        label: 'Commit Sudoku',
+        onClicked: (menuItem) => windowManager.destroy(),
+      ),
+    ]);
+
+    await _systemTray.setContextMenu(_menu);
+
     _systemTray.registerSystemTrayEventHandler((eventName) {
       debugPrint("System Tray Event: $eventName");
+      if (eventName == kSystemTrayEventClick) {
         _showWindow();
+      } else if (eventName == kSystemTrayEventRightClick) {
+        _systemTray.popUpContextMenu();
+      }
     });
   }
 
   void _startPopupTimer() {
-    _popupTimer = Timer.periodic(popupInterval, (timer) {
+    _popupTimer?.cancel();
+    _popupTimer = Timer.periodic(_currentPopupInterval, (timer) {
       _showWindow();
     });
+    debugPrint("Popup timer started with interval: ${_currentPopupInterval.inMinutes} minutes");
   }
 
   Future<void> _showWindow() async {
@@ -192,42 +224,128 @@ class _MainPageState extends State<MainPage> with WindowListener {
       await windowManager.center();
       await windowManager.show();
       await windowManager.focus();
+      _currentEntryFocusNode.requestFocus();
       await _playSound();
     } else {
       await windowManager.focus();
+      _currentEntryFocusNode.requestFocus();
     }
   }
 
   Future<void> _playSound() async {
     await _audioPlayer.stop();
-    await _audioPlayer.play(AssetSource('sounds/$notificationSound'));
+    try {
-    debugPrint("Played sound: $notificationSound");
+      await _audioPlayer.play(AssetSource('sounds/$_currentNotificationSound'));
+      debugPrint("Played sound: $_currentNotificationSound");
+    } catch (e) {
+      debugPrint("Error playing sound $_currentNotificationSound: e");
+    }
+  }
+
+  Future<void> _checkNavigation() async {
+    if (_currentlyDisplayedNote == null) {
+      setState(() {
+        _canGoPrevious = false;
+        _canGoNext = false;
+      });
+      return;
+    }
+
+    final prev = await getPreviousNote(_currentlyDisplayedNote!.date);
+    final bool isLatest = _currentlyDisplayedNote!.date == previousNote?.date;
+
+    setState(() {
+      _canGoPrevious = prev != null;
+      _canGoNext = !isLatest;
+    });
+  }
+
+  Future<void> _goToPreviousNote() async {
+    if (!_canGoPrevious || _currentlyDisplayedNote == null) return;
+
+    final prevNote = await getPreviousNote(_currentlyDisplayedNote!.date);
+    if (prevNote != null) {
+      setState(() {
+        _currentlyDisplayedNote = prevNote;
+        _previousEntryController.text = prevNote.content;
+      });
+      await _checkNavigation();
+    }
+  }
+
+  Future<void> _goToNextNote() async {
+    if (!_canGoNext || _currentlyDisplayedNote == null) return;
+
+    final nextNote = await getNextNote(_currentlyDisplayedNote!.date);
+    if (nextNote != null) {
+      setState(() {
+        _currentlyDisplayedNote = nextNote;
+        _previousEntryController.text = nextNote.content;
+      });
+      await _checkNavigation();
+    }
   }
 
   void _loadData() async {
+    String? intervalMinutesStr = await DB.getSetting('popupIntervalMinutes');
+    String? soundFileStr = await DB.getSetting('notificationSound');
+
+    int intervalMinutes = int.tryParse(intervalMinutesStr ?? '') ?? _defaultPopupInterval.inMinutes;
+    _currentPopupInterval = Duration(minutes: intervalMinutes);
+    _currentNotificationSound = soundFileStr ?? _defaultNotificationSound;
+
+    _intervalController.text = intervalMinutes.toString();
+    _soundController.text = _currentNotificationSound;
+
+    _startPopupTimer();
+
     final note = await getLatestNote();
     previousNote = note;
-    _previousEntryController.text = note?.content ?? "";
+    _currentlyDisplayedNote = note;
+    _previousEntryController.text = _currentlyDisplayedNote?.content ?? "";
 
-    final todo = await getLatestTodo();
+    final scratch = await getLatestScratch();
-    _todoController.text = todo?.content ?? "";
+    _scratchController.text = scratch?.content ?? "";
     _currentEntryController.text = "";
 
-    debugPrint("Data loaded (placeholder).");
+    await _checkNavigation();
+
+    debugPrint("Data loaded.");
   }
 
   void _saveData() async {
     String previousEntry = _previousEntryController.text;
     String currentEntry = _currentEntryController.text;
-    String todoList = _todoController.text;
+    String scratchContent = _scratchController.text;
+    String intervalStr = _intervalController.text;
+    String soundStr = _soundController.text;
 
     await createNote(currentEntry);
-    await createTodo(todoList);
+    await createScratch(scratchContent);
+    if (previousNote != null) {
       previousNote!.content = previousEntry;
       await updateNote(previousNote!);
+    }
+
+    int newIntervalMinutes = int.tryParse(intervalStr) ?? _currentPopupInterval.inMinutes;
+    Duration newInterval = Duration(minutes: newIntervalMinutes);
+    if (newInterval != _currentPopupInterval) {
+      _currentPopupInterval = newInterval;
+      DB.setSetting('popupIntervalMinutes', newIntervalMinutes.toString());
+      _startPopupTimer();
+    } else {
+      DB.setSetting('popupIntervalMinutes', newIntervalMinutes.toString());
+    }
+
+    if (soundStr != _currentNotificationSound) {
+      _currentNotificationSound = soundStr;
+      DB.setSetting('notificationSound', soundStr);
+    } else {
+      DB.setSetting('notificationSound', soundStr);
+    }
 
     debugPrint(
-      "Saving data (placeholder)... Current Entry: [${currentEntry.length} chars], Todo: [${todoList.length} chars]",
+      "Saving data... Current Entry: [${currentEntry.length} chars], Scratch: [${scratchContent.length} chars]",
     );
   }
 
@@ -237,18 +355,87 @@ class _MainPageState extends State<MainPage> with WindowListener {
 
   @override
   Widget build(BuildContext context) {
-    return KeyboardListener(
+    // Wrap Scaffold with RawKeyboardListener as workaround for Escape key
-      focusNode: FocusNode(),
+    return RawKeyboardListener(
-      autofocus: true,
+      focusNode: FocusNode(), // Needs its own node
-      onKeyEvent: (event) {
+      onKey: (RawKeyEvent event) {
-        if (event is KeyDownEvent &&
+        if (event is RawKeyDownEvent &&
             event.logicalKey == LogicalKeyboardKey.escape) {
-          debugPrint("Escape key pressed - hiding window.");
+          debugPrint(
+            "Escape pressed inside MainPage (RawKeyboardListener - Workaround)",
+          );
+          // Call method directly since we are in the state
+          FocusManager.instance.primaryFocus?.unfocus(); // Keep unfocus attempt
           onWindowClose();
         }
       },
       child: Scaffold(
-        appBar: AppBar(title: const Text('Journaler'), actions: const []),
+        appBar: AppBar(
+          title: const Text('Journaler'),
+          actions: <Widget>[
+            // Group Label and Input for Interval
+            Padding(
+              padding: const EdgeInsets.symmetric(vertical: 8.0).copyWith(left: 8.0), // Add padding
+              child: Row(
+                mainAxisSize: MainAxisSize.min, // Use minimum space
+                children: [
+                  const Text("Interval (m):"),
+                  const SizedBox(width: 4), // Space between label and input
+                  SizedBox(
+                    width: 60, // Constrain width
+                    child: TextField(
+                      controller: _intervalController,
+                      // textAlignVertical: TextAlignVertical.center, // Let default alignment handle it
+                      decoration: const InputDecoration(
+                        border: OutlineInputBorder(),
+                        isDense: true,
+                        contentPadding: EdgeInsets.symmetric(horizontal: 8.0, vertical: 8.0),
+                      ),
+                      keyboardType: TextInputType.number,
+                      inputFormatters: <TextInputFormatter>[
+                        FilteringTextInputFormatter.digitsOnly
+                      ],
+                    ),
+                  ),
+                ],
+              ),
+            ),
+            // Group Label and Input for Sound
+            Padding(
+              padding: const EdgeInsets.symmetric(vertical: 8.0, horizontal: 8.0),
+              child: Row(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  const Text("Sound:"),
+                  const SizedBox(width: 4),
+                  SizedBox(
+                    width: 150, // Constrain width
+                    child: TextField(
+                      controller: _soundController,
+                      // textAlignVertical: TextAlignVertical.center,
+                      decoration: const InputDecoration(
+                        border: OutlineInputBorder(),
+                        isDense: true,
+                        contentPadding: EdgeInsets.symmetric(horizontal: 8.0, vertical: 8.0),
+                        hintText: 'sound.mp3',
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+            // Test Sound Button
+            Padding(
+              padding: const EdgeInsets.symmetric(vertical: 8.0),
+              child: IconButton(
+                icon: const Icon(Icons.volume_up),
+                tooltip: 'Test Sound',
+                onPressed: _playSound,
+              ),
+            ),
+            const SizedBox(width: 10),
+          ],
+        ),
         body: Padding(
           padding: const EdgeInsets.all(8.0),
           child: Row(
@@ -256,17 +443,63 @@ class _MainPageState extends State<MainPage> with WindowListener {
             children: [
               Expanded(
                 flex: 9,
+                child: Listener(
+                  behavior: HitTestBehavior.opaque,
+                  onPointerSignal: (pointerSignal) {
+                    if (pointerSignal is PointerScrollEvent) {
+                      if (pointerSignal.scrollDelta.dy < 0) {
+                        if (_canGoPrevious) {
+                          _goToPreviousNote();
+                        }
+                      } else if (pointerSignal.scrollDelta.dy > 0) {
+                        if (_canGoNext) {
+                          _goToNextNote();
+                        }
+                      }
+                    }
+                  },
                   child: Column(
                     crossAxisAlignment: CrossAxisAlignment.stretch,
                     children: [
+                      // Combine Label, Buttons, and TextField for Previous Entry
+                      Row(
+                        children: [
+                          Expanded(
+                            child: Text(
+                              _currentlyDisplayedNote?.date == previousNote?.date
+                                  ? 'Previous Entry (Latest)'
+                                  : 'Entry: ${_currentlyDisplayedNote?.date ?? 'N/A'}',
+                              style: TextStyle(fontSize: 18, color: Colors.grey),
+                            ),
+                          ),
+                          IconButton(
+                            icon: const Icon(Icons.arrow_back),
+                            tooltip: 'Previous Note',
+                            onPressed: _canGoPrevious ? _goToPreviousNote : null,
+                          ),
+                          IconButton(
+                            icon: const Icon(Icons.arrow_forward),
+                            tooltip: 'Next Note',
+                            onPressed: _canGoNext ? _goToNextNote : null,
+                          ),
+                        ],
+                      ),
                       Expanded(
                         child: TextField(
                           controller: _previousEntryController,
+                          readOnly: _currentlyDisplayedNote?.date != previousNote?.date,
                           maxLines: null,
                           expands: true,
                           style: Theme.of(context).textTheme.bodyMedium,
-                        decoration: const InputDecoration(
+                          decoration: InputDecoration(
-                          labelText: 'Previous Entry',
+                            hintText: _currentlyDisplayedNote?.date != previousNote?.date
+                                ? 'Viewing note from ${_currentlyDisplayedNote?.date} (Read-Only)'
+                                : 'Latest Note',
+                            border: const OutlineInputBorder(),
+                            filled: _currentlyDisplayedNote?.date != previousNote?.date,
+                            fillColor: _currentlyDisplayedNote?.date != previousNote?.date
+                                ? Colors.grey.withOpacity(0.1)
+                                : null,
                           ),
                         ),
                       ),
@@ -274,6 +507,7 @@ class _MainPageState extends State<MainPage> with WindowListener {
                       Expanded(
                         child: TextField(
                           controller: _currentEntryController,
+                          focusNode: _currentEntryFocusNode,
                           maxLines: null,
                           expands: true,
                           autofocus: true,
@@ -281,27 +515,22 @@ class _MainPageState extends State<MainPage> with WindowListener {
                           decoration: const InputDecoration(
                             labelText: 'Current Entry (What\'s on your mind?)',
                           ),
-                        onChanged: (text) {},
                         ),
                       ),
                     ],
                   ),
                 ),
+              ),
               const SizedBox(width: 8),
               Expanded(
-                flex: 3,
+                flex: 4, // Adjust flex factor as needed
                 child: TextField(
-                  controller: _todoController,
+                  controller: _scratchController,
                   maxLines: null,
                   expands: true,
-                  style:
+                  style: Theme.of(context).textTheme.bodyMedium, // Apply theme text style
-                      Theme.of(
-                        context,
-                      ).textTheme.bodyMedium, // Apply theme text style
                   decoration: const InputDecoration(
-                    labelText: 'Todo',
+                    labelText: 'Scratch',
-                    // border: OutlineInputBorder(), // Handled by theme
-                    // contentPadding: EdgeInsets.all(8.0), // Handled by theme or default
                   ),
                 ),
               ),
@@ -312,3 +541,5 @@ class _MainPageState extends State<MainPage> with WindowListener {
     );
   }
 }
+
+// --- End Actions and Shortcuts ---

lib/notes.dart

@@ -7,11 +7,11 @@ class Note {
   Note({required this.date, required this.content});
 }
 
-class Todo {
+class Scratch {
   final String date;
-  final String content;
+  String content;
 
-  Todo({required this.date, required this.content});
+  Scratch({required this.date, required this.content});
 }
 
 Future<Note?> getLatestNote() async {
@@ -43,22 +43,60 @@ Future<void> updateNote(Note note) async {
   );
 }
 
-Future<Todo?> getLatestTodo() async {
+Future<Scratch?> getLatestScratch() async {
-  final todo = await DB.db.rawQuery(
+  final scratch = await DB.db.rawQuery(
-    'SELECT content, date FROM todos ORDER BY date DESC LIMIT 1',
+    'SELECT content, date FROM scratches ORDER BY date DESC LIMIT 1',
   );
-  if (todo.isEmpty) {
+
+  if (scratch.isEmpty) {
     return null;
-  }
+  } else {
-  return Todo(
+    return Scratch(
-    date: todo[0]['date'] as String,
+      date: scratch[0]['date'] as String,
-    content: todo[0]['content'] as String,
+      content: scratch[0]['content'] as String,
     );
+  }
 }
 
-Future<void> createTodo(String content) async {
+Future<void> createScratch(String content) async {
-  if (content.isEmpty) {
+  await DB.db.insert('scratches', {'content': content});
-    return;
+}
-  }
+
-  await DB.db.insert('todos', {'content': content});
+// Get the note immediately older than the given date
+Future<Note?> getPreviousNote(String currentDate) async {
+  final List<Map<String, dynamic>> notes = await DB.db.query(
+    'notes',
+    where: 'date < ?',
+    whereArgs: [currentDate],
+    orderBy: 'date DESC',
+    limit: 1,
+  );
+  if (notes.isNotEmpty) {
+    return Note(
+      date: notes.first['date'] as String,
+      content: notes.first['content'] as String,
+    );
+  }
+  return null;
+}
+
+// Get the note immediately newer than the given date
+Future<Note?> getNextNote(String currentDate) async {
+  final List<Map<String, dynamic>> notes = await DB.db.query(
+    'notes',
+    where: 'date > ?',
+    whereArgs: [currentDate],
+    orderBy: 'date ASC',
+    limit: 1,
+  );
+  if (notes.isNotEmpty) {
+    return Note(
+      date: notes.first['date'] as String,
+      content: notes.first['content'] as String,
+    );
+  }
+  // If there's no newer note, it means we might be at the latest
+  // but let's double-check by explicitly getting the latest again.
+  // This handles the case where the `currentDate` might not be the absolute latest.
+  return getLatestNote();
 }