mainmenu.py

from __future__ import annotations

import ctypes
import logging
import sys
from typing import List, Optional, Protocol

from PyQt6.QtCore import QEvent, QObject, QPoint, QSize, Qt, pyqtSignal
from PyQt6.QtGui import QRegion
from PyQt6.QtWidgets import (
    QApplication,
    QFrame,
    QHBoxLayout,
    QLabel,
    QListWidget,
    QListWidgetItem,
    QStyledItemDelegate,
    QVBoxLayout,
    QWidget,
)

from combo_popup import _disable_windows_rounded_corners

LOGGER = logging.getLogger(__name__)

MENU_POPUP_STYLE = """
QFrame#MenuPopup {
    background-color: #202020;
    border: none;
    border-radius: 0px;
}
QListWidget {
    background-color: #202020;
    color: #D6D6D6;
    border: none;
    border-radius: 0px;
    outline: 0px;
    padding: 0px;
    font: 10pt "Segoe UI";
}
QListWidget::item {
    min-height: 32px;
    padding: 0px 24px 0px 10px;
    border: none;
    border-radius: 0px;
    color: #D6D6D6;
    background-color: transparent;
}
QListWidget::item:selected {
    background-color: #202020;
    color: #D6D6D6;
}
QListWidget::item:hover {
    background-color: #5B3A8C;
}
QScrollBar {
    width: 0px;
    height: 0px;
    border: none;
    background: transparent;
}
"""


class _MenuItemDelegate(QStyledItemDelegate):
    """Delegate that renders shortcut text aligned to the right."""

    def __init__(self, parent: Optional[QWidget] = None) -> None:
        super().__init__(parent)

    def sizeHint(self, option, index) -> QSize:  # noqa: N802
        return QSize(option.rect.width(), 32)

    def paint(self, painter, option, index) -> None:  # noqa: N802
        super().paint(painter, option, index)
        shortcut = index.data(Qt.ItemDataRole.UserRole + 1)
        if not shortcut:
            return
        from PyQt6.QtGui import QColor, QFontMetrics

        painter.save()
        painter.setPen(QColor("#6a6a72"))
        painter.setFont(option.font)
        fm = QFontMetrics(option.font)
        text_rect = option.rect.adjusted(0, 0, -10, 0)
        painter.drawText(text_rect, Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter, str(shortcut))
        painter.restore()


class _MenuPopup(QFrame):
    """Frameless popup that looks identical to the combo popup."""

    itemActivated = pyqtSignal(int)
    closed = pyqtSignal()

    def __init__(self, items: List[str], shortcuts: List[str], parent: Optional[QWidget] = None) -> None:
        super().__init__(
            parent,
            Qt.WindowType.Tool
            | Qt.WindowType.FramelessWindowHint
            | Qt.WindowType.NoDropShadowWindowHint,
        )
        self.setObjectName("MenuPopup")
        self.setFrameShape(QFrame.Shape.NoFrame)
        self.setStyleSheet(MENU_POPUP_STYLE)

        root = QVBoxLayout(self)
        root.setContentsMargins(0, 0, 0, 0)
        root.setSpacing(0)

        self._list = QListWidget(self)
        self._list.setFrameShape(QFrame.Shape.NoFrame)
        self._list.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self._list.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self._list.setSpacing(0)
        self._list.setStyleSheet(MENU_POPUP_STYLE)
        self._list.setItemDelegate(_MenuItemDelegate(self._list))

        for i, text in enumerate(items):
            item = QListWidgetItem(text)
            item.setData(Qt.ItemDataRole.UserRole, i)
            item.setData(Qt.ItemDataRole.UserRole + 1, shortcuts[i] if i < len(shortcuts) else "")
            item.setSizeHint(QSize(200, 32))
            self._list.addItem(item)

        self._list.itemClicked.connect(self._on_click)
        root.addWidget(self._list)

        height = self._list.count() * 32
        self.setFixedSize(220, height)

    def _on_click(self, item: QListWidgetItem) -> None:
        row = item.data(Qt.ItemDataRole.UserRole)
        if isinstance(row, int):
            self.itemActivated.emit(row)
        self.close()

    def keyPressEvent(self, event) -> None:  # noqa: N802
        if event.key() == Qt.Key.Key_Escape:
            self.close()
            return
        super().keyPressEvent(event)


class _MenuButton(QLabel):
    """Clickable label that acts as a menu bar item."""

    triggered = pyqtSignal()

    _STYLE_NORMAL = (
        "background-color: transparent !important;"
        "padding: 6px 12px;"
        "border: none;"
        "border-radius: 0px;"
        "color: #D6D6D6;"
        "font: 10pt 'Segoe UI';"
    )
    _STYLE_HOVER = (
        "background-color: #5B3A8C !important;"
        "padding: 6px 12px;"
        "border: none;"
        "border-radius: 0px;"
        "color: #D6D6D6;"
        "font: 10pt 'Segoe UI';"
    )

    def __init__(self, text: str, parent: Optional[QWidget] = None) -> None:
        super().__init__(text, parent)
        self._hovered = False
        self._popup: _MenuPopup | None = None
        self._event_filter_installed = False
        self.setCursor(Qt.CursorShape.PointingHandCursor)
        self.setStyleSheet(self._STYLE_NORMAL)

    def _update_style(self) -> None:
        active = self._hovered or (self._popup is not None and self._popup.isVisible())
        self.setStyleSheet(self._STYLE_HOVER if active else self._STYLE_NORMAL)

    def enterEvent(self, event) -> None:  # noqa: N802
        self._hovered = True
        self._update_style()

    def leaveEvent(self, event) -> None:  # noqa: N802
        self._hovered = False
        self._update_style()

    def mousePressEvent(self, event) -> None:  # noqa: N802
        if self._popup is not None and self._popup.isVisible():
            self._close_popup()
            event.accept()
            return
        self._show_popup()
        event.accept()

    def _show_popup(self) -> None:
        if self._popup is not None and self._popup.isVisible():
            self._close_popup()
            return

        actions = self._actions
        if not actions:
            return

        texts: List[str] = []
        shortcuts: List[str] = []
        for act in actions:
            if act is None:
                continue
            texts.append(act.text())
            sc = act.shortcut().toString()
            shortcuts.append(sc)

        popup = _MenuPopup(texts, shortcuts)
        popup.itemActivated.connect(lambda idx: self._activate_action(idx))

        pos = self.mapToGlobal(QPoint(0, self.height()))
        popup.move(pos)

        self._popup = popup
        popup.closed.connect(self._on_popup_closed)
        popup.destroyed.connect(self._on_popup_closed)

        app = QApplication.instance()
        if app is not None and not self._event_filter_installed:
            app.installEventFilter(self)
            self._event_filter_installed = True

        _disable_windows_rounded_corners(popup)
        popup.show()
        _disable_windows_rounded_corners(popup)
        self._update_style()
        popup.setMask(QRegion(popup.rect()))

    def _activate_action(self, index: int) -> None:
        action = self._nth_action(index)
        if action is not None and action.isEnabled():
            action.trigger()
        self._close_popup()

    def _nth_action(self, index: int):
        actions = self._actions
        real = [a for a in actions if a is not None]
        if 0 <= index < len(real):
            return real[index]
        return None

    def _close_popup(self) -> None:
        popup = self._popup
        self._popup = None
        if popup is not None:
            popup.close()
            popup.deleteLater()
        app = QApplication.instance()
        if app is not None and self._event_filter_installed:
            app.removeEventFilter(self)
            self._event_filter_installed = False
        self._update_style()

    def _on_popup_closed(self) -> None:
        self._close_popup()

    def eventFilter(self, watched, event) -> bool:  # noqa: N802
        if self._popup is None or not self._popup.isVisible():
            return False
        if event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_Escape:
            self._close_popup()
            return True
        if event.type() != QEvent.Type.MouseButtonPress:
            return False

        pos = event.globalPosition().toPoint()
        clicked = QApplication.widgetAt(pos)
        if clicked is None:
            self._close_popup()
            return False
        if clicked is self or self.isAncestorOf(clicked):
            return False
        if self._popup is not None and (clicked is self._popup or self._popup.isAncestorOf(clicked)):
            return False

        self._close_popup()
        return False


class FileActionProvider(Protocol):
    """Protocol describing the actions required for top-level menus."""

    act_file_new: object
    act_file_open: object
    act_file_save: object
    act_file_import_txt: object
    act_file_export_txt: object
    act_file_export_json: object
    act_language_english: object
    act_language_russian: object
    act_edit_undo: object
    act_edit_redo: object


class MainMenuBar(QWidget):
    """Application menu bar with fully custom popup menus."""

    def __init__(self, parent: QWidget, actions: FileActionProvider) -> None:
        super().__init__(parent)
        self.setFixedHeight(32)
        self.setStyleSheet("background: #202020; border: none;")

        layout = QHBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)

        self._file_btn = _MenuButton("")
        self._edit_btn = _MenuButton("")
        self._lang_btn = _MenuButton("")

        self._file_btn._actions = [
            actions.act_file_new,
            actions.act_file_open,
            actions.act_file_save,
            None,  # separator
            actions.act_file_import_txt,
            actions.act_file_export_txt,
            actions.act_file_export_json,
        ]
        self._edit_btn._actions = [
            actions.act_edit_undo,
            actions.act_edit_redo,
        ]
        self._lang_btn._actions = [
            actions.act_language_english,
            actions.act_language_russian,
        ]

        layout.addWidget(self._file_btn)
        layout.addWidget(self._edit_btn)
        layout.addWidget(self._lang_btn)
        layout.addStretch(1)

    def retranslate(self, *, file_menu_title: str, edit_menu_title: str, languages_menu_title: str) -> None:
        self._file_btn.setText(file_menu_title)
        self._edit_btn.setText(edit_menu_title)
        self._lang_btn.setText(languages_menu_title)