Implement scrolling through previous notes

lib/db.dart

@@ -28,6 +28,11 @@ CREATE TABLE IF NOT EXISTS scratches (
 );
 CREATE INDEX IF NOT EXISTS idx_scratches_date ON scratches (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_scratches_date_unique ON scratches (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,15 +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';
 
 // TODO: Add an icon to the executable, simply use the existing tray icon
-// TODO: Add an entry field for the duration ie. the interval of apperance
-// TODO: Also the sound file, if possible...
-// TODO: Cram the above into the database
 // TODO: Implement some sort of scroll through notes
 
-const Duration popupInterval = Duration(minutes: 20);
+// Default values - will be replaced by DB values if they exist
-const String notificationSound = 'MeetTheSniper.mp3';
+const Duration _defaultPopupInterval = Duration(minutes: 20);
+const String _defaultNotificationSound = 'MeetTheSniper.mp3';
 
 void main() async {
   await DB.init();
@@ -135,8 +134,16 @@ class MainPageState extends State<MainPage> with WindowListener {
   final TextEditingController _currentEntryController = 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;
@@ -147,7 +154,6 @@ class MainPageState extends State<MainPage> with WindowListener {
     windowManager.addListener(this);
     _initSystemTray();
     _loadData();
-    _startPopupTimer();
     windowManager.setPreventClose(true);
     _setWindowConfig();
   }
@@ -161,6 +167,8 @@ class MainPageState extends State<MainPage> with WindowListener {
     _currentEntryController.dispose();
     _currentEntryFocusNode.dispose();
     _scratchController.dispose();
+    _intervalController.dispose();
+    _soundController.dispose();
     _audioPlayer.dispose();
     super.dispose();
   }
@@ -201,9 +209,11 @@ class MainPageState extends State<MainPage> with WindowListener {
   }
 
   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 {
@@ -224,19 +234,82 @@ class MainPageState extends State<MainPage> with WindowListener {
 
   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 scratch = await getLatestScratch();
     _scratchController.text = scratch?.content ?? "";
     _currentEntryController.text = "";
 
+    await _checkNavigation();
+
     debugPrint("Data loaded.");
   }
 
@@ -244,6 +317,8 @@ class MainPageState extends State<MainPage> with WindowListener {
     String previousEntry = _previousEntryController.text;
     String currentEntry = _currentEntryController.text;
     String scratchContent = _scratchController.text;
+    String intervalStr = _intervalController.text;
+    String soundStr = _soundController.text;
 
     await createNote(currentEntry);
     await createScratch(scratchContent);
@@ -252,6 +327,23 @@ class MainPageState extends State<MainPage> with WindowListener {
       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... Current Entry: [${currentEntry.length} chars], Scratch: [${scratchContent.length} chars]",
     );
@@ -278,7 +370,72 @@ class MainPageState extends State<MainPage> with WindowListener {
         }
       },
       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(
@@ -286,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,
                           ),
                         ),
                       ),
@@ -312,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: _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: 'Scratch',
-                    // border: OutlineInputBorder(), // Handled by theme
-                    // contentPadding: EdgeInsets.all(8.0), // Handled by theme or default
                   ),
                 ),
               ),

lib/notes.dart

@@ -61,3 +61,42 @@ Future<Scratch?> getLatestScratch() async {
 Future<void> createScratch(String content) async {
   await DB.db.insert('scratches', {'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();
+}