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

bouquin/db.py

@@ -17,6 +17,7 @@ Entry = Tuple[str, str]
 class DBConfig:
     path: Path
     key: str
+    idle_minutes: int = 15  # 0 = never lock
 
 
 class DBManager:
@@ -25,14 +26,17 @@ class DBManager:
         self.conn: sqlite.Connection | None = None
 
     def connect(self) -> bool:
+        """
+        Open, decrypt and install schema on the database.
+        """
         # Ensure parent dir exists
         self.cfg.path.parent.mkdir(parents=True, exist_ok=True)
         self.conn = sqlite.connect(str(self.cfg.path))
         self.conn.row_factory = sqlite.Row
         cur = self.conn.cursor()
         cur.execute(f"PRAGMA key = '{self.cfg.key}';")
-        cur.execute("PRAGMA journal_mode = WAL;")
-        self.conn.commit()
+        cur.execute("PRAGMA foreign_keys = ON;")
+        cur.execute("PRAGMA journal_mode = WAL;").fetchone()
         try:
             self._integrity_ok()
         except Exception:
@@ -43,15 +47,18 @@ class DBManager:
         return True
 
     def _integrity_ok(self) -> bool:
+        """
+        Runs the cipher_integrity_check PRAGMA on the database.
+        """
         cur = self.conn.cursor()
         cur.execute("PRAGMA cipher_integrity_check;")
         rows = cur.fetchall()
 
-        # OK
+        # OK: nothing returned
         if not rows:
             return
 
-        # Not OK
+        # Not OK: rows of problems returned
         details = "; ".join(str(r[0]) for r in rows if r and r[0] is not None)
         raise sqlite.IntegrityError(
             "SQLCipher integrity check failed"
@@ -59,16 +66,62 @@ class DBManager:
         )
 
     def _ensure_schema(self) -> None:
+        """
+        Install the expected schema on the database.
+        We also handle upgrades here.
+        """
         cur = self.conn.cursor()
-        cur.execute(
+        # Always keep FKs on
+        cur.execute("PRAGMA foreign_keys = ON;")
+
+        # Create new versioned schema if missing (< 0.1.5)
+        cur.executescript(
             """
-            CREATE TABLE IF NOT EXISTS entries (
-                date TEXT PRIMARY KEY, -- ISO yyyy-MM-dd
-                content TEXT NOT NULL
+            CREATE TABLE IF NOT EXISTS pages (
+                date TEXT PRIMARY KEY,                 -- yyyy-MM-dd
+                current_version_id INTEGER,
+                FOREIGN KEY(current_version_id) REFERENCES versions(id) ON DELETE SET NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS versions (
+                id INTEGER PRIMARY KEY,
+                date TEXT NOT NULL,                    -- FK to pages.date
+                version_no INTEGER NOT NULL,           -- 1,2,3… per date
+                created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+                note   TEXT,
+                content TEXT NOT NULL,
+                FOREIGN KEY(date) REFERENCES pages(date) ON DELETE CASCADE
             );
+
+            CREATE UNIQUE INDEX IF NOT EXISTS ux_versions_date_ver ON versions(date, version_no);
+            CREATE INDEX IF NOT EXISTS ix_versions_date_created ON versions(date, created_at);
             """
         )
-        cur.execute("PRAGMA user_version = 1;")
+
+        # If < 0.1.5 'entries' table exists and nothing has been migrated yet, try to migrate.
+        pre_0_1_5 = cur.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='entries';"
+        ).fetchone()
+        pages_empty = cur.execute("SELECT 1 FROM pages LIMIT 1;").fetchone() is None
+
+        if pre_0_1_5 and pages_empty:
+            # Seed pages and versions (all as version 1)
+            cur.execute("INSERT OR IGNORE INTO pages(date) SELECT date FROM entries;")
+            cur.execute(
+                "INSERT INTO versions(date, version_no, content) "
+                "SELECT date, 1, content FROM entries;"
+            )
+            # Point head to v1 for each page
+            cur.execute(
+                """
+                UPDATE pages
+                SET current_version_id = (
+                    SELECT v.id FROM versions v
+                    WHERE v.date = pages.date AND v.version_no = 1
+                );
+                """
+            )
+            cur.execute("DROP TABLE IF EXISTS entries;")
         self.conn.commit()
 
     def rekey(self, new_key: str) -> None:
@@ -91,42 +144,214 @@ class DBManager:
             raise sqlite.Error("Re-open failed after rekey")
 
     def get_entry(self, date_iso: str) -> str:
+        """
+        Get a single entry by its date.
+        """
         cur = self.conn.cursor()
-        cur.execute("SELECT content FROM entries WHERE date = ?;", (date_iso,))
-        row = cur.fetchone()
+        row = cur.execute(
+            """
+            SELECT v.content
+            FROM pages p
+            JOIN versions v ON v.id = p.current_version_id
+            WHERE p.date = ?;
+            """,
+            (date_iso,),
+        ).fetchone()
         return row[0] if row else ""
 
     def upsert_entry(self, date_iso: str, content: str) -> None:
-        cur = self.conn.cursor()
-        cur.execute(
-            """
-            INSERT INTO entries(date, content) VALUES(?, ?)
-            ON CONFLICT(date) DO UPDATE SET content = excluded.content;
-            """,
-            (date_iso, content),
-        )
-        self.conn.commit()
+        """
+        Insert or update an entry.
+        """
+        # Make a new version and set it as current
+        self.save_new_version(date_iso, content, note=None, set_current=True)
 
     def search_entries(self, text: str) -> list[str]:
+        """
+        Search for entries by term. This only works against the latest
+        version of the page.
+        """
         cur = self.conn.cursor()
         pattern = f"%{text}%"
-        return cur.execute(
-            "SELECT * FROM entries WHERE TRIM(content) LIKE ?", (pattern,)
+        rows = cur.execute(
+            """
+            SELECT p.date, v.content
+            FROM pages AS p
+            JOIN versions AS v
+              ON v.id = p.current_version_id
+            WHERE TRIM(v.content) <> ''
+              AND v.content LIKE LOWER(?) ESCAPE '\\'
+            ORDER BY p.date DESC;
+            """,
+            (pattern,),
         ).fetchall()
+        return [(r[0], r[1]) for r in rows]
 
     def dates_with_content(self) -> list[str]:
+        """
+        Find all entries and return the dates of them.
+        This is used to mark the calendar days in bold if they contain entries.
+        """
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            """
+            SELECT p.date
+            FROM pages p
+            JOIN versions v ON v.id = p.current_version_id
+            WHERE TRIM(v.content) <> ''
+            ORDER BY p.date;
+            """
+        ).fetchall()
+        return [r[0] for r in rows]
+
+    # ------------------------- Versioning logic here ------------------------#
+    def save_new_version(
+        self,
+        date_iso: str,
+        content: str,
+        note: str | None = None,
+        set_current: bool = True,
+    ) -> tuple[int, int]:
+        """
+        Append a new version for this date. Returns (version_id, version_no).
+        If set_current=True, flips the page head to this new version.
+        """
+        if self.conn is None:
+            raise RuntimeError("Database is not connected")
+        with self.conn:  # transaction
+            cur = self.conn.cursor()
+            # Ensure page row exists
+            cur.execute("INSERT OR IGNORE INTO pages(date) VALUES (?);", (date_iso,))
+            # Next version number
+            row = cur.execute(
+                "SELECT COALESCE(MAX(version_no), 0) AS maxv FROM versions WHERE date=?;",
+                (date_iso,),
+            ).fetchone()
+            next_ver = int(row["maxv"]) + 1
+            # Insert the version
+            cur.execute(
+                "INSERT INTO versions(date, version_no, content, note) "
+                "VALUES (?,?,?,?);",
+                (date_iso, next_ver, content, note),
+            )
+            ver_id = cur.lastrowid
+            if set_current:
+                cur.execute(
+                    "UPDATE pages SET current_version_id=? WHERE date=?;",
+                    (ver_id, date_iso),
+                )
+            return ver_id, next_ver
+
+    def list_versions(self, date_iso: str) -> list[dict]:
+        """
+        Returns history for a given date (newest first), including which one is current.
+        Each item: {id, version_no, created_at, note, is_current}
+        """
         cur = self.conn.cursor()
-        cur.execute("SELECT date FROM entries WHERE TRIM(content) <> '';")
-        return [r[0] for r in cur.fetchall()]
+        rows = cur.execute(
+            """
+            SELECT v.id, v.version_no, v.created_at, v.note,
+                   CASE WHEN v.id = p.current_version_id THEN 1 ELSE 0 END AS is_current
+            FROM versions v
+            LEFT JOIN pages p ON p.date = v.date
+            WHERE v.date = ?
+            ORDER BY v.version_no DESC;
+            """,
+            (date_iso,),
+        ).fetchall()
+        return [dict(r) for r in rows]
 
+    def get_version(
+        self,
+        *,
+        date_iso: str | None = None,
+        version_no: int | None = None,
+        version_id: int | None = None,
+    ) -> dict | None:
+        """
+        Fetch a specific version by (date, version_no) OR by version_id.
+        Returns a dict with keys: id, date, version_no, created_at, note, content.
+        """
+        cur = self.conn.cursor()
+        if version_id is not None:
+            row = cur.execute(
+                "SELECT id, date, version_no, created_at, note, content "
+                "FROM versions WHERE id=?;",
+                (version_id,),
+            ).fetchone()
+        else:
+            if date_iso is None or version_no is None:
+                raise ValueError(
+                    "Provide either version_id OR (date_iso and version_no)"
+                )
+            row = cur.execute(
+                "SELECT id, date, version_no, created_at, note, content "
+                "FROM versions WHERE date=? AND version_no=?;",
+                (date_iso, version_no),
+            ).fetchone()
+        return dict(row) if row else None
+
+    def revert_to_version(
+        self,
+        date_iso: str,
+        *,
+        version_no: int | None = None,
+        version_id: int | None = None,
+    ) -> None:
+        """
+        Point the page head (pages.current_version_id) to an existing version.
+        Fast revert: no content is rewritten.
+        """
+        if self.conn is None:
+            raise RuntimeError("Database is not connected")
+        cur = self.conn.cursor()
+
+        if version_id is None:
+            if version_no is None:
+                raise ValueError("Provide version_no or version_id")
+            row = cur.execute(
+                "SELECT id FROM versions WHERE date=? AND version_no=?;",
+                (date_iso, version_no),
+            ).fetchone()
+            if row is None:
+                raise ValueError("Version not found for this date")
+            version_id = int(row["id"])
+        else:
+            # Ensure that version_id belongs to the given date
+            row = cur.execute(
+                "SELECT date FROM versions WHERE id=?;", (version_id,)
+            ).fetchone()
+            if row is None or row["date"] != date_iso:
+                raise ValueError("version_id does not belong to the given date")
+
+        with self.conn:
+            cur.execute(
+                "UPDATE pages SET current_version_id=? WHERE date=?;",
+                (version_id, date_iso),
+            )
+
+    # ------------------------- Export logic here ------------------------#
     def get_all_entries(self) -> List[Entry]:
+        """
+        Get all entries. Used for exports.
+        """
         cur = self.conn.cursor()
-        rows = cur.execute("SELECT date, content FROM entries ORDER BY date").fetchall()
-        return [(row["date"], row["content"]) for row in rows]
+        rows = cur.execute(
+            """
+            SELECT p.date, v.content
+            FROM pages p
+            JOIN versions v ON v.id = p.current_version_id
+            ORDER BY p.date;
+            """
+        ).fetchall()
+        return [(r[0], r[1]) for r in rows]
 
     def export_json(
         self, entries: Sequence[Entry], file_path: str, pretty: bool = True
     ) -> None:
+        """
+        Export to json.
+        """
         data = [{"date": d, "content": c} for d, c in entries]
         with open(file_path, "w", encoding="utf-8") as f:
             if pretty:

bouquin/history_dialog.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import difflib, re, html as _html
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QListWidget,
+    QListWidgetItem,
+    QPushButton,
+    QMessageBox,
+    QTextBrowser,
+    QTabWidget,
+)
+
+
+def _html_to_text(s: str) -> str:
+    """Lightweight HTML→text for diff (keeps paragraphs/line breaks)."""
+    STYLE_SCRIPT_RE = re.compile(r"(?is)<(script|style)[^>]*>.*?</\1>")
+    COMMENT_RE = re.compile(r"<!--.*?-->", re.S)
+    BR_RE = re.compile(r"(?i)<br\s*/?>")
+    BLOCK_END_RE = re.compile(r"(?i)</(p|div|section|article|li|h[1-6])\s*>")
+    TAG_RE = re.compile(r"<[^>]+>")
+    MULTINL_RE = re.compile(r"\n{3,}")
+
+    s = STYLE_SCRIPT_RE.sub("", s)
+    s = COMMENT_RE.sub("", s)
+    s = BR_RE.sub("\n", s)
+    s = BLOCK_END_RE.sub("\n", s)
+    s = TAG_RE.sub("", s)
+    s = _html.unescape(s)
+    s = MULTINL_RE.sub("\n\n", s)
+    return s.strip()
+
+
+def _colored_unified_diff_html(old_html: str, new_html: str) -> str:
+    """Return HTML with colored unified diff (+ green, - red, context gray)."""
+    a = _html_to_text(old_html).splitlines()
+    b = _html_to_text(new_html).splitlines()
+    ud = difflib.unified_diff(a, b, fromfile="current", tofile="selected", lineterm="")
+    lines = []
+    for line in ud:
+        if line.startswith("+") and not line.startswith("+++"):
+            lines.append(
+                f"<span style='color:#116329'>+ {_html.escape(line[1:])}</span>"
+            )
+        elif line.startswith("-") and not line.startswith("---"):
+            lines.append(
+                f"<span style='color:#b31d28'>- {_html.escape(line[1:])}</span>"
+            )
+        elif line.startswith("@@"):
+            lines.append(f"<span style='color:#6f42c1'>{_html.escape(line)}</span>")
+        else:
+            lines.append(f"<span style='color:#586069'>{_html.escape(line)}</span>")
+    css = "pre { font-family: Consolas,Menlo,Monaco,monospace; font-size: 13px; }"
+    return f"<style>{css}</style><pre>{'<br>'.join(lines)}</pre>"
+
+
+class HistoryDialog(QDialog):
+    """Show versions for a date, preview, diff, and allow revert."""
+
+    def __init__(self, db, date_iso: str, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(f"History — {date_iso}")
+        self._db = db
+        self._date = date_iso
+        self._versions = []  # list[dict] from DB
+        self._current_id = None  # id of current
+
+        root = QVBoxLayout(self)
+
+        # Top: list of versions
+        top = QHBoxLayout()
+        self.list = QListWidget()
+        self.list.setMinimumSize(500, 650)
+        self.list.currentItemChanged.connect(self._on_select)
+        top.addWidget(self.list, 1)
+
+        # Right: tabs (Preview / Diff vs current)
+        self.tabs = QTabWidget()
+        self.preview = QTextBrowser()
+        self.preview.setOpenExternalLinks(True)
+        self.diff = QTextBrowser()
+        self.diff.setOpenExternalLinks(False)
+        self.tabs.addTab(self.preview, "Preview")
+        self.tabs.addTab(self.diff, "Diff vs current")
+        self.tabs.setMinimumSize(500, 650)
+        top.addWidget(self.tabs, 2)
+
+        root.addLayout(top)
+
+        # Buttons
+        row = QHBoxLayout()
+        row.addStretch(1)
+        self.btn_revert = QPushButton("Revert to Selected")
+        self.btn_revert.clicked.connect(self._revert)
+        self.btn_close = QPushButton("Close")
+        self.btn_close.clicked.connect(self.reject)
+        row.addWidget(self.btn_revert)
+        row.addWidget(self.btn_close)
+        root.addLayout(row)
+
+        self._load_versions()
+
+    # --- Data/UX helpers ---
+    def _load_versions(self):
+        self._versions = self._db.list_versions(
+            self._date
+        )  # [{id,version_no,created_at,note,is_current}]
+        self._current_id = next(
+            (v["id"] for v in self._versions if v["is_current"]), None
+        )
+        self.list.clear()
+        for v in self._versions:
+            label = f"v{v['version_no']} — {v['created_at']}"
+            if v.get("note"):
+                label += f"  ·  {v['note']}"
+            if v["is_current"]:
+                label += "  **(current)**"
+            it = QListWidgetItem(label)
+            it.setData(Qt.UserRole, v["id"])
+            self.list.addItem(it)
+        # select the first non-current if available, else current
+        idx = 0
+        for i, v in enumerate(self._versions):
+            if not v["is_current"]:
+                idx = i
+                break
+        if self.list.count():
+            self.list.setCurrentRow(idx)
+
+    @Slot()
+    def _on_select(self):
+        item = self.list.currentItem()
+        if not item:
+            self.preview.clear()
+            self.diff.clear()
+            self.btn_revert.setEnabled(False)
+            return
+        sel_id = item.data(Qt.UserRole)
+        # Preview selected as HTML
+        sel = self._db.get_version(version_id=sel_id)
+        self.preview.setHtml(sel["content"])
+        # Diff vs current (textual diff)
+        cur = self._db.get_version(version_id=self._current_id)
+        self.diff.setHtml(_colored_unified_diff_html(cur["content"], sel["content"]))
+        # Enable revert only if selecting a non-current
+        self.btn_revert.setEnabled(sel_id != self._current_id)
+
+    @Slot()
+    def _revert(self):
+        item = self.list.currentItem()
+        if not item:
+            return
+        sel_id = item.data(Qt.UserRole)
+        if sel_id == self._current_id:
+            return
+        sel = self._db.get_version(version_id=sel_id)
+        vno = sel["version_no"]
+        # Confirm
+        if (
+            QMessageBox.question(
+                self,
+                "Revert",
+                f"Revert {self._date} to version v{vno}?\n\nYou can always change your mind later.",
+                QMessageBox.Yes | QMessageBox.No,
+            )
+            != QMessageBox.Yes
+        ):
+            return
+        # Flip head pointer
+        try:
+            self._db.revert_to_version(self._date, version_id=sel_id)
+        except Exception as e:
+            QMessageBox.critical(self, "Revert failed", str(e))
+            return
+        QMessageBox.information(self, "Reverted", f"{self._date} is now at v{vno}.")
+        self.accept()  # let the caller refresh the editor

bouquin/main_window.py

@@ -4,7 +4,7 @@ import os
 import sys
 
 from pathlib import Path
-from PySide6.QtCore import QDate, QTimer, Qt, QSettings, Slot, QUrl
+from PySide6.QtCore import QDate, QTimer, Qt, QSettings, Slot, QUrl, QEvent
 from PySide6.QtGui import (
     QAction,
     QCursor,
@@ -17,8 +17,10 @@ from PySide6.QtWidgets import (
     QCalendarWidget,
     QDialog,
     QFileDialog,
+    QLabel,
     QMainWindow,
     QMessageBox,
+    QPushButton,
     QSizePolicy,
     QSplitter,
     QVBoxLayout,
@@ -27,13 +29,70 @@ from PySide6.QtWidgets import (
 
 from .db import DBManager
 from .editor import Editor
+from .history_dialog import HistoryDialog
 from .key_prompt import KeyPrompt
+from .save_dialog import SaveDialog
 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 _LockOverlay(QWidget):
+    def __init__(self, parent: QWidget, on_unlock: callable):
+        super().__init__(parent)
+        self.setObjectName("LockOverlay")
+        self.setAttribute(Qt.WA_StyledBackground, True)
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.setGeometry(parent.rect())
+
+        self.setStyleSheet(
+            """
+#LockOverlay { background-color: #ccc; }
+#LockOverlay QLabel { color: #fff; font-size: 18px; }
+#LockOverlay QPushButton {
+    background-color: #f2f2f2;
+    color: #000;
+    padding: 6px 14px;
+    border: 1px solid #808080;
+    border-radius: 6px;
+    font-size: 14px;
+}
+#LockOverlay QPushButton:hover   { background-color: #ffffff; }
+#LockOverlay QPushButton:pressed { background-color: #e6e6e6; }
+"""
+        )
+
+        lay = QVBoxLayout(self)
+        lay.addStretch(1)
+
+        msg = QLabel("Locked due to inactivity")
+        msg.setAlignment(Qt.AlignCenter)
+
+        self._btn = QPushButton("Unlock")
+        self._btn.setFixedWidth(200)
+        self._btn.setCursor(Qt.PointingHandCursor)
+        self._btn.setAutoDefault(True)
+        self._btn.setDefault(True)
+        self._btn.clicked.connect(on_unlock)
+
+        lay.addWidget(msg, 0, Qt.AlignCenter)
+        lay.addWidget(self._btn, 0, Qt.AlignCenter)
+        lay.addStretch(1)
+
+        self.hide()  # start hidden
+
+    # keep overlay sized with its parent
+    def eventFilter(self, obj, event):
+        if obj is self.parent() and event.type() in (QEvent.Resize, QEvent.Show):
+            self.setGeometry(obj.rect())
+        return False
+
+    def showEvent(self, e):
+        super().showEvent(e)
+        self._btn.setFocus()
+
+
 class MainWindow(QMainWindow):
     def __init__(self):
         super().__init__()
@@ -77,18 +136,19 @@ class MainWindow(QMainWindow):
         self.editor = Editor()
 
         # Toolbar for controlling styling
-        tb = ToolBar()
-        self.addToolBar(tb)
+        self.toolBar = ToolBar()
+        self.addToolBar(self.toolBar)
         # 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)
+        self.toolBar.boldRequested.connect(self.editor.apply_weight)
+        self.toolBar.italicRequested.connect(self.editor.apply_italic)
+        self.toolBar.underlineRequested.connect(self.editor.apply_underline)
+        self.toolBar.strikeRequested.connect(self.editor.apply_strikethrough)
+        self.toolBar.codeRequested.connect(self.editor.apply_code)
+        self.toolBar.headingRequested.connect(self.editor.apply_heading)
+        self.toolBar.bulletsRequested.connect(self.editor.toggle_bullets)
+        self.toolBar.numbersRequested.connect(self.editor.toggle_numbers)
+        self.toolBar.alignRequested.connect(self.editor.setAlignment)
+        self.toolBar.historyRequested.connect(self._open_history)
 
         split = QSplitter()
         split.addWidget(left_panel)
@@ -100,16 +160,39 @@ class MainWindow(QMainWindow):
         lay.addWidget(split)
         self.setCentralWidget(container)
 
+        # Idle lock setup
+        self._idle_timer = QTimer(self)
+        self._idle_timer.setSingleShot(True)
+        self._idle_timer.timeout.connect(self._enter_lock)
+        self._apply_idle_minutes(getattr(self.cfg, "idle_minutes", 15))
+        self._idle_timer.start()
+
+        # full-window overlay that sits on top of the central widget
+        self._lock_overlay = _LockOverlay(self.centralWidget(), self._on_unlock_clicked)
+        self.centralWidget().installEventFilter(self._lock_overlay)
+
+        self._locked = False
+
+        # reset idle timer on any key press anywhere in the app
+        from PySide6.QtWidgets import QApplication
+
+        QApplication.instance().installEventFilter(self)
+
         # Status bar for feedback
         self.statusBar().showMessage("Ready", 800)
 
         # Menu bar (File)
         mb = self.menuBar()
         file_menu = mb.addMenu("&File")
-        act_save = QAction("&Save", self)
+        act_save = QAction("&Save a version", self)
         act_save.setShortcut("Ctrl+S")
         act_save.triggered.connect(lambda: self._save_current(explicit=True))
         file_menu.addAction(act_save)
+        act_history = QAction("History", self)
+        act_history.setShortcut("Ctrl+H")
+        act_history.setShortcutContext(Qt.ApplicationShortcut)
+        act_history.triggered.connect(self._open_history)
+        file_menu.addAction(act_history)
         act_settings = QAction("Settin&gs", self)
         act_settings.setShortcut("Ctrl+G")
         act_settings.triggered.connect(self._open_settings)
@@ -155,6 +238,12 @@ class MainWindow(QMainWindow):
         act_docs.triggered.connect(self._open_docs)
         help_menu.addAction(act_docs)
         self.addAction(act_docs)
+        act_bugs = QAction("Report a bug", self)
+        act_bugs.setShortcut("Ctrl+R")
+        act_bugs.setShortcutContext(Qt.ApplicationShortcut)
+        act_bugs.triggered.connect(self._open_bugs)
+        help_menu.addAction(act_bugs)
+        self.addAction(act_bugs)
 
         # Autosave
         self._dirty = False
@@ -249,7 +338,7 @@ class MainWindow(QMainWindow):
 
     def _on_text_changed(self):
         self._dirty = True
-        self._save_timer.start(1200)  # autosave after idle
+        self._save_timer.start(10000)  # autosave after idle
 
     def _adjust_day(self, delta: int):
         """Move selection by delta days (negative for previous)."""
@@ -277,7 +366,7 @@ class MainWindow(QMainWindow):
         # Now load the newly selected date
         self._load_selected_date()
 
-    def _save_date(self, date_iso: str, explicit: bool = False):
+    def _save_date(self, date_iso: str, explicit: bool = False, note: str = "autosave"):
         """
         Save editor contents into the given date. Shows status on success.
         explicit=True means user invoked Save: show feedback even if nothing changed.
@@ -286,7 +375,7 @@ class MainWindow(QMainWindow):
             return
         text = self.editor.toHtml()
         try:
-            self.db.upsert_entry(date_iso, text)
+            self.db.save_new_version(date_iso, text, note)
         except Exception as e:
             QMessageBox.critical(self, "Save Error", str(e))
             return
@@ -300,27 +389,65 @@ class MainWindow(QMainWindow):
         )
 
     def _save_current(self, explicit: bool = False):
+        try:
+            self._save_timer.stop()
+        except Exception:
+            pass
+        if explicit:
+            # Prompt for a note
+            dlg = SaveDialog(self)
+            if dlg.exec() != QDialog.Accepted:
+                return
+            note = dlg.note_text()
+        else:
+            note = "autosave"
         # Delegate to _save_date for the currently selected date
-        self._save_date(self._current_date_iso(), explicit)
+        self._save_date(self._current_date_iso(), explicit, note)
+        try:
+            self._save_timer.start()
+        except Exception:
+            pass
+
+    def _open_history(self):
+        date_iso = self._current_date_iso()
+        dlg = HistoryDialog(self.db, date_iso, self)
+        if dlg.exec() == QDialog.Accepted:
+            # refresh editor + calendar (head pointer may have changed)
+            self._load_selected_date(date_iso)
+            self._refresh_calendar_marks()
 
+    # ----------- Settings handler ------------#
     def _open_settings(self):
         dlg = SettingsDialog(self.cfg, self.db, self)
-        if dlg.exec() == QDialog.Accepted:
-            new_cfg = dlg.config
-            if new_cfg.path != self.cfg.path:
-                # Save the new path to the notebook
-                self.cfg.path = new_cfg.path
-                save_db_config(self.cfg)
-                self.db.close()
-                # Prompt again for the key for the new path
-                if not self._prompt_for_key_until_valid():
-                    QMessageBox.warning(
-                        self, "Reopen failed", "Could not unlock database at new path."
-                    )
-                    return
-                self._load_selected_date()
-                self._refresh_calendar_marks()
+        if dlg.exec() != QDialog.Accepted:
+            return
 
+        new_cfg = dlg.config
+        old_path = self.cfg.path
+
+        # Update in-memory config from the dialog
+        self.cfg.path = new_cfg.path
+        self.cfg.key = new_cfg.key
+        self.cfg.idle_minutes = getattr(new_cfg, "idle_minutes", self.cfg.idle_minutes)
+
+        # Persist once
+        save_db_config(self.cfg)
+
+        # Apply idle setting immediately (restart the timer with new interval if it changed)
+        self._apply_idle_minutes(self.cfg.idle_minutes)
+
+        # If the DB path changed, reconnect
+        if self.cfg.path != old_path:
+            self.db.close()
+            if not self._prompt_for_key_until_valid(first_time=False):
+                QMessageBox.warning(
+                    self, "Reopen failed", "Could not unlock database at new path."
+                )
+                return
+            self._load_selected_date()
+            self._refresh_calendar_marks()
+
+    # ------------ Window positioning --------------- #
     def _restore_window_position(self):
         geom = self.settings.value("main/geometry", None)
         state = self.settings.value("main/windowState", None)
@@ -354,6 +481,7 @@ class MainWindow(QMainWindow):
         # Center the window in that screen’s available area
         self.move(r.center() - self.rect().center())
 
+    # ----------------- Export handler ----------------- #
     @Slot()
     def _export(self):
         try:
@@ -402,9 +530,77 @@ class MainWindow(QMainWindow):
         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()}")
+            QMessageBox.warning(
+                self, "Open Documentation", f"Couldn't open:\n{url.toDisplayString()}"
+            )
 
+    def _open_bugs(self):
+        url_str = "https://nr.mig5.net/forms/mig5/contact"
+        url = QUrl.fromUserInput(url_str)
+        if not QDesktopServices.openUrl(url):
+            QMessageBox.warning(
+                self, "Open Documentation", f"Couldn't open:\n{url.toDisplayString()}"
+            )
+
+    # Idle handlers
+    def _apply_idle_minutes(self, minutes: int):
+        minutes = max(0, int(minutes))
+        if not hasattr(self, "_idle_timer"):
+            return
+        if minutes == 0:
+            self._idle_timer.stop()
+            # If you’re currently locked, unlock when user disables the timer:
+            if getattr(self, "_locked", False):
+                try:
+                    self._locked = False
+                    if hasattr(self, "_lock_overlay"):
+                        self._lock_overlay.hide()
+                except Exception:
+                    pass
+        else:
+            self._idle_timer.setInterval(minutes * 60 * 1000)
+            if not getattr(self, "_locked", False):
+                self._idle_timer.start()
+
+    def eventFilter(self, obj, event):
+        if event.type() == QEvent.KeyPress and not self._locked:
+            self._idle_timer.start()
+        return super().eventFilter(obj, event)
+
+    def _enter_lock(self):
+        if self._locked:
+            return
+        self._locked = True
+        if self.menuBar():
+            self.menuBar().setEnabled(False)
+        if self.statusBar():
+            self.statusBar().setEnabled(False)
+        tb = getattr(self, "toolBar", None)
+        if tb:
+            tb.setEnabled(False)
+        self._lock_overlay.show()
+        self._lock_overlay.raise_()
+
+    @Slot()
+    def _on_unlock_clicked(self):
+        try:
+            ok = self._prompt_for_key_until_valid(first_time=False)
+        except Exception as e:
+            QMessageBox.critical(self, "Unlock failed", str(e))
+            return
+        if ok:
+            self._locked = False
+            self._lock_overlay.hide()
+            if self.menuBar():
+                self.menuBar().setEnabled(True)
+            if self.statusBar():
+                self.statusBar().setEnabled(True)
+            tb = getattr(self, "toolBar", None)
+            if tb:
+                tb.setEnabled(True)
+            self._idle_timer.start()
+
+    # Close app handler - save window position and database
     def closeEvent(self, event):
         try:
             # Save window position

bouquin/save_dialog.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import datetime
+
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QLabel,
+    QLineEdit,
+    QDialogButtonBox,
+)
+
+
+class SaveDialog(QDialog):
+    def __init__(
+        self,
+        parent=None,
+        title: str = "Enter a name for this version",
+        message: str = "Enter a name for this version?",
+    ):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        v = QVBoxLayout(self)
+        v.addWidget(QLabel(message))
+        self.note = QLineEdit()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.note.setText(f"New version I saved at {now}")
+        v.addWidget(self.note)
+        bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        bb.accepted.connect(self.accept)
+        bb.rejected.connect(self.reject)
+        v.addWidget(bb)
+
+    def note_text(self) -> str:
+        return self.note.text()

bouquin/settings.py

@@ -22,10 +22,12 @@ def load_db_config() -> DBConfig:
     s = get_settings()
     path = Path(s.value("db/path", str(default_db_path())))
     key = s.value("db/key", "")
-    return DBConfig(path=path, key=key)
+    idle = s.value("db/idle_minutes", 15, type=int)
+    return DBConfig(path=path, key=key, idle_minutes=idle)
 
 
 def save_db_config(cfg: DBConfig) -> None:
     s = get_settings()
     s.setValue("db/path", str(cfg.path))
     s.setValue("db/key", str(cfg.key))
+    s.setValue("db/idle_minutes", str(cfg.idle_minutes))

bouquin/settings_dialog.py

@@ -17,6 +17,7 @@ from PySide6.QtWidgets import (
     QFileDialog,
     QDialogButtonBox,
     QSizePolicy,
+    QSpinBox,
     QMessageBox,
 )
 from PySide6.QtCore import Qt, Slot
@@ -56,7 +57,7 @@ class SettingsDialog(QDialog):
         form.addRow("Database path", path_row)
 
         # Encryption settings
-        enc_group = QGroupBox("Encryption")
+        enc_group = QGroupBox("Encryption and Privacy")
         enc = QVBoxLayout(enc_group)
         enc.setContentsMargins(12, 8, 12, 12)
         enc.setSpacing(6)
@@ -64,10 +65,8 @@ class SettingsDialog(QDialog):
         # 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.key = current_settings.key or ""
+        self.save_key_btn.setChecked(bool(self.key))
         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)
@@ -100,6 +99,31 @@ class SettingsDialog(QDialog):
         self.rekey_btn.clicked.connect(self._change_key)
         enc.addWidget(self.rekey_btn, 0, Qt.AlignLeft)
 
+        self.idle_spin = QSpinBox()
+        self.idle_spin.setRange(0, 240)
+        self.idle_spin.setSingleStep(1)
+        self.idle_spin.setAccelerated(True)
+        self.idle_spin.setSuffix(" min")
+        self.idle_spin.setSpecialValueText("Never")
+        self.idle_spin.setValue(getattr(cfg, "idle_minutes", 15))
+        enc.addWidget(self.idle_spin, 0, Qt.AlignLeft)
+        # Explanation for idle option (autolock)
+        self.idle_spin_label = QLabel(
+            "Bouquin will automatically lock the notepad after this length of time, after which you'll need to re-enter the key to unlock it. "
+            "Set to 0 (never) to never lock."
+        )
+        self.idle_spin_label.setWordWrap(True)
+        self.idle_spin_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        # make it look secondary
+        spal = self.idle_spin_label.palette()
+        spal.setColor(self.idle_spin_label.foregroundRole(), spal.color(QPalette.Mid))
+        self.idle_spin_label.setPalette(spal)
+
+        spin_row = QHBoxLayout()
+        spin_row.setContentsMargins(24, 0, 0, 0)  # indent to line up under the spinbox
+        spin_row.addWidget(self.idle_spin_label)
+        enc.addLayout(spin_row)
+
         # Put the group into the form so it spans the full width nicely
         form.addRow(enc_group)
 
@@ -126,7 +150,12 @@ class SettingsDialog(QDialog):
             self.path_edit.setText(p)
 
     def _save(self):
-        self._cfg = DBConfig(path=Path(self.path_edit.text()), key=self.key)
+        key_to_save = self.key if self.save_key_btn.isChecked() else ""
+        self._cfg = DBConfig(
+            path=Path(self.path_edit.text()),
+            key=key_to_save,
+            idle_minutes=self.idle_spin.value(),
+        )
         save_db_config(self._cfg)
         self.accept()
 
@@ -155,14 +184,18 @@ class SettingsDialog(QDialog):
     @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)
+            if not self.key:
+                p1 = KeyPrompt(
+                    self, title="Enter your key", message="Enter the encryption key"
+                )
+                if p1.exec() != QDialog.Accepted:
+                    self.save_key_btn.blockSignals(True)
+                    self.save_key_btn.setChecked(False)
+                    self.save_key_btn.blockSignals(False)
+                    return
+            self.key = p1.key() or ""
+        else:
+            self.key = ""
 
     @property
     def config(self) -> DBConfig:

bouquin/toolbar.py

@@ -15,6 +15,7 @@ class ToolBar(QToolBar):
     bulletsRequested = Signal()
     numbersRequested = Signal()
     alignRequested = Signal(Qt.AlignmentFlag)
+    historyRequested = Signal()
 
     def __init__(self, parent=None):
         super().__init__("Format", parent)
@@ -76,6 +77,10 @@ class ToolBar(QToolBar):
             lambda: self.alignRequested.emit(Qt.AlignRight)
         )
 
+        # History button
+        self.actHistory = QAction("History", self)
+        self.actHistory.triggered.connect(self.historyRequested)
+
         self.addActions(
             [
                 self.actBold,
@@ -92,6 +97,7 @@ class ToolBar(QToolBar):
                 self.actAlignL,
                 self.actAlignC,
                 self.actAlignR,
+                self.actHistory,
             ]
         )
 
@@ -120,6 +126,9 @@ class ToolBar(QToolBar):
         self._style_letter_button(self.actAlignC, "C")
         self._style_letter_button(self.actAlignR, "R")
 
+        # History
+        self._style_letter_button(self.actHistory, "View History")
+
     def _style_letter_button(
         self,
         action: QAction,

{bouquin-0.1.3.dist-info → bouquin-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.1.3
+Version: 0.1.5
 Summary: Bouquin is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
 Home-page: https://git.mig5.net/mig5/bouquin
 License: GPL-3.0-or-later
@@ -46,6 +46,7 @@ There is deliberately no network connectivity or syncing intended.
  * Search
  * Automatic periodic saving (or explicitly save)
  * Transparent integrity checking of the database when it opens
+ * Automatic locking of the app after a period of inactivity (default 15 min)
  * Rekey the database (change the password)
  * Export the database to json, txt, html or csv
 

bouquin-0.1.5.dist-info/RECORD

@@ -0,0 +1,18 @@
+bouquin/__init__.py,sha256=-bBNFYOq80A2Egtpo5V5zWJtYOxQfRZFQ_feve5lkFU,23
+bouquin/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+bouquin/db.py,sha256=GDcv_ngezbf9DiFUhrEFN9yq4i2QHuDepG-2qQLyD80,16082
+bouquin/editor.py,sha256=vPLqysUNinUO6gtJQ8uDxJ_BL-lcaq0IXLStlG63k4E,8042
+bouquin/history_dialog.py,sha256=oFW1CGyqT8mzXdYuVyuBrlNVFSkvlBzajkOJ590L0go,6308
+bouquin/key_prompt.py,sha256=N5UxgDDnVAaoAIs9AqoydPSRjJ4Likda4-ejlE-lr-Y,1076
+bouquin/main.py,sha256=u7Wm5-9LRZDKkzKkK0W6P4oTtDorrrmtwIJWmQCqsRs,351
+bouquin/main_window.py,sha256=su_3MXwogKNRRcovng7Ll3btoTEdkD8OZMMK7UqmPsg,22199
+bouquin/save_dialog.py,sha256=nPLNWeImJZamNg53qE7_aeMK_p16aOiry0G4VvJsIWY,939
+bouquin/search.py,sha256=NAgH_FLjFB2i9bJXEfH3ClO8dWg7geYyoHtmLFNkrwA,6478
+bouquin/settings.py,sha256=GpMeJcTjdL1PFumeqdlSOi7nlgGdPTOeRbFadWYFcA0,870
+bouquin/settings_dialog.py,sha256=pgIg2G5O092mPn5EmkKrEgtl-Tyc8dwwCyNSNEAOidA,7256
+bouquin/toolbar.py,sha256=AsJB5zpPzUIyZkOqGcb2EJqQXelmPZ5aJX35XrrxA4g,5694
+bouquin-0.1.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+bouquin-0.1.5.dist-info/METADATA,sha256=SM2UsBP9iC21_2YAglG50fbz_CoZ91qg6m16L8GIJmU,2546
+bouquin-0.1.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+bouquin-0.1.5.dist-info/entry_points.txt,sha256=d2C5Mc85suj1vWg_mmcfFuEBAYEkdwhZquusme5EWuQ,49
+bouquin-0.1.5.dist-info/RECORD,,

bouquin-0.1.3.dist-info/RECORD

@@ -1,16 +0,0 @@
-bouquin/__init__.py,sha256=-bBNFYOq80A2Egtpo5V5zWJtYOxQfRZFQ_feve5lkFU,23
-bouquin/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
-bouquin/db.py,sha256=s3FDphbi6zxpHEFHnz44saZ9qAV4wU4WEiE6V95PkmI,7877
-bouquin/editor.py,sha256=vPLqysUNinUO6gtJQ8uDxJ_BL-lcaq0IXLStlG63k4E,8042
-bouquin/key_prompt.py,sha256=N5UxgDDnVAaoAIs9AqoydPSRjJ4Likda4-ejlE-lr-Y,1076
-bouquin/main.py,sha256=u7Wm5-9LRZDKkzKkK0W6P4oTtDorrrmtwIJWmQCqsRs,351
-bouquin/main_window.py,sha256=48lq5trwORpGWko6jWLGBk-_7PrtaQfZT1l-jbz67rY,15427
-bouquin/search.py,sha256=NAgH_FLjFB2i9bJXEfH3ClO8dWg7geYyoHtmLFNkrwA,6478
-bouquin/settings.py,sha256=aEsIIlYGwSxCVXXMpo98192QzatIIP6OvQDtcKrYWW4,742
-bouquin/settings_dialog.py,sha256=kWR4OeeHd5uQZ6lfHtuYx3UIh_MCb-nhjHcDyhQhpKM,5747
-bouquin/toolbar.py,sha256=i8uNhcAyYczVKPgSgk6tNJ63XxqlhPjLNpjzfM9NDC0,5401
-bouquin-0.1.3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-bouquin-0.1.3.dist-info/METADATA,sha256=y2FvqLWDTEYj1E2LCYAezvRsbycKVV71pVy9AaZv9EY,2468
-bouquin-0.1.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-bouquin-0.1.3.dist-info/entry_points.txt,sha256=d2C5Mc85suj1vWg_mmcfFuEBAYEkdwhZquusme5EWuQ,49
-bouquin-0.1.3.dist-info/RECORD,,