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

bouquin/history_dialog.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import difflib, re, html as _html
+from datetime import datetime
 from PySide6.QtCore import Qt, Slot
 from PySide6.QtWidgets import (
     QDialog,
@@ -77,14 +78,14 @@ class HistoryDialog(QDialog):
         self.list.currentItemChanged.connect(self._on_select)
         top.addWidget(self.list, 1)
 
-        # Right: tabs (Preview / Diff vs current)
+        # Right: tabs (Preview / Diff)
         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.addTab(self.diff, "Diff")
         self.tabs.setMinimumSize(500, 650)
         top.addWidget(self.tabs, 2)
 
@@ -104,6 +105,14 @@ class HistoryDialog(QDialog):
         self._load_versions()
 
     # --- Data/UX helpers ---
+    def _fmt_local(self, iso_utc: str) -> str:
+        """
+        Convert UTC in the database to user's local tz
+        """
+        dt = datetime.fromisoformat(iso_utc.replace("Z", "+00:00"))
+        local = dt.astimezone()
+        return local.strftime("%Y-%m-%d %H:%M:%S %Z")
+
     def _load_versions(self):
         self._versions = self._db.list_versions(
             self._date
@@ -113,7 +122,7 @@ class HistoryDialog(QDialog):
         )
         self.list.clear()
         for v in self._versions:
-            label = f"v{v['version_no']} — {v['created_at']}"
+            label = f"v{v['version_no']} — {self._fmt_local(v['created_at'])}"
             if v.get("note"):
                 label += f"  ·  {v['note']}"
             if v["is_current"]:
@@ -158,22 +167,10 @@ class HistoryDialog(QDialog):
             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

@@ -1,10 +1,20 @@
 from __future__ import annotations
 
+import datetime
 import os
 import sys
 
 from pathlib import Path
-from PySide6.QtCore import QDate, QTimer, Qt, QSettings, Slot, QUrl, QEvent
+from PySide6.QtCore import (
+    QDate,
+    QTimer,
+    Qt,
+    QSettings,
+    Slot,
+    QUrl,
+    QEvent,
+    QSignalBlocker,
+)
 from PySide6.QtGui import (
     QAction,
     QCursor,
@@ -12,6 +22,7 @@ from PySide6.QtGui import (
     QFont,
     QGuiApplication,
     QTextCharFormat,
+    QTextListFormat,
 )
 from PySide6.QtWidgets import (
     QCalendarWidget,
@@ -94,8 +105,8 @@ class _LockOverlay(QWidget):
 
 
 class MainWindow(QMainWindow):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.setWindowTitle(APP_NAME)
         self.setMinimumSize(1000, 650)
 
@@ -149,6 +160,10 @@ class MainWindow(QMainWindow):
         self.toolBar.numbersRequested.connect(self.editor.toggle_numbers)
         self.toolBar.alignRequested.connect(self.editor.setAlignment)
         self.toolBar.historyRequested.connect(self._open_history)
+        self.toolBar.insertImageRequested.connect(self._on_insert_image)
+
+        self.editor.currentCharFormatChanged.connect(lambda _f: self._sync_toolbar())
+        self.editor.cursorPositionChanged.connect(self._sync_toolbar)
 
         split = QSplitter()
         split.addWidget(left_panel)
@@ -201,6 +216,10 @@ class MainWindow(QMainWindow):
         act_export.setShortcut("Ctrl+E")
         act_export.triggered.connect(self._export)
         file_menu.addAction(act_export)
+        act_backup = QAction("&Backup", self)
+        act_backup.setShortcut("Ctrl+Shift+B")
+        act_backup.triggered.connect(self._backup)
+        file_menu.addAction(act_backup)
         file_menu.addSeparator()
         act_quit = QAction("&Quit", self)
         act_quit.setShortcut("Ctrl+Q")
@@ -210,21 +229,21 @@ class MainWindow(QMainWindow):
         # Navigate menu with next/previous/today
         nav_menu = mb.addMenu("&Navigate")
         act_prev = QAction("Previous Day", self)
-        act_prev.setShortcut("Ctrl+P")
+        act_prev.setShortcut("Ctrl+Shift+P")
         act_prev.setShortcutContext(Qt.ApplicationShortcut)
         act_prev.triggered.connect(lambda: self._adjust_day(-1))
         nav_menu.addAction(act_prev)
         self.addAction(act_prev)
 
         act_next = QAction("Next Day", self)
-        act_next.setShortcut("Ctrl+N")
+        act_next.setShortcut("Ctrl+Shift+N")
         act_next.setShortcutContext(Qt.ApplicationShortcut)
         act_next.triggered.connect(lambda: self._adjust_day(1))
         nav_menu.addAction(act_next)
         self.addAction(act_next)
 
         act_today = QAction("Today", self)
-        act_today.setShortcut("Ctrl+T")
+        act_today.setShortcut("Ctrl+Shift+T")
         act_today.setShortcutContext(Qt.ApplicationShortcut)
         act_today.triggered.connect(self._adjust_today)
         nav_menu.addAction(act_today)
@@ -315,6 +334,61 @@ class MainWindow(QMainWindow):
             pass
 
     # --- UI handlers ---------------------------------------------------------
+
+    def _sync_toolbar(self):
+        fmt = self.editor.currentCharFormat()
+        c = self.editor.textCursor()
+        bf = c.blockFormat()
+
+        # Block signals so setChecked() doesn't re-trigger actions
+        blocker1 = QSignalBlocker(self.toolBar.actBold)
+        blocker2 = QSignalBlocker(self.toolBar.actItalic)
+        blocker3 = QSignalBlocker(self.toolBar.actUnderline)
+        blocker4 = QSignalBlocker(self.toolBar.actStrike)
+
+        self.toolBar.actBold.setChecked(fmt.fontWeight() == QFont.Weight.Bold)
+        self.toolBar.actItalic.setChecked(fmt.fontItalic())
+        self.toolBar.actUnderline.setChecked(fmt.fontUnderline())
+        self.toolBar.actStrike.setChecked(fmt.fontStrikeOut())
+
+        # Headings: decide which to check by current point size
+        def _approx(a, b, eps=0.5):  # small float tolerance
+            return abs(float(a) - float(b)) <= eps
+
+        cur_size = fmt.fontPointSize() or self.editor.font().pointSizeF()
+
+        bH1 = _approx(cur_size, 24)
+        bH2 = _approx(cur_size, 18)
+        bH3 = _approx(cur_size, 14)
+
+        b1 = QSignalBlocker(self.toolBar.actH1)
+        b2 = QSignalBlocker(self.toolBar.actH2)
+        b3 = QSignalBlocker(self.toolBar.actH3)
+        bN = QSignalBlocker(self.toolBar.actNormal)
+
+        self.toolBar.actH1.setChecked(bH1)
+        self.toolBar.actH2.setChecked(bH2)
+        self.toolBar.actH3.setChecked(bH3)
+        self.toolBar.actNormal.setChecked(not (bH1 or bH2 or bH3))
+
+        # Lists
+        lst = c.currentList()
+        bullets_on = lst and lst.format().style() == QTextListFormat.Style.ListDisc
+        numbers_on = lst and lst.format().style() == QTextListFormat.Style.ListDecimal
+        QSignalBlocker(self.toolBar.actBullets)
+        QSignalBlocker(self.toolBar.actNumbers)
+        self.toolBar.actBullets.setChecked(bool(bullets_on))
+        self.toolBar.actNumbers.setChecked(bool(numbers_on))
+
+        # Alignment
+        align = bf.alignment() & Qt.AlignHorizontal_Mask
+        QSignalBlocker(self.toolBar.actAlignL)
+        self.toolBar.actAlignL.setChecked(align == Qt.AlignLeft)
+        QSignalBlocker(self.toolBar.actAlignC)
+        self.toolBar.actAlignC.setChecked(align == Qt.AlignHCenter)
+        QSignalBlocker(self.toolBar.actAlignR)
+        self.toolBar.actAlignR.setChecked(align == Qt.AlignRight)
+
     def _current_date_iso(self) -> str:
         d = self.calendar.selectedDate()
         return f"{d.year():04d}-{d.month():02d}-{d.day():02d}"
@@ -373,7 +447,7 @@ class MainWindow(QMainWindow):
         """
         if not self._dirty and not explicit:
             return
-        text = self.editor.toHtml()
+        text = self.editor.to_html_with_embedded_images()
         try:
             self.db.save_new_version(date_iso, text, note)
         except Exception as e:
@@ -416,6 +490,18 @@ class MainWindow(QMainWindow):
             self._load_selected_date(date_iso)
             self._refresh_calendar_marks()
 
+    def _on_insert_image(self):
+        # Let the user pick one or many images
+        paths, _ = QFileDialog.getOpenFileNames(
+            self,
+            "Insert image(s)",
+            "",
+            "Images (*.png *.jpg *.jpeg *.bmp *.gif *.webp)",
+        )
+        if not paths:
+            return
+        self.editor.insert_images(paths)  # call into the editor
+
     # ----------- Settings handler ------------#
     def _open_settings(self):
         dlg = SettingsDialog(self.cfg, self.db, self)
@@ -484,13 +570,31 @@ class MainWindow(QMainWindow):
     # ----------------- Export handler ----------------- #
     @Slot()
     def _export(self):
-        try:
-            self.export_dialog()
-        except Exception as e:
-            QMessageBox.critical(self, "Export failed", str(e))
+        warning_title = "Unencrypted export"
+        warning_message = """
+Exporting the database will be unencrypted!
+
+Are you sure you want to continue?
+
+If you want an encrypted backup, choose Backup instead of Export.
+"""
+        dlg = QMessageBox()
+        dlg.setWindowTitle(warning_title)
+        dlg.setText(warning_message)
+        dlg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+        dlg.setIcon(QMessageBox.Warning)
+        dlg.show()
+        dlg.adjustSize()
+        if dlg.exec() != QMessageBox.Yes:
+            return False
 
-    def export_dialog(self) -> None:
-        filters = "Text (*.txt);;" "JSON (*.json);;" "CSV (*.csv);;" "HTML (*.html);;"
+        filters = (
+            "Text (*.txt);;"
+            "JSON (*.json);;"
+            "CSV (*.csv);;"
+            "HTML (*.html);;"
+            "SQL (*.sql);;"
+        )
 
         start_dir = os.path.join(os.path.expanduser("~"), "Documents")
         filename, selected_filter = QFileDialog.getSaveFileName(
@@ -504,6 +608,7 @@ class MainWindow(QMainWindow):
             "JSON (*.json)": ".json",
             "CSV (*.csv)": ".csv",
             "HTML (*.html)": ".html",
+            "SQL (*.sql)": ".sql",
         }.get(selected_filter, ".txt")
 
         if not Path(filename).suffix:
@@ -518,14 +623,49 @@ class MainWindow(QMainWindow):
             elif selected_filter.startswith("CSV"):
                 self.db.export_csv(entries, filename)
             elif selected_filter.startswith("HTML"):
-                self.bd.export_html(entries, filename)
+                self.db.export_html(entries, filename)
+            elif selected_filter.startswith("SQL"):
+                self.db.export_sql(filename)
             else:
-                self.bd.export_by_extension(entries, filename)
+                self.db.export_by_extension(filename)
 
             QMessageBox.information(self, "Export complete", f"Saved to:\n{filename}")
         except Exception as e:
             QMessageBox.critical(self, "Export failed", str(e))
 
+    # ----------------- Backup handler ----------------- #
+    @Slot()
+    def _backup(self):
+        filters = "SQLCipher (*.db);;"
+
+        now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+        start_dir = os.path.join(
+            os.path.expanduser("~"), "Documents", f"bouquin_backup_{now}.db"
+        )
+        filename, selected_filter = QFileDialog.getSaveFileName(
+            self, "Backup encrypted notebook", start_dir, filters
+        )
+        if not filename:
+            return  # user cancelled
+
+        default_ext = {
+            "SQLCipher (*.db)": ".db",
+        }.get(selected_filter, ".db")
+
+        if not Path(filename).suffix:
+            filename += default_ext
+
+        try:
+            if selected_filter.startswith("SQL"):
+                self.db.export_sqlcipher(filename)
+                QMessageBox.information(
+                    self, "Backup complete", f"Saved to:\n{filename}"
+                )
+        except Exception as e:
+            QMessageBox.critical(self, "Backup failed", str(e))
+
+    # ----------------- Help handlers ----------------- #
+
     def _open_docs(self):
         url_str = "https://git.mig5.net/mig5/bouquin/wiki/Help"
         url = QUrl.fromUserInput(url_str)
@@ -542,7 +682,7 @@ class MainWindow(QMainWindow):
                 self, "Open Documentation", f"Couldn't open:\n{url.toDisplayString()}"
             )
 
-    # Idle handlers
+    # ----------------- Idle handlers ----------------- #
     def _apply_idle_minutes(self, minutes: int):
         minutes = max(0, int(minutes))
         if not hasattr(self, "_idle_timer"):
@@ -600,13 +740,14 @@ class MainWindow(QMainWindow):
                 tb.setEnabled(True)
             self._idle_timer.start()
 
-    # Close app handler - save window position and database
+    # ----------------- Close handlers ----------------- #
     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()

bouquin/settings_dialog.py

@@ -57,7 +57,7 @@ class SettingsDialog(QDialog):
         form.addRow("Database path", path_row)
 
         # Encryption settings
-        enc_group = QGroupBox("Encryption and Privacy")
+        enc_group = QGroupBox("Encryption")
         enc = QVBoxLayout(enc_group)
         enc.setContentsMargins(12, 8, 12, 12)
         enc.setSpacing(6)
@@ -68,7 +68,7 @@ class SettingsDialog(QDialog):
         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)
+        self.save_key_btn.toggled.connect(self._save_key_btn_clicked)
         enc.addWidget(self.save_key_btn, 0, Qt.AlignLeft)
 
         # Explanation for remembering key
@@ -94,11 +94,20 @@ class SettingsDialog(QDialog):
         enc.addWidget(line)
 
         # Change key button
-        self.rekey_btn = QPushButton("Change key")
+        self.rekey_btn = QPushButton("Change encryption 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)
 
+        form.addRow(enc_group)
+
+        # Privacy settings
+        priv_group = QGroupBox("Lock screen when idle")
+        priv = QVBoxLayout(priv_group)
+        priv.setContentsMargins(12, 8, 12, 12)
+        priv.setSpacing(6)
+
         self.idle_spin = QSpinBox()
         self.idle_spin.setRange(0, 240)
         self.idle_spin.setSingleStep(1)
@@ -106,7 +115,7 @@ class SettingsDialog(QDialog):
         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)
+        priv.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. "
@@ -122,10 +131,39 @@ class SettingsDialog(QDialog):
         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)
+        priv.addLayout(spin_row)
 
-        # Put the group into the form so it spans the full width nicely
-        form.addRow(enc_group)
+        form.addRow(priv_group)
+
+        # Maintenance settings
+        maint_group = QGroupBox("Database maintenance")
+        maint = QVBoxLayout(maint_group)
+        maint.setContentsMargins(12, 8, 12, 12)
+        maint.setSpacing(6)
+
+        self.compact_btn = QPushButton("Compact database")
+        self.compact_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self.compact_btn.clicked.connect(self._compact_btn_clicked)
+
+        maint.addWidget(self.compact_btn, 0, Qt.AlignLeft)
+
+        # Explanation for compating button
+        self.compact_label = QLabel(
+            "Compacting runs VACUUM on the database. This can help reduce its size."
+        )
+        self.compact_label.setWordWrap(True)
+        self.compact_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        # make it look secondary
+        cpal = self.compact_label.palette()
+        cpal.setColor(self.compact_label.foregroundRole(), cpal.color(QPalette.Mid))
+        self.compact_label.setPalette(cpal)
+
+        maint_row = QHBoxLayout()
+        maint_row.setContentsMargins(24, 0, 0, 0)  # indent to line up under the button
+        maint_row.addWidget(self.compact_label)
+        maint.addLayout(maint_row)
+
+        form.addRow(maint_group)
 
         # Buttons
         bb = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Cancel)
@@ -174,6 +212,7 @@ class SettingsDialog(QDialog):
             QMessageBox.warning(self, "Empty key", "Key cannot be empty.")
             return
         try:
+            self.key = new_key
             self._db.rekey(new_key)
             QMessageBox.information(
                 self, "Key changed", "The notebook was re-encrypted with the new key!"
@@ -182,7 +221,7 @@ class SettingsDialog(QDialog):
             QMessageBox.critical(self, "Error", f"Could not change key:\n{e}")
 
     @Slot(bool)
-    def save_key_btn_clicked(self, checked: bool):
+    def _save_key_btn_clicked(self, checked: bool):
         if checked:
             if not self.key:
                 p1 = KeyPrompt(
@@ -193,10 +232,20 @@ class SettingsDialog(QDialog):
                     self.save_key_btn.setChecked(False)
                     self.save_key_btn.blockSignals(False)
                     return
-            self.key = p1.key() or ""
+                self.key = p1.key() or ""
         else:
             self.key = ""
 
+    @Slot(bool)
+    def _compact_btn_clicked(self):
+        try:
+            self._db.compact()
+            QMessageBox.information(
+                self, "Compact complete", "Database compacted successfully!"
+            )
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Could not compact database:\n{e}")
+
     @property
     def config(self) -> DBConfig:
         return self._cfg

bouquin/toolbar.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from PySide6.QtCore import Signal, Qt
-from PySide6.QtGui import QAction, QKeySequence, QFont, QFontDatabase
+from PySide6.QtGui import QAction, QKeySequence, QFont, QFontDatabase, QActionGroup
 from PySide6.QtWidgets import QToolBar
 
 
@@ -16,6 +16,7 @@ class ToolBar(QToolBar):
     numbersRequested = Signal()
     alignRequested = Signal(Qt.AlignmentFlag)
     historyRequested = Signal()
+    insertImageRequested = Signal()
 
     def __init__(self, parent=None):
         super().__init__("Format", parent)
@@ -25,54 +26,87 @@ class ToolBar(QToolBar):
         self._apply_toolbar_styles()
 
     def _build_actions(self):
-        self.actBold = QAction("Bold", self)
+        self.actBold = QAction("B", self)
+        self.actBold.setToolTip("Bold")
+        self.actBold.setCheckable(True)
         self.actBold.setShortcut(QKeySequence.Bold)
         self.actBold.triggered.connect(self.boldRequested)
 
-        self.actItalic = QAction("Italic", self)
+        self.actItalic = QAction("I", self)
+        self.actItalic.setToolTip("Italic")
+        self.actItalic.setCheckable(True)
         self.actItalic.setShortcut(QKeySequence.Italic)
         self.actItalic.triggered.connect(self.italicRequested)
 
-        self.actUnderline = QAction("Underline", self)
+        self.actUnderline = QAction("U", self)
+        self.actUnderline.setToolTip("Underline")
+        self.actUnderline.setCheckable(True)
         self.actUnderline.setShortcut(QKeySequence.Underline)
         self.actUnderline.triggered.connect(self.underlineRequested)
 
-        self.actStrike = QAction("Strikethrough", self)
+        self.actStrike = QAction("S", self)
+        self.actStrike.setToolTip("Strikethrough")
+        self.actStrike.setCheckable(True)
         self.actStrike.setShortcut("Ctrl+-")
         self.actStrike.triggered.connect(self.strikeRequested)
 
-        self.actCode = QAction("Inline code", self)
+        self.actCode = QAction("</>", self)
+        self.actCode.setToolTip("Code block")
         self.actCode.setShortcut("Ctrl+`")
         self.actCode.triggered.connect(self.codeRequested)
 
         # Headings
-        self.actH1 = QAction("Heading 1", self)
-        self.actH2 = QAction("Heading 2", self)
-        self.actH3 = QAction("Heading 3", self)
-        self.actNormal = QAction("Normal text", self)
+        self.actH1 = QAction("H1", self)
+        self.actH1.setToolTip("Heading 1")
+        self.actH1.setCheckable(True)
         self.actH1.setShortcut("Ctrl+1")
-        self.actH2.setShortcut("Ctrl+2")
-        self.actH3.setShortcut("Ctrl+3")
-        self.actNormal.setShortcut("Ctrl+N")
         self.actH1.triggered.connect(lambda: self.headingRequested.emit(24))
+        self.actH2 = QAction("H2", self)
+        self.actH2.setToolTip("Heading 2")
+        self.actH2.setCheckable(True)
+        self.actH2.setShortcut("Ctrl+2")
         self.actH2.triggered.connect(lambda: self.headingRequested.emit(18))
+        self.actH3 = QAction("H3", self)
+        self.actH3.setToolTip("Heading 3")
+        self.actH3.setCheckable(True)
+        self.actH3.setShortcut("Ctrl+3")
         self.actH3.triggered.connect(lambda: self.headingRequested.emit(14))
+        self.actNormal = QAction("N", self)
+        self.actNormal.setToolTip("Normal paragraph text")
+        self.actNormal.setCheckable(True)
+        self.actNormal.setShortcut("Ctrl+N")
         self.actNormal.triggered.connect(lambda: self.headingRequested.emit(0))
 
         # Lists
-        self.actBullets = QAction("Bulleted list", self)
+        self.actBullets = QAction("•", self)
+        self.actBullets.setToolTip("Bulleted list")
+        self.actBullets.setCheckable(True)
         self.actBullets.triggered.connect(self.bulletsRequested)
-        self.actNumbers = QAction("Numbered list", self)
+        self.actNumbers = QAction("1.", self)
+        self.actNumbers.setToolTip("Numbered list")
+        self.actNumbers.setCheckable(True)
         self.actNumbers.triggered.connect(self.numbersRequested)
 
+        # Images
+        self.actInsertImg = QAction("Image", self)
+        self.actInsertImg.setToolTip("Insert image")
+        self.actInsertImg.setShortcut("Ctrl+Shift+I")
+        self.actInsertImg.triggered.connect(self.insertImageRequested)
+
         # Alignment
-        self.actAlignL = QAction("Align left", self)
-        self.actAlignC = QAction("Align center", self)
-        self.actAlignR = QAction("Align right", self)
+        self.actAlignL = QAction("L", self)
+        self.actAlignL.setToolTip("Align Left")
+        self.actAlignL.setCheckable(True)
         self.actAlignL.triggered.connect(lambda: self.alignRequested.emit(Qt.AlignLeft))
+        self.actAlignC = QAction("C", self)
+        self.actAlignC.setToolTip("Align Center")
+        self.actAlignC.setCheckable(True)
         self.actAlignC.triggered.connect(
             lambda: self.alignRequested.emit(Qt.AlignHCenter)
         )
+        self.actAlignR = QAction("R", self)
+        self.actAlignR.setToolTip("Align Right")
+        self.actAlignR.setCheckable(True)
         self.actAlignR.triggered.connect(
             lambda: self.alignRequested.emit(Qt.AlignRight)
         )
@@ -81,6 +115,28 @@ class ToolBar(QToolBar):
         self.actHistory = QAction("History", self)
         self.actHistory.triggered.connect(self.historyRequested)
 
+        # Set exclusive buttons in QActionGroups
+        self.grpHeadings = QActionGroup(self)
+        self.grpHeadings.setExclusive(True)
+        for a in (
+            self.actBold,
+            self.actItalic,
+            self.actUnderline,
+            self.actStrike,
+            self.actH1,
+            self.actH2,
+            self.actH3,
+            self.actNormal,
+        ):
+            a.setCheckable(True)
+            a.setActionGroup(self.grpHeadings)
+
+        self.grpAlign = QActionGroup(self)
+        self.grpAlign.setExclusive(True)
+        for a in (self.actAlignL, self.actAlignC, self.actAlignR):
+            a.setActionGroup(self.grpAlign)
+
+        # Add actions
         self.addActions(
             [
                 self.actBold,
@@ -94,6 +150,7 @@ class ToolBar(QToolBar):
                 self.actNormal,
                 self.actBullets,
                 self.actNumbers,
+                self.actInsertImg,
                 self.actAlignL,
                 self.actAlignC,
                 self.actAlignR,
@@ -106,7 +163,6 @@ class ToolBar(QToolBar):
         self._style_letter_button(self.actItalic, "I", italic=True)
         self._style_letter_button(self.actUnderline, "U", underline=True)
         self._style_letter_button(self.actStrike, "S", strike=True)
-
         # Monospace look for code; use a fixed font
         code_font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
         self._style_letter_button(self.actCode, "</>", custom_font=code_font)
@@ -139,11 +195,13 @@ class ToolBar(QToolBar):
         underline: bool = False,
         strike: bool = False,
         custom_font: QFont | None = None,
+        tooltip: str | None = None,
     ):
         btn = self.widgetForAction(action)
         if not btn:
             return
         btn.setText(text)
+
         f = custom_font if custom_font is not None else QFont(btn.font())
         if custom_font is None:
             f.setBold(bold)
@@ -153,5 +211,6 @@ class ToolBar(QToolBar):
         btn.setFont(f)
 
         # Keep accessibility/tooltip readable
-        btn.setToolTip(action.text())
-        btn.setAccessibleName(action.text())
+        if tooltip:
+            btn.setToolTip(tooltip)
+            btn.setAccessibleName(tooltip)