bouquin 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

bouquin/main_window.py

@@ -1,26 +1,37 @@
 from __future__ import annotations
 
+import os
 import sys
 
-from PySide6.QtCore import QDate, QTimer, Qt
-from PySide6.QtGui import QAction, QFont, QTextCharFormat
+from pathlib import Path
+from PySide6.QtCore import QDate, QTimer, Qt, QSettings, Slot, QUrl
+from PySide6.QtGui import (
+    QAction,
+    QCursor,
+    QDesktopServices,
+    QFont,
+    QGuiApplication,
+    QTextCharFormat,
+)
 from PySide6.QtWidgets import (
-    QDialog,
     QCalendarWidget,
+    QDialog,
+    QFileDialog,
     QMainWindow,
     QMessageBox,
-    QPlainTextEdit,
+    QSizePolicy,
     QSplitter,
     QVBoxLayout,
     QWidget,
-    QSizePolicy,
 )
 
 from .db import DBManager
-from .settings import APP_NAME, load_db_config, save_db_config
+from .editor import Editor
 from .key_prompt import KeyPrompt
-from .highlighter import MarkdownHighlighter
+from .search import Search
+from .settings import APP_ORG, APP_NAME, load_db_config, save_db_config
 from .settings_dialog import SettingsDialog
+from .toolbar import ToolBar
 
 
 class MainWindow(QMainWindow):
@@ -30,9 +41,18 @@ class MainWindow(QMainWindow):
         self.setMinimumSize(1000, 650)
 
         self.cfg = load_db_config()
-        # Always prompt for the key (we never store it)
-        if not self._prompt_for_key_until_valid():
-            sys.exit(1)
+        if not os.path.exists(self.cfg.path):
+            # Fresh database/first time use, so guide the user re: setting a key
+            first_time = True
+        else:
+            first_time = False
+
+        # Prompt for the key unless it is found in config
+        if not self.cfg.key:
+            if not self._prompt_for_key_until_valid(first_time):
+                sys.exit(1)
+        else:
+            self._try_connect()
 
         # ---- UI: Left fixed panel (calendar) + right editor -----------------
         self.calendar = QCalendarWidget()
@@ -40,17 +60,35 @@ class MainWindow(QMainWindow):
         self.calendar.setGridVisible(True)
         self.calendar.selectionChanged.connect(self._on_date_changed)
 
+        self.search = Search(self.db)
+        self.search.openDateRequested.connect(self._load_selected_date)
+
+        # Lock the calendar to the left panel at the top to stop it stretching
+        # when the main window is resized.
         left_panel = QWidget()
         left_layout = QVBoxLayout(left_panel)
         left_layout.setContentsMargins(8, 8, 8, 8)
         left_layout.addWidget(self.calendar, alignment=Qt.AlignTop)
+        left_layout.addWidget(self.search, alignment=Qt.AlignBottom)
         left_layout.addStretch(1)
         left_panel.setFixedWidth(self.calendar.sizeHint().width() + 16)
 
-        self.editor = QPlainTextEdit()
-        tab_w = 4 * self.editor.fontMetrics().horizontalAdvance(" ")
-        self.editor.setTabStopDistance(tab_w)
-        self.highlighter = MarkdownHighlighter(self.editor.document())
+        # This is the note-taking editor
+        self.editor = Editor()
+
+        # Toolbar for controlling styling
+        tb = ToolBar()
+        self.addToolBar(tb)
+        # Wire toolbar intents to editor methods
+        tb.boldRequested.connect(self.editor.apply_weight)
+        tb.italicRequested.connect(self.editor.apply_italic)
+        tb.underlineRequested.connect(self.editor.apply_underline)
+        tb.strikeRequested.connect(self.editor.apply_strikethrough)
+        tb.codeRequested.connect(self.editor.apply_code)
+        tb.headingRequested.connect(self.editor.apply_heading)
+        tb.bulletsRequested.connect(self.editor.toggle_bullets)
+        tb.numbersRequested.connect(self.editor.toggle_numbers)
+        tb.alignRequested.connect(self.editor.setAlignment)
 
         split = QSplitter()
         split.addWidget(left_panel)
@@ -72,17 +110,21 @@ class MainWindow(QMainWindow):
         act_save.setShortcut("Ctrl+S")
         act_save.triggered.connect(lambda: self._save_current(explicit=True))
         file_menu.addAction(act_save)
-        act_settings = QAction("S&ettings", self)
-        act_save.setShortcut("Ctrl+E")
+        act_settings = QAction("Settin&gs", self)
+        act_settings.setShortcut("Ctrl+G")
         act_settings.triggered.connect(self._open_settings)
         file_menu.addAction(act_settings)
+        act_export = QAction("&Export", self)
+        act_export.setShortcut("Ctrl+E")
+        act_export.triggered.connect(self._export)
+        file_menu.addAction(act_export)
         file_menu.addSeparator()
         act_quit = QAction("&Quit", self)
         act_quit.setShortcut("Ctrl+Q")
         act_quit.triggered.connect(self.close)
         file_menu.addAction(act_quit)
 
-        # Navigate menu with next/previous day
+        # Navigate menu with next/previous/today
         nav_menu = mb.addMenu("&Navigate")
         act_prev = QAction("Previous Day", self)
         act_prev.setShortcut("Ctrl+P")
@@ -105,6 +147,15 @@ class MainWindow(QMainWindow):
         nav_menu.addAction(act_today)
         self.addAction(act_today)
 
+        # Help menu with drop-down
+        help_menu = mb.addMenu("&Help")
+        act_docs = QAction("Documentation", self)
+        act_docs.setShortcut("Ctrl+D")
+        act_docs.setShortcutContext(Qt.ApplicationShortcut)
+        act_docs.triggered.connect(self._open_docs)
+        help_menu.addAction(act_docs)
+        self.addAction(act_docs)
+
         # Autosave
         self._dirty = False
         self._save_timer = QTimer(self)
@@ -112,12 +163,18 @@ class MainWindow(QMainWindow):
         self._save_timer.timeout.connect(self._save_current)
         self.editor.textChanged.connect(self._on_text_changed)
 
-        # First load + mark dates with content
+        # First load + mark dates in calendar with content
         self._load_selected_date()
         self._refresh_calendar_marks()
 
-    # --- DB lifecycle
+        # Restore window position from settings
+        self.settings = QSettings(APP_ORG, APP_NAME)
+        self._restore_window_position()
+
     def _try_connect(self) -> bool:
+        """
+        Try to connect to the database.
+        """
         try:
             self.db = DBManager(self.cfg)
             ok = self.db.connect()
@@ -130,17 +187,29 @@ class MainWindow(QMainWindow):
             return False
         return ok
 
-    def _prompt_for_key_until_valid(self) -> bool:
+    def _prompt_for_key_until_valid(self, first_time: bool) -> bool:
+        """
+        Prompt for the SQLCipher key.
+        """
+        if first_time:
+            title = "Set an encryption key"
+            message = "Bouquin encrypts your data.\n\nPlease create a strong passphrase to encrypt the notebook.\n\nYou can always change it later!"
+        else:
+            title = "Unlock encrypted notebook"
+            message = "Enter your key to unlock the notebook"
         while True:
-            dlg = KeyPrompt(self, message="Enter a key to unlock the notebook")
+            dlg = KeyPrompt(self, title, message)
             if dlg.exec() != QDialog.Accepted:
                 return False
             self.cfg.key = dlg.key()
             if self._try_connect():
                 return True
 
-    # --- Calendar marks to indicate text exists for htat day -----------------
     def _refresh_calendar_marks(self):
+        """
+        Sets a bold marker on the day to indicate that text exists
+        for that day.
+        """
         fmt_bold = QTextCharFormat()
         fmt_bold.setFontWeight(QFont.Weight.Bold)
         # Clear previous marks
@@ -161,19 +230,22 @@ class MainWindow(QMainWindow):
         d = self.calendar.selectedDate()
         return f"{d.year():04d}-{d.month():02d}-{d.day():02d}"
 
-    def _load_selected_date(self):
-        date_iso = self._current_date_iso()
+    def _load_selected_date(self, date_iso=False):
+        if not date_iso:
+            date_iso = self._current_date_iso()
         try:
             text = self.db.get_entry(date_iso)
         except Exception as e:
             QMessageBox.critical(self, "Read Error", str(e))
             return
         self.editor.blockSignals(True)
-        self.editor.setPlainText(text)
+        self.editor.setHtml(text)
         self.editor.blockSignals(False)
         self._dirty = False
         # track which date the editor currently represents
         self._active_date_iso = date_iso
+        qd = QDate.fromString(date_iso, "yyyy-MM-dd")
+        self.calendar.setSelectedDate(qd)
 
     def _on_text_changed(self):
         self._dirty = True
@@ -212,7 +284,7 @@ class MainWindow(QMainWindow):
         """
         if not self._dirty and not explicit:
             return
-        text = self.editor.toPlainText()
+        text = self.editor.toHtml()
         try:
             self.db.upsert_entry(date_iso, text)
         except Exception as e:
@@ -249,8 +321,97 @@ class MainWindow(QMainWindow):
                 self._load_selected_date()
                 self._refresh_calendar_marks()
 
-    def closeEvent(self, event):  # noqa: N802
+    def _restore_window_position(self):
+        geom = self.settings.value("main/geometry", None)
+        state = self.settings.value("main/windowState", None)
+        was_max = self.settings.value("main/maximized", False, type=bool)
+
+        if geom is not None:
+            self.restoreGeometry(geom)
+            if state is not None:
+                self.restoreState(state)
+            if not self._rect_on_any_screen(self.frameGeometry()):
+                self._move_to_cursor_screen_center()
+        else:
+            # First run: place window on the screen where the mouse cursor is.
+            self._move_to_cursor_screen_center()
+
+        # If it was maximized, do that AFTER the window exists in the event loop.
+        if was_max:
+            QTimer.singleShot(0, self.showMaximized)
+
+    def _rect_on_any_screen(self, rect):
+        for sc in QGuiApplication.screens():
+            if sc.availableGeometry().intersects(rect):
+                return True
+        return False
+
+    def _move_to_cursor_screen_center(self):
+        screen = (
+            QGuiApplication.screenAt(QCursor.pos()) or QGuiApplication.primaryScreen()
+        )
+        r = screen.availableGeometry()
+        # Center the window in that screen’s available area
+        self.move(r.center() - self.rect().center())
+
+    @Slot()
+    def _export(self):
+        try:
+            self.export_dialog()
+        except Exception as e:
+            QMessageBox.critical(self, "Export failed", str(e))
+
+    def export_dialog(self) -> None:
+        filters = "Text (*.txt);;" "JSON (*.json);;" "CSV (*.csv);;" "HTML (*.html);;"
+
+        start_dir = os.path.join(os.path.expanduser("~"), "Documents")
+        filename, selected_filter = QFileDialog.getSaveFileName(
+            self, "Export entries", start_dir, filters
+        )
+        if not filename:
+            return  # user cancelled
+
+        default_ext = {
+            "Text (*.txt)": ".txt",
+            "JSON (*.json)": ".json",
+            "CSV (*.csv)": ".csv",
+            "HTML (*.html)": ".html",
+        }.get(selected_filter, ".txt")
+
+        if not Path(filename).suffix:
+            filename += default_ext
+
+        try:
+            entries = self.db.get_all_entries()
+            if selected_filter.startswith("Text"):
+                self.db.export_txt(entries, filename)
+            elif selected_filter.startswith("JSON"):
+                self.db.export_json(entries, filename)
+            elif selected_filter.startswith("CSV"):
+                self.db.export_csv(entries, filename)
+            elif selected_filter.startswith("HTML"):
+                self.bd.export_html(entries, filename)
+            else:
+                self.bd.export_by_extension(entries, filename)
+
+            QMessageBox.information(self, "Export complete", f"Saved to:\n{filename}")
+        except Exception as e:
+            QMessageBox.critical(self, "Export failed", str(e))
+
+    def _open_docs(self):
+        url_str = "https://git.mig5.net/mig5/bouquin/wiki/Help"
+        url = QUrl.fromUserInput(url_str)
+        if not QDesktopServices.openUrl(url):
+            QMessageBox.warning(self, "Open Documentation",
+                                f"Couldn't open:\n{url.toDisplayString()}")
+
+    def closeEvent(self, event):
         try:
+            # Save window position
+            self.settings.setValue("main/geometry", self.saveGeometry())
+            self.settings.setValue("main/windowState", self.saveState())
+            self.settings.setValue("main/maximized", self.isMaximized())
+            # Ensure we save any last pending edits to the db
             self._save_current()
             self.db.close()
         except Exception:

bouquin/search.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import re
+from typing import Iterable, Tuple
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QFont, QTextCharFormat, QTextCursor, QTextDocument
+from PySide6.QtWidgets import (
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QHBoxLayout,
+    QVBoxLayout,
+    QWidget,
+)
+
+# type: rows are (date_iso, content)
+Row = Tuple[str, str]
+
+
+class Search(QWidget):
+    """Encapsulates the search UI + logic and emits a signal when a result is chosen."""
+
+    openDateRequested = Signal(str)
+
+    def __init__(self, db, parent: QWidget | None = None):
+        super().__init__(parent)
+        self._db = db
+
+        self.search = QLineEdit()
+        self.search.setPlaceholderText("Search for notes here")
+        self.search.textChanged.connect(self._search)
+
+        self.results = QListWidget()
+        self.results.setUniformItemSizes(False)
+        self.results.setSelectionMode(self.results.SelectionMode.SingleSelection)
+        self.results.itemClicked.connect(self._open_selected)
+        self.results.hide()
+
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(0, 0, 0, 0)
+        lay.setSpacing(6)
+        lay.addWidget(self.search)
+        lay.addWidget(self.results)
+
+    def _open_selected(self, item: QListWidgetItem):
+        date_str = item.data(Qt.ItemDataRole.UserRole)
+        if date_str:
+            self.openDateRequested.emit(date_str)
+
+    def _search(self, text: str):
+        """
+        Search for the supplied text in the database.
+        For all rows found, populate the results widget with a clickable preview.
+        """
+        q = text.strip()
+        if not q:
+            self.results.clear()
+            self.results.hide()
+            return
+
+        try:
+            rows: Iterable[Row] = self._db.search_entries(q)
+        except Exception:
+            # be quiet on DB errors here; caller can surface if desired
+            rows = []
+
+        self._populate_results(q, rows)
+
+    def _populate_results(self, query: str, rows: Iterable[Row]):
+        self.results.clear()
+        rows = list(rows)
+        if not rows:
+            self.results.hide()
+            return
+
+        self.results.show()
+
+        for date_str, content in rows:
+            # Build an HTML fragment around the match and whether to show ellipses
+            frag_html, left_ell, right_ell = self._make_html_snippet(
+                content, query, radius=30, maxlen=90
+            )
+
+            # ---- Per-item widget: date on top, preview row below (with ellipses) ----
+            container = QWidget()
+            outer = QVBoxLayout(container)
+            outer.setContentsMargins(8, 6, 8, 6)
+            outer.setSpacing(2)
+
+            # Date label (plain text)
+            date_lbl = QLabel(date_str)
+            date_lbl.setTextFormat(Qt.TextFormat.PlainText)
+            date_f = date_lbl.font()
+            date_f.setPointSizeF(date_f.pointSizeF() - 1)
+            date_lbl.setFont(date_f)
+            date_lbl.setStyleSheet("color:#666;")
+            outer.addWidget(date_lbl)
+
+            # Preview row with optional ellipses
+            row = QWidget()
+            h = QHBoxLayout(row)
+            h.setContentsMargins(0, 0, 0, 0)
+            h.setSpacing(4)
+
+            if left_ell:
+                left = QLabel("…")
+                left.setStyleSheet("color:#888;")
+                h.addWidget(left, 0, Qt.AlignmentFlag.AlignTop)
+
+            preview = QLabel()
+            preview.setTextFormat(Qt.TextFormat.RichText)
+            preview.setWordWrap(True)
+            preview.setOpenExternalLinks(True)
+            preview.setText(
+                frag_html
+                if frag_html
+                else "<span style='color:#888'>(no preview)</span>"
+            )
+            h.addWidget(preview, 1)
+
+            if right_ell:
+                right = QLabel("…")
+                right.setStyleSheet("color:#888;")
+                h.addWidget(right, 0, Qt.AlignmentFlag.AlignBottom)
+
+            outer.addWidget(row)
+
+            # ---- Add to list ----
+            item = QListWidgetItem()
+            item.setData(Qt.ItemDataRole.UserRole, date_str)
+            item.setSizeHint(container.sizeHint())
+
+            self.results.addItem(item)
+            self.results.setItemWidget(item, container)
+
+    # --- Snippet/highlight helpers -----------------------------------------
+    def _make_html_snippet(self, html_src: str, query: str, *, radius=60, maxlen=180):
+        doc = QTextDocument()
+        doc.setHtml(html_src)
+        plain = doc.toPlainText()
+        if not plain:
+            return "", False, False
+
+        tokens = [t for t in re.split(r"\s+", query.strip()) if t]
+        L = len(plain)
+
+        # Find first occurrence (phrase first, then earliest token)
+        idx, mlen = -1, 0
+        if tokens:
+            lower = plain.lower()
+            phrase = " ".join(tokens).lower()
+            j = lower.find(phrase)
+            if j >= 0:
+                idx, mlen = j, len(phrase)
+            else:
+                for t in tokens:
+                    tj = lower.find(t.lower())
+                    if tj >= 0 and (idx < 0 or tj < idx):
+                        idx, mlen = tj, len(t)
+        # Compute window
+        if idx < 0:
+            start, end = 0, min(L, maxlen)
+        else:
+            start = max(0, min(idx - radius, max(0, L - maxlen)))
+            end = min(L, max(idx + mlen + radius, start + maxlen))
+
+        # Bold all token matches that fall inside [start, end)
+        if tokens:
+            lower = plain.lower()
+            fmt = QTextCharFormat()
+            fmt.setFontWeight(QFont.Weight.Bold)
+            for t in tokens:
+                t_low = t.lower()
+                pos = start
+                while True:
+                    k = lower.find(t_low, pos)
+                    if k == -1 or k >= end:
+                        break
+                    c = QTextCursor(doc)
+                    c.setPosition(k)
+                    c.setPosition(k + len(t), QTextCursor.MoveMode.KeepAnchor)
+                    c.mergeCharFormat(fmt)
+                    pos = k + len(t)
+
+        # Select the window and export as HTML fragment
+        c = QTextCursor(doc)
+        c.setPosition(start)
+        c.setPosition(end, QTextCursor.MoveMode.KeepAnchor)
+        fragment_html = (
+            c.selection().toHtml()
+        )  # preserves original styles + our bolding
+
+        return fragment_html, start > 0, end < L

bouquin/settings.py

@@ -21,9 +21,11 @@ def get_settings() -> QSettings:
 def load_db_config() -> DBConfig:
     s = get_settings()
     path = Path(s.value("db/path", str(default_db_path())))
-    return DBConfig(path=path, key="")
+    key = s.value("db/key", "")
+    return DBConfig(path=path, key=key)
 
 
 def save_db_config(cfg: DBConfig) -> None:
     s = get_settings()
     s.setValue("db/path", str(cfg.path))
+    s.setValue("db/key", str(cfg.key))

bouquin/settings_dialog.py

@@ -3,8 +3,12 @@ from __future__ import annotations
 from pathlib import Path
 
 from PySide6.QtWidgets import (
+    QCheckBox,
     QDialog,
     QFormLayout,
+    QFrame,
+    QGroupBox,
+    QLabel,
     QHBoxLayout,
     QVBoxLayout,
     QWidget,
@@ -15,9 +19,12 @@ from PySide6.QtWidgets import (
     QSizePolicy,
     QMessageBox,
 )
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtGui import QPalette
+
 
 from .db import DBConfig, DBManager
-from .settings import save_db_config
+from .settings import load_db_config, save_db_config
 from .key_prompt import KeyPrompt
 
 
@@ -27,10 +34,11 @@ class SettingsDialog(QDialog):
         self.setWindowTitle("Settings")
         self._cfg = DBConfig(path=cfg.path, key="")
         self._db = db
+        self.key = ""
 
         form = QFormLayout()
         form.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
-        self.setMinimumWidth(520)
+        self.setMinimumWidth(560)
         self.setSizeGripEnabled(True)
 
         self.path_edit = QLineEdit(str(self._cfg.path))
@@ -47,18 +55,65 @@ class SettingsDialog(QDialog):
         h.setStretch(1, 0)
         form.addRow("Database path", path_row)
 
+        # Encryption settings
+        enc_group = QGroupBox("Encryption")
+        enc = QVBoxLayout(enc_group)
+        enc.setContentsMargins(12, 8, 12, 12)
+        enc.setSpacing(6)
+
+        # Checkbox to remember key
+        self.save_key_btn = QCheckBox("Remember key")
+        current_settings = load_db_config()
+        if current_settings.key:
+            self.save_key_btn.setChecked(True)
+        else:
+            self.save_key_btn.setChecked(False)
+        self.save_key_btn.setCursor(Qt.PointingHandCursor)
+        self.save_key_btn.toggled.connect(self.save_key_btn_clicked)
+        enc.addWidget(self.save_key_btn, 0, Qt.AlignLeft)
+
+        # Explanation for remembering key
+        self.save_key_label = QLabel(
+            "If you don't want to be prompted for your encryption key, check this to remember it. "
+            "WARNING: the key is saved to disk and could be recoverable if your disk is compromised."
+        )
+        self.save_key_label.setWordWrap(True)
+        self.save_key_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        # make it look secondary
+        pal = self.save_key_label.palette()
+        pal.setColor(self.save_key_label.foregroundRole(), pal.color(QPalette.Mid))
+        self.save_key_label.setPalette(pal)
+
+        exp_row = QHBoxLayout()
+        exp_row.setContentsMargins(24, 0, 0, 0)  # indent to line up under the checkbox
+        exp_row.addWidget(self.save_key_label)
+        enc.addLayout(exp_row)
+
+        line = QFrame()
+        line.setFrameShape(QFrame.HLine)
+        line.setFrameShadow(QFrame.Sunken)
+        enc.addWidget(line)
+
         # Change key button
         self.rekey_btn = QPushButton("Change key")
+        self.rekey_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
         self.rekey_btn.clicked.connect(self._change_key)
+        enc.addWidget(self.rekey_btn, 0, Qt.AlignLeft)
+
+        # Put the group into the form so it spans the full width nicely
+        form.addRow(enc_group)
 
+        # Buttons
         bb = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Cancel)
         bb.accepted.connect(self._save)
         bb.rejected.connect(self.reject)
 
+        # Root layout (adjust margins/spacing a bit)
         v = QVBoxLayout(self)
+        v.setContentsMargins(12, 12, 12, 12)
+        v.setSpacing(10)
         v.addLayout(form)
-        v.addWidget(self.rekey_btn)
-        v.addWidget(bb)
+        v.addWidget(bb, 0, Qt.AlignRight)
 
     def _browse(self):
         p, _ = QFileDialog.getSaveFileName(
@@ -71,16 +126,16 @@ class SettingsDialog(QDialog):
             self.path_edit.setText(p)
 
     def _save(self):
-        self._cfg = DBConfig(path=Path(self.path_edit.text()), key="")
+        self._cfg = DBConfig(path=Path(self.path_edit.text()), key=self.key)
         save_db_config(self._cfg)
         self.accept()
 
     def _change_key(self):
-        p1 = KeyPrompt(self, title="Change key", message="Enter new key")
+        p1 = KeyPrompt(self, title="Change key", message="Enter a new encryption key")
         if p1.exec() != QDialog.Accepted:
             return
         new_key = p1.key()
-        p2 = KeyPrompt(self, title="Change key", message="Re-enter new key")
+        p2 = KeyPrompt(self, title="Change key", message="Re-enter the new key")
         if p2.exec() != QDialog.Accepted:
             return
         if new_key != p2.key():
@@ -91,10 +146,24 @@ class SettingsDialog(QDialog):
             return
         try:
             self._db.rekey(new_key)
-            QMessageBox.information(self, "Key changed", "The database key was updated.")
+            QMessageBox.information(
+                self, "Key changed", "The notebook was re-encrypted with the new key!"
+            )
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Could not change key:\n{e}")
 
+    @Slot(bool)
+    def save_key_btn_clicked(self, checked: bool):
+        if checked:
+            p1 = KeyPrompt(
+                self, title="Enter your key", message="Enter the encryption key"
+            )
+            if p1.exec() != QDialog.Accepted:
+                return
+            self.key = p1.key()
+        self._cfg = DBConfig(path=Path(self.path_edit.text()), key=self.key)
+        save_db_config(self._cfg)
+
     @property
     def config(self) -> DBConfig:
         return self._cfg