bouquin 0.1.10__py3-none-any.whl → 0.2.1.2__py3-none-any.whl

bouquin/main_window.py

@@ -24,8 +24,10 @@ from PySide6.QtGui import (
     QDesktopServices,
     QFont,
     QGuiApplication,
+    QKeySequence,
     QPalette,
     QTextCharFormat,
+    QTextCursor,
     QTextListFormat,
 )
 from PySide6.QtWidgets import (
@@ -34,15 +36,19 @@ from PySide6.QtWidgets import (
     QDialog,
     QFileDialog,
     QMainWindow,
+    QMenu,
     QMessageBox,
     QSizePolicy,
     QSplitter,
+    QTableView,
+    QTabWidget,
     QVBoxLayout,
     QWidget,
 )
 
 from .db import DBManager
-from .editor import Editor
+from .markdown_editor import MarkdownEditor
+from .find_bar import FindBar
 from .history_dialog import HistoryDialog
 from .key_prompt import KeyPrompt
 from .lock_overlay import LockOverlay
@@ -95,33 +101,36 @@ class MainWindow(QMainWindow):
         left_layout.addWidget(self.search)
         left_panel.setFixedWidth(self.calendar.sizeHint().width() + 16)
 
-        # This is the note-taking editor
-        self.editor = Editor(self.themes)
+        # Create tab widget to hold multiple editors
+        self.tab_widget = QTabWidget()
+        self.tab_widget.setTabsClosable(True)
+        self.tab_widget.tabCloseRequested.connect(self._close_tab)
+        self.tab_widget.currentChanged.connect(self._on_tab_changed)
 
         # Toolbar for controlling styling
         self.toolBar = ToolBar()
         self.addToolBar(self.toolBar)
-        # Wire toolbar intents to editor methods
-        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.checkboxesRequested.connect(self.editor.toggle_checkboxes)
-        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)
+        self._bind_toolbar()
+
+        # Create the first editor tab
+        self._create_new_tab()
 
         split = QSplitter()
         split.addWidget(left_panel)
-        split.addWidget(self.editor)
-        split.setStretchFactor(1, 1)  # editor grows
+        split.addWidget(self.tab_widget)
+        split.setStretchFactor(1, 1)
+
+        # Enable context menu on calendar for opening dates in new tabs
+        self.calendar.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.calendar.customContextMenuRequested.connect(
+            self._show_calendar_context_menu
+        )
+
+        # Flag to prevent _on_date_changed when showing context menu
+        self._showing_context_menu = False
+
+        # Install event filter to catch right-clicks before selectionChanged fires
+        self.calendar.installEventFilter(self)
 
         container = QWidget()
         lay = QVBoxLayout(container)
@@ -146,8 +155,26 @@ class MainWindow(QMainWindow):
 
         QApplication.instance().installEventFilter(self)
 
+        # Focus on the editor
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.editor.setFocusPolicy(Qt.StrongFocus)
+        self.toolBar.setFocusPolicy(Qt.NoFocus)
+        for w in self.toolBar.findChildren(QWidget):
+            w.setFocusPolicy(Qt.NoFocus)
+        QGuiApplication.instance().applicationStateChanged.connect(
+            self._on_app_state_changed
+        )
+
         # Status bar for feedback
         self.statusBar().showMessage("Ready", 800)
+        # Add findBar and add it to the statusBar
+        # FindBar will get the current editor dynamically via a callable
+        self.findBar = FindBar(
+            lambda: self.current_editor(), shortcut_parent=self, parent=self
+        )
+        self.statusBar().addPermanentWidget(self.findBar)
+        # When the findBar closes, put the caret back in the editor
+        self.findBar.closed.connect(self._focus_editor_now)
 
         # Menu bar (File)
         mb = self.menuBar()
@@ -202,6 +229,24 @@ class MainWindow(QMainWindow):
         nav_menu.addAction(act_today)
         self.addAction(act_today)
 
+        act_find = QAction("Find on page", self)
+        act_find.setShortcut(QKeySequence.Find)
+        act_find.triggered.connect(self.findBar.show_bar)
+        nav_menu.addAction(act_find)
+        self.addAction(act_find)
+
+        act_find_next = QAction("Find Next", self)
+        act_find_next.setShortcut(QKeySequence.FindNext)
+        act_find_next.triggered.connect(self.findBar.find_next)
+        nav_menu.addAction(act_find_next)
+        self.addAction(act_find_next)
+
+        act_find_prev = QAction("Find Previous", self)
+        act_find_prev.setShortcut(QKeySequence.FindPrevious)
+        act_find_prev.triggered.connect(self.findBar.find_prev)
+        nav_menu.addAction(act_find_prev)
+        self.addAction(act_find_prev)
+
         # Help menu with drop-down
         help_menu = mb.addMenu("&Help")
         act_docs = QAction("Documentation", self)
@@ -222,7 +267,7 @@ class MainWindow(QMainWindow):
         self._save_timer = QTimer(self)
         self._save_timer.setSingleShot(True)
         self._save_timer.timeout.connect(self._save_current)
-        self.editor.textChanged.connect(self._on_text_changed)
+        # Note: textChanged will be connected per-editor in _create_new_tab
 
         # First load + mark dates in calendar with content
         if not self._load_yesterday_todos():
@@ -277,11 +322,282 @@ class MainWindow(QMainWindow):
             if self._try_connect():
                 return True
 
+    # ----------------- Tab and date management ----------------- #
+
+    def _current_date_iso(self) -> str:
+        d = self.calendar.selectedDate()
+        return f"{d.year():04d}-{d.month():02d}-{d.day():02d}"
+
+    def _date_key(self, qd: QDate) -> tuple[int, int, int]:
+        return (qd.year(), qd.month(), qd.day())
+
+    def _index_for_date_insert(self, date: QDate) -> int:
+        """Return the index where a tab for `date` should be inserted (ascending order)."""
+        key = self._date_key(date)
+        for i in range(self.tab_widget.count()):
+            w = self.tab_widget.widget(i)
+            d = getattr(w, "current_date", None)
+            if isinstance(d, QDate) and d.isValid():
+                if self._date_key(d) > key:
+                    return i
+        return self.tab_widget.count()
+
+    def _reorder_tabs_by_date(self):
+        """Reorder existing tabs by their date (ascending)."""
+        bar = self.tab_widget.tabBar()
+        dated, undated = [], []
+
+        for i in range(self.tab_widget.count()):
+            w = self.tab_widget.widget(i)
+            d = getattr(w, "current_date", None)
+            if isinstance(d, QDate) and d.isValid():
+                dated.append((d, w))
+            else:
+                undated.append(w)
+
+        dated.sort(key=lambda t: self._date_key(t[0]))
+
+        with QSignalBlocker(self.tab_widget):
+            # Update labels to yyyy-MM-dd
+            for d, w in dated:
+                idx = self.tab_widget.indexOf(w)
+                if idx != -1:
+                    self.tab_widget.setTabText(idx, d.toString("yyyy-MM-dd"))
+
+            # Move dated tabs into target positions 0..len(dated)-1
+            for target_pos, (_, w) in enumerate(dated):
+                cur = self.tab_widget.indexOf(w)
+                if cur != -1 and cur != target_pos:
+                    bar.moveTab(cur, target_pos)
+
+            # Keep any undated pages (if they ever exist) after the dated ones
+            start = len(dated)
+            for offset, w in enumerate(undated):
+                cur = self.tab_widget.indexOf(w)
+                target = start + offset
+                if cur != -1 and cur != target:
+                    bar.moveTab(cur, target)
+
+    def _tab_index_for_date(self, date: QDate) -> int:
+        """Return the index of the tab showing `date`, or -1 if none."""
+        iso = date.toString("yyyy-MM-dd")
+        for i in range(self.tab_widget.count()):
+            w = self.tab_widget.widget(i)
+            if (
+                hasattr(w, "current_date")
+                and w.current_date.toString("yyyy-MM-dd") == iso
+            ):
+                return i
+        return -1
+
+    def _open_date_in_tab(self, date: QDate):
+        """Focus existing tab for `date`, or create it if needed. Returns the editor."""
+        idx = self._tab_index_for_date(date)
+        if idx != -1:
+            self.tab_widget.setCurrentIndex(idx)
+            # keep calendar selection in sync (don’t trigger load)
+            from PySide6.QtCore import QSignalBlocker
+
+            with QSignalBlocker(self.calendar):
+                self.calendar.setSelectedDate(date)
+            QTimer.singleShot(0, self._focus_editor_now)
+            return self.tab_widget.widget(idx)
+        # not open yet -> create
+        return self._create_new_tab(date)
+
+    def _create_new_tab(self, date: QDate | None = None) -> MarkdownEditor:
+        if date is None:
+            date = self.calendar.selectedDate()
+
+        # Deduplicate: if already open, just jump there
+        existing = self._tab_index_for_date(date)
+        if existing != -1:
+            self.tab_widget.setCurrentIndex(existing)
+            return self.tab_widget.widget(existing)
+
+        """Create a new editor tab and return the editor instance."""
+        editor = MarkdownEditor(self.themes)
+
+        # Set up the editor's event connections
+        editor.currentCharFormatChanged.connect(lambda _f: self._sync_toolbar())
+        editor.cursorPositionChanged.connect(self._sync_toolbar)
+        editor.textChanged.connect(self._on_text_changed)
+
+        # Set tab title
+        tab_title = date.toString("yyyy-MM-dd")
+
+        # Add the tab
+        index = self.tab_widget.addTab(editor, tab_title)
+        self.tab_widget.setCurrentIndex(index)
+
+        # Load the date's content
+        self._load_date_into_editor(date, editor)
+
+        # Store the date with the editor so we can save it later
+        editor.current_date = date
+
+        # Insert at sorted position
+        tab_title = date.toString("yyyy-MM-dd")
+        pos = self._index_for_date_insert(date)
+        index = self.tab_widget.insertTab(pos, editor, tab_title)
+        self.tab_widget.setCurrentIndex(index)
+
+        return editor
+
+    def _close_tab(self, index: int):
+        """Close a tab at the given index."""
+        if self.tab_widget.count() <= 1:
+            # Don't close the last tab
+            return
+
+        editor = self.tab_widget.widget(index)
+        if editor:
+            # Save before closing
+            self._save_editor_content(editor)
+
+        self.tab_widget.removeTab(index)
+
+    def _on_tab_changed(self, index: int):
+        """Handle tab change - reconnect toolbar and sync UI."""
+        if index < 0:
+            return
+
+        editor = self.tab_widget.widget(index)
+        if editor and hasattr(editor, "current_date"):
+            # Update calendar selection to match the tab
+            with QSignalBlocker(self.calendar):
+                self.calendar.setSelectedDate(editor.current_date)
+
+        # Reconnect toolbar to new active editor
+        self._sync_toolbar()
+
+        # Focus the editor
+        QTimer.singleShot(0, self._focus_editor_now)
+
+    def _call_editor(self, method_name, *args):
+        """
+        Call the relevant method of the MarkdownEditor class on bind
+        """
+        ed = self.current_editor()
+        if ed is None:
+            return
+        getattr(ed, method_name)(*args)
+
+    def current_editor(self) -> MarkdownEditor | None:
+        """Get the currently active editor."""
+        return self.tab_widget.currentWidget()
+
+    @property
+    def editor(self) -> MarkdownEditor | None:
+        """Compatibility property to get current editor (for existing code)."""
+        return self.current_editor()
+
+    def _date_from_calendar_pos(self, pos) -> QDate | None:
+        """Translate a QCalendarWidget local pos to the QDate under the cursor."""
+        view: QTableView = self.calendar.findChild(
+            QTableView, "qt_calendar_calendarview"
+        )
+        if view is None:
+            return None
+
+        # Map calendar-local pos -> viewport pos
+        vp_pos = view.viewport().mapFrom(self.calendar, pos)
+        idx = view.indexAt(vp_pos)
+        if not idx.isValid():
+            return None
+
+        model = view.model()
+
+        # Account for optional headers
+        start_col = (
+            0
+            if self.calendar.verticalHeaderFormat() == QCalendarWidget.NoVerticalHeader
+            else 1
+        )
+        start_row = (
+            0
+            if self.calendar.horizontalHeaderFormat()
+            == QCalendarWidget.NoHorizontalHeader
+            else 1
+        )
+
+        # Find index of day 1 (first cell belonging to current month)
+        first_index = None
+        for r in range(start_row, model.rowCount()):
+            for c in range(start_col, model.columnCount()):
+                if model.index(r, c).data() == 1:
+                    first_index = model.index(r, c)
+                    break
+            if first_index:
+                break
+        if first_index is None:
+            return None
+
+        # Find index of the last day of the current month
+        last_day = (
+            QDate(self.calendar.yearShown(), self.calendar.monthShown(), 1)
+            .addMonths(1)
+            .addDays(-1)
+            .day()
+        )
+        last_index = None
+        for r in range(model.rowCount() - 1, first_index.row() - 1, -1):
+            for c in range(model.columnCount() - 1, start_col - 1, -1):
+                if model.index(r, c).data() == last_day:
+                    last_index = model.index(r, c)
+                    break
+            if last_index:
+                break
+        if last_index is None:
+            return None
+
+        # Determine if clicked cell belongs to prev/next month or current
+        day = int(idx.data())
+        year = self.calendar.yearShown()
+        month = self.calendar.monthShown()
+
+        before_first = (idx.row() < first_index.row()) or (
+            idx.row() == first_index.row() and idx.column() < first_index.column()
+        )
+        after_last = (idx.row() > last_index.row()) or (
+            idx.row() == last_index.row() and idx.column() > last_index.column()
+        )
+
+        if before_first:
+            if month == 1:
+                month = 12
+                year -= 1
+            else:
+                month -= 1
+        elif after_last:
+            if month == 12:
+                month = 1
+                year += 1
+            else:
+                month += 1
+
+        qd = QDate(year, month, day)
+        return qd if qd.isValid() else None
+
+    def _show_calendar_context_menu(self, pos):
+        self._showing_context_menu = True  # so selectionChanged handler doesn't fire
+        clicked_date = self._date_from_calendar_pos(pos)
+
+        menu = QMenu(self)
+        open_in_new_tab_action = menu.addAction("Open in New Tab")
+        action = menu.exec_(self.calendar.mapToGlobal(pos))
+
+        self._showing_context_menu = False
+
+        if action == open_in_new_tab_action and clicked_date and clicked_date.isValid():
+            self._open_date_in_tab(clicked_date)
+
+    # ----------------- Some theme helpers -------------------#
     def _retheme_overrides(self):
         if hasattr(self, "_lock_overlay"):
             self._lock_overlay._apply_overlay_style()
         self._apply_calendar_text_colors()
-        self._apply_link_css()  # Reapply link styles based on the current theme
+        self._apply_link_css()
         self._apply_search_highlights(getattr(self, "_search_highlighted_dates", set()))
         self.calendar.update()
         self.editor.viewport().update()
@@ -298,7 +614,6 @@ class MainWindow(QMainWindow):
             css = ""  # Default to no custom styling for links (system or light theme)
 
         try:
-            # Apply to the editor (QTextEdit or any other relevant widgets)
             self.editor.document().setDefaultStyleSheet(css)
         except Exception:
             pass
@@ -347,7 +662,6 @@ class MainWindow(QMainWindow):
             self.calendar.setPalette(app_pal)
             self.calendar.setStyleSheet("")
 
-        # Keep weekend text color in sync with the current palette
         self._apply_calendar_text_colors()
         self.calendar.update()
 
@@ -413,20 +727,47 @@ class MainWindow(QMainWindow):
 
     # --- UI handlers ---------------------------------------------------------
 
+    def _bind_toolbar(self):
+        if getattr(self, "_toolbar_bound", False):
+            return
+        tb = self.toolBar
+
+        # keep refs so we never create new lambdas (prevents accidental dupes)
+        self._tb_bold = lambda: self._call_editor("apply_weight")
+        self._tb_italic = lambda: self._call_editor("apply_italic")
+        self._tb_strike = lambda: self._call_editor("apply_strikethrough")
+        self._tb_code = lambda: self._call_editor("apply_code")
+        self._tb_heading = lambda level: self._call_editor("apply_heading", level)
+        self._tb_bullets = lambda: self._call_editor("toggle_bullets")
+        self._tb_numbers = lambda: self._call_editor("toggle_numbers")
+        self._tb_checkboxes = lambda: self._call_editor("toggle_checkboxes")
+
+        tb.boldRequested.connect(self._tb_bold)
+        tb.italicRequested.connect(self._tb_italic)
+        tb.strikeRequested.connect(self._tb_strike)
+        tb.codeRequested.connect(self._tb_code)
+        tb.headingRequested.connect(self._tb_heading)
+        tb.bulletsRequested.connect(self._tb_bullets)
+        tb.numbersRequested.connect(self._tb_numbers)
+        tb.checkboxesRequested.connect(self._tb_checkboxes)
+
+        # these aren’t editor methods
+        tb.historyRequested.connect(self._open_history)
+        tb.insertImageRequested.connect(self._on_insert_image)
+
+        self._toolbar_bound = True
+
     def _sync_toolbar(self):
         fmt = self.editor.currentCharFormat()
         c = self.editor.textCursor()
-        bf = c.blockFormat()
 
         # Block signals so setChecked() doesn't re-trigger actions
         QSignalBlocker(self.toolBar.actBold)
         QSignalBlocker(self.toolBar.actItalic)
-        QSignalBlocker(self.toolBar.actUnderline)
         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
@@ -458,49 +799,60 @@ class MainWindow(QMainWindow):
         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}"
-
     def _load_selected_date(self, date_iso=False, extra_data=False):
+        """Load a date into the current editor"""
+        editor = self.current_editor()
+        if not editor:
+            return
+
         if not date_iso:
             date_iso = self._current_date_iso()
+
+        qd = QDate.fromString(date_iso, "yyyy-MM-dd")
+        self._load_date_into_editor(qd, editor, extra_data)
+        editor.current_date = qd
+
+        # Update tab title
+        current_index = self.tab_widget.currentIndex()
+        if current_index >= 0:
+            self.tab_widget.setTabText(current_index, date_iso)
+
+        # Keep tabs sorted by date
+        self._reorder_tabs_by_date()
+
+    def _load_date_into_editor(
+        self, date: QDate, editor: MarkdownEditor, extra_data=False
+    ):
+        """Load a specific date's content into a given editor."""
+        date_iso = date.toString("yyyy-MM-dd")
         try:
             text = self.db.get_entry(date_iso)
             if extra_data:
-                # Wrap extra_data in a <p> tag for HTML rendering
-                extra_data_html = f"<p>{extra_data}</p>"
-
-                # Inject the extra_data before the closing </body></html>
-                modified = re.sub(r"(<\/body><\/html>)", extra_data_html + r"\1", text)
-                text = modified
-                self.editor.setHtml(text)
+                # Append extra data as markdown
+                if text and not text.endswith("\n"):
+                    text += "\n"
+                text += extra_data
+                # Force a save now so we don't lose it.
+                self._set_editor_markdown_preserve_view(text, editor)
                 self._dirty = True
                 self._save_date(date_iso, True)
-
-            print("end")
         except Exception as e:
             QMessageBox.critical(self, "Read Error", str(e))
             return
 
-        self.editor.blockSignals(True)
-        self.editor.setHtml(text)
-        self.editor.blockSignals(False)
-
+        self._set_editor_markdown_preserve_view(text, editor)
         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 _save_editor_content(self, editor: MarkdownEditor):
+        """Save a specific editor's content to its associated date."""
+        if not hasattr(editor, "current_date"):
+            return
+        date_iso = editor.current_date.toString("yyyy-MM-dd")
+        try:
+            md = editor.to_markdown()
+            self.db.save_new_version(date_iso, md, note="autosave")
+        except Exception as e:
+            QMessageBox.critical(self, "Save Error", str(e))
 
     def _on_text_changed(self):
         self._dirty = True
@@ -514,7 +866,7 @@ class MainWindow(QMainWindow):
     def _adjust_today(self):
         """Jump to today."""
         today = QDate.currentDate()
-        self.calendar.setSelectedDate(today)
+        self._create_new_tab(today)
 
     def _load_yesterday_todos(self):
         try:
@@ -524,39 +876,33 @@ class MainWindow(QMainWindow):
             text = self.db.get_entry(yesterday_str)
             unchecked_items = []
 
-            # Regex to match the unchecked checkboxes and their associated text
-            checkbox_pattern = re.compile(
-                r"<span[^>]*>(☐)</span>\s*(.*?)</p>", re.DOTALL
-            )
-
-            # Find unchecked items and store them
-            for match in checkbox_pattern.finditer(text):
-                checkbox = match.group(1)  # Either ☐ or ☑
-                item_text = match.group(2).strip()  # The text after the checkbox
-                if checkbox == "☐":  # If it's an unchecked checkbox (☐)
-                    unchecked_items.append("☐ " + item_text)  # Store the unchecked item
-
-            # Remove the unchecked items from yesterday's HTML content
+            # Split into lines and find unchecked checkbox items
+            lines = text.split("\n")
+            remaining_lines = []
+
+            for line in lines:
+                # Check for unchecked markdown checkboxes: - [ ] or - [☐]
+                if re.match(r"^\s*-\s*\[\s*\]\s+", line) or re.match(
+                    r"^\s*-\s*\[☐\]\s+", line
+                ):
+                    # Extract the text after the checkbox
+                    item_text = re.sub(r"^\s*-\s*\[[\s☐]\]\s+", "", line)
+                    unchecked_items.append(f"- [ ] {item_text}")
+                else:
+                    # Keep all other lines
+                    remaining_lines.append(line)
+
+            # Save modified content back if we moved items
             if unchecked_items:
-                # This regex will find the entire checkbox line and remove it from the HTML content
-                uncheckbox_pattern = re.compile(
-                    r"<span[^>]*>☐</span>\s*(.*?)</p>", re.DOTALL
-                )
-                modified_text = re.sub(
-                    uncheckbox_pattern, "", text
-                )  # Remove the checkbox lines
-
-                # Save the modified HTML back to the database
+                modified_text = "\n".join(remaining_lines)
                 self.db.save_new_version(
                     yesterday_str,
                     modified_text,
                     "Unchecked checkbox items moved to next day",
                 )
 
-                # Join unchecked items into a formatted string
-                unchecked_str = "\n".join(
-                    [f"<p>{item}</p>" for item in unchecked_items]
-                )
+                # Join unchecked items into markdown format
+                unchecked_str = "\n".join(unchecked_items) + "\n"
 
                 # Load the unchecked items into the current editor
                 self._load_selected_date(False, unchecked_str)
@@ -569,19 +915,65 @@ class MainWindow(QMainWindow):
     def _on_date_changed(self):
         """
         When the calendar selection changes, save the previous day's note if dirty,
-        so we don't lose that text, then load the newly selected day.
+        so we don't lose that text, then load the newly selected day into current tab.
         """
+        # Skip if we're showing a context menu (right-click shouldn't load dates)
+        if getattr(self, "_showing_context_menu", False):
+            return
+
+        editor = self.current_editor()
+        if not editor:
+            return
+
         # Stop pending autosave and persist current buffer if needed
         try:
             self._save_timer.stop()
         except Exception:
             pass
-        prev = getattr(self, "_active_date_iso", None)
-        if prev and self._dirty:
-            self._save_date(prev, explicit=False)
-        # Now load the newly selected date
-        self._load_selected_date()
 
+        # Save the current editor's content if dirty
+        if hasattr(editor, "current_date") and self._dirty:
+            prev_date_iso = editor.current_date.toString("yyyy-MM-dd")
+            self._save_date(prev_date_iso, explicit=False)
+
+        # Now load the newly selected date into the current tab
+        new_date = self.calendar.selectedDate()
+        self._load_date_into_editor(new_date, editor)
+        editor.current_date = new_date
+
+        # Update tab title
+        current_index = self.tab_widget.currentIndex()
+        if current_index >= 0:
+            self.tab_widget.setTabText(current_index, new_date.toString("yyyy-MM-dd"))
+
+        # Keep tabs sorted by date
+        self._reorder_tabs_by_date()
+
+    # ----------- History handler ------------#
+    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()
+
+    # ----------- Image insert handler ------------#
+    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
+        # Insert each image
+        for path_str in paths:
+            self.editor.insert_image_from_path(Path(path_str))
+
+    # --------------- Database saving of content ---------------- #
     def _save_date(self, date_iso: str, explicit: bool = False, note: str = "autosave"):
         """
         Save editor contents into the given date. Shows status on success.
@@ -589,7 +981,7 @@ class MainWindow(QMainWindow):
         """
         if not self._dirty and not explicit:
             return
-        text = self.editor.to_html_with_embedded_images()
+        text = self.editor.to_markdown()
         try:
             self.db.save_new_version(date_iso, text, note)
         except Exception as e:
@@ -605,10 +997,16 @@ class MainWindow(QMainWindow):
         )
 
     def _save_current(self, explicit: bool = False):
+        """Save the current editor's content."""
         try:
             self._save_timer.stop()
         except Exception:
             pass
+
+        editor = self.current_editor()
+        if not editor or not hasattr(editor, "current_date"):
+            return
+
         if explicit:
             # Prompt for a note
             dlg = SaveDialog(self)
@@ -617,33 +1015,14 @@ class MainWindow(QMainWindow):
             note = dlg.note_text()
         else:
             note = "autosave"
-        # Delegate to _save_date for the currently selected date
-        self._save_date(self._current_date_iso(), explicit, note)
+        # Save the current editor's date
+        date_iso = editor.current_date.toString("yyyy-MM-dd")
+        self._save_date(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()
-
-    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)
@@ -708,7 +1087,7 @@ class MainWindow(QMainWindow):
             QGuiApplication.screenAt(QCursor.pos()) or QGuiApplication.primaryScreen()
         )
         r = screen.availableGeometry()
-        # Center the window in that screen’s available area
+        # Center the window in that screen's available area
         self.move(r.center() - self.rect().center())
 
     # ----------------- Export handler ----------------- #
@@ -775,7 +1154,7 @@ If you want an encrypted backup, choose Backup instead of Export.
             elif selected_filter.startswith("SQL"):
                 self.db.export_sql(filename)
             else:
-                self.db.export_by_extension(filename)
+                raise ValueError("Unrecognised extension!")
 
             QMessageBox.information(self, "Export complete", f"Saved to:\n{filename}")
         except Exception as e:
@@ -837,7 +1216,7 @@ If you want an encrypted backup, choose Backup instead of Export.
             return
         if minutes == 0:
             self._idle_timer.stop()
-            # If you’re currently locked, unlock when user disables the timer:
+            # If currently locked, unlock when user disables the timer:
             if getattr(self, "_locked", False):
                 try:
                     self._locked = False
@@ -851,11 +1230,27 @@ If you want an encrypted backup, choose Backup instead of Export.
                 self._idle_timer.start()
 
     def eventFilter(self, obj, event):
+        # Catch right-clicks on calendar BEFORE selectionChanged can fire
+        if obj == self.calendar and event.type() == QEvent.MouseButtonPress:
+            try:
+                # QMouseEvent in PySide6
+                if event.button() == Qt.RightButton:
+                    self._showing_context_menu = True
+            except Exception:
+                pass
+
         if event.type() == QEvent.KeyPress and not self._locked:
             self._idle_timer.start()
+
+        if event.type() in (QEvent.ApplicationActivate, QEvent.WindowActivate):
+            QTimer.singleShot(0, self._focus_editor_now)
+
         return super().eventFilter(obj, event)
 
     def _enter_lock(self):
+        """
+        Trigger the lock overlay and disable widgets
+        """
         if self._locked:
             return
         self._locked = True
@@ -871,6 +1266,10 @@ If you want an encrypted backup, choose Backup instead of Export.
 
     @Slot()
     def _on_unlock_clicked(self):
+        """
+        Prompt for key to unlock screen
+        If successful, re-enable widgets
+        """
         try:
             ok = self._prompt_for_key_until_valid(first_time=False)
         except Exception as e:
@@ -887,6 +1286,7 @@ If you want an encrypted backup, choose Backup instead of Export.
             if tb:
                 tb.setEnabled(True)
             self._idle_timer.start()
+            QTimer.singleShot(0, self._focus_editor_now)
 
     # ----------------- Close handlers ----------------- #
     def closeEvent(self, event):
@@ -896,9 +1296,88 @@ If you want an encrypted backup, choose Backup instead of Export.
             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()
+            # Ensure we save all tabs before closing
+            for i in range(self.tab_widget.count()):
+                editor = self.tab_widget.widget(i)
+                if editor:
+                    self._save_editor_content(editor)
             self.db.close()
         except Exception:
             pass
         super().closeEvent(event)
+
+    # ----------------- Below logic helps focus the editor ----------------- #
+
+    def _focus_editor_now(self):
+        """Give focus to the editor and ensure the caret is visible."""
+        if getattr(self, "_locked", False):
+            return
+        if not self.isActiveWindow():
+            return
+        editor = self.current_editor()
+        if not editor:
+            return
+        # Belt-and-suspenders: do it now and once more on the next tick
+        editor.setFocus(Qt.ActiveWindowFocusReason)
+        editor.ensureCursorVisible()
+        QTimer.singleShot(
+            0,
+            lambda: (
+                editor.setFocus(Qt.ActiveWindowFocusReason) if editor else None,
+                editor.ensureCursorVisible() if editor else None,
+            ),
+        )
+
+    def _on_app_state_changed(self, state):
+        # Called on macOS/Wayland/Windows when the whole app re-activates
+        if state == Qt.ApplicationActive and self.isActiveWindow():
+            QTimer.singleShot(0, self._focus_editor_now)
+
+    def changeEvent(self, ev):
+        # Called on some platforms when the window's activation state flips
+        super().changeEvent(ev)
+        if ev.type() == QEvent.ActivationChange and self.isActiveWindow():
+            QTimer.singleShot(0, self._focus_editor_now)
+
+    def _set_editor_markdown_preserve_view(
+        self, markdown: str, editor: MarkdownEditor | None = None
+    ):
+        if editor is None:
+            editor = self.current_editor()
+        if not editor:
+            return
+
+        ed = editor
+
+        # Save caret/selection and scroll
+        cur = ed.textCursor()
+        old_pos, old_anchor = cur.position(), cur.anchor()
+        v = ed.verticalScrollBar().value()
+        h = ed.horizontalScrollBar().value()
+
+        # Only touch the doc if it actually changed
+        ed.blockSignals(True)
+        if ed.to_markdown() != markdown:
+            ed.from_markdown(markdown)
+        ed.blockSignals(False)
+
+        # Restore scroll first
+        ed.verticalScrollBar().setValue(v)
+        ed.horizontalScrollBar().setValue(h)
+
+        # Restore caret/selection (bounded to new doc length)
+        doc_length = ed.document().characterCount() - 1
+        old_pos = min(old_pos, doc_length)
+        old_anchor = min(old_anchor, doc_length)
+
+        cur = ed.textCursor()
+        cur.setPosition(old_anchor)
+        mode = (
+            QTextCursor.KeepAnchor if old_anchor != old_pos else QTextCursor.MoveAnchor
+        )
+        cur.setPosition(old_pos, mode)
+        ed.setTextCursor(cur)
+
+        # Refresh highlights if the theme changed
+        if hasattr(self, "findBar"):
+            self.findBar.refresh()