ankigammon 1.0.6__py3-none-any.whl

ankigammon/gui/widgets/position_list.py

@@ -0,0 +1,166 @@
+"""
+Widget for displaying list of parsed positions.
+"""
+
+from typing import List, Optional
+from PySide6.QtWidgets import (
+    QListWidget, QListWidgetItem, QWidget, QVBoxLayout, QLabel, QMenu, QMessageBox,
+    QDialog, QAbstractItemView
+)
+from PySide6.QtCore import Qt, Signal, Slot
+from PySide6.QtGui import QIcon, QAction, QKeyEvent
+import qtawesome as qta
+
+from ankigammon.models import Decision, DecisionType, Player
+from ankigammon.gui.dialogs.note_dialog import NoteEditDialog
+
+
+class PositionListItem(QListWidgetItem):
+    """Custom list item for a decision/position."""
+
+    def __init__(self, decision: Decision, index: int):
+        super().__init__()
+        self.decision = decision
+        self.index = index
+
+        self.setText(f"#{index + 1}: {decision.get_short_display_text()}")
+
+        tooltip = decision.get_metadata_text()
+        if decision.note:
+            tooltip += f"\n\nNote: {decision.note}"
+        self.setToolTip(tooltip)
+
+
+class PositionListWidget(QListWidget):
+    """
+    List widget for displaying parsed positions.
+
+    Signals:
+        position_selected(Decision): Emitted when user selects a position
+        positions_deleted(list): Emitted when user deletes position(s) - List[int] of indices
+    """
+
+    position_selected = Signal(Decision)
+    positions_deleted = Signal(list)
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self.decisions: List[Decision] = []
+
+        self.setVerticalScrollMode(QListWidget.ScrollPerPixel)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._show_context_menu)
+        self.currentItemChanged.connect(self._on_selection_changed)
+
+    def set_decisions(self, decisions: List[Decision]):
+        """Load decisions into the list."""
+        self.clear()
+        self.decisions = decisions
+
+        for i, decision in enumerate(decisions):
+            item = PositionListItem(decision, i)
+            self.addItem(item)
+
+        if decisions:
+            self.setCurrentRow(0)
+
+    @Slot(QListWidgetItem, QListWidgetItem)
+    def _on_selection_changed(self, current, previous):
+        """Handle selection change."""
+        if current and isinstance(current, PositionListItem):
+            self.position_selected.emit(current.decision)
+
+    @Slot()
+    def _show_context_menu(self, pos):
+        """Show context menu for delete action."""
+        selected_items = self.selectedItems()
+
+        if not selected_items:
+            return
+
+        menu = QMenu(self)
+        menu.setCursor(Qt.PointingHandCursor)
+
+        if len(selected_items) == 1:
+            item = selected_items[0]
+            edit_note_action = QAction(
+                qta.icon('fa6s.note-sticky', color='#f9e2af'),
+                "Edit Note...",
+                self
+            )
+            edit_note_action.triggered.connect(lambda: self._edit_note(item))
+            menu.addAction(edit_note_action)
+
+            menu.addSeparator()
+
+        delete_text = "Delete" if len(selected_items) == 1 else f"Delete {len(selected_items)} Items"
+        delete_action = QAction(
+            qta.icon('fa6s.trash', color='#f38ba8'),
+            delete_text,
+            self
+        )
+        delete_action.triggered.connect(self._delete_selected_items)
+        menu.addAction(delete_action)
+
+        menu.exec(self.mapToGlobal(pos))
+
+    def _edit_note(self, item: PositionListItem):
+        """Edit the note for a position."""
+        current_note = item.decision.note or ""
+
+        dialog = NoteEditDialog(current_note, f"Note for position #{item.index + 1}:", self)
+
+        if dialog.exec() == QDialog.Accepted:
+            new_note = dialog.get_text()
+
+            item.decision.note = new_note.strip() if new_note.strip() else None
+
+            tooltip = item.decision.get_metadata_text()
+            if item.decision.note:
+                tooltip += f"\n\nNote: {item.decision.note}"
+            item.setToolTip(tooltip)
+
+    def _delete_selected_items(self):
+        """Delete selected items with confirmation."""
+        selected_items = self.selectedItems()
+
+        if not selected_items:
+            return
+
+        if len(selected_items) == 1:
+            item = selected_items[0]
+            message = f"Delete position #{item.index + 1}?\n\n{item.decision.get_short_display_text()}"
+            title = "Delete Position"
+        else:
+            message = f"Delete {len(selected_items)} selected position(s)?"
+            title = "Delete Positions"
+
+        reply = QMessageBox.question(
+            self,
+            title,
+            message,
+            QMessageBox.Yes | QMessageBox.No
+        )
+
+        if reply == QMessageBox.Yes:
+            indices_to_delete = sorted([item.index for item in selected_items], reverse=True)
+            rows_to_delete = sorted([self.row(item) for item in selected_items], reverse=True)
+            for row in rows_to_delete:
+                self.takeItem(row)
+
+            self.positions_deleted.emit(indices_to_delete)
+
+    def keyPressEvent(self, event: QKeyEvent):
+        """Handle keyboard shortcuts for deletion."""
+        if event.key() in (Qt.Key_Delete, Qt.Key_Backspace):
+            self._delete_selected_items()
+        else:
+            super().keyPressEvent(event)
+
+    def get_selected_decision(self) -> Optional[Decision]:
+        """Get currently selected decision."""
+        item = self.currentItem()
+        if isinstance(item, PositionListItem):
+            return item.decision
+        return None

ankigammon/gui/widgets/smart_input.py

@@ -0,0 +1,268 @@
+"""
+Smart input widget with auto-detection and visual feedback.
+"""
+
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QPlainTextEdit,
+    QLabel, QFrame, QPushButton
+)
+from PySide6.QtCore import Qt, Signal, QTimer
+from PySide6.QtGui import QFont
+import qtawesome as qta
+
+from ankigammon.settings import Settings
+from ankigammon.gui.format_detector import FormatDetector, DetectionResult, InputFormat
+
+
+class SmartInputWidget(QWidget):
+    """
+    Input widget with intelligent format detection.
+
+    Signals:
+        format_detected(DetectionResult): Emitted when format is detected
+    """
+
+    format_detected = Signal(DetectionResult)
+
+    def __init__(self, settings: Settings, parent=None):
+        super().__init__(parent)
+        self.settings = settings
+        self.detector = FormatDetector(settings)
+        self.last_result = None
+
+        # Debounce timer for detection
+        self.detection_timer = QTimer()
+        self.detection_timer.setSingleShot(True)
+        self.detection_timer.timeout.connect(self._run_detection)
+
+        self._setup_ui()
+
+    def _setup_ui(self):
+        """Initialize the user interface."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(12)
+
+        # Label
+        label = QLabel("Input Text:")
+        label.setStyleSheet("font-weight: 600; color: #cdd6f4;")
+        layout.addWidget(label)
+
+        # Text input area
+        self.text_area = QPlainTextEdit()
+        self.text_area.setPlaceholderText(
+            "Paste XG analysis or position IDs here...\n\n"
+            "Examples:\n"
+            "• Full XG analysis (Ctrl+C from eXtreme Gammon)\n"
+            "• XGID, OGID, or GNUID position IDs (one per line)\n"
+            "• Mixed formats supported - auto-detected"
+        )
+
+        # Use fixed-width font for better XGID readability
+        font = QFont("Consolas", 10)
+        if not font.exactMatch():
+            font = QFont("Courier New", 10)
+        self.text_area.setFont(font)
+
+        self.text_area.setLineWrapMode(QPlainTextEdit.NoWrap)
+        self.text_area.setTabChangesFocus(True)
+        self.text_area.setMinimumHeight(300)
+
+        # Dark theme styling
+        self.text_area.setStyleSheet("""
+            QPlainTextEdit {
+                background-color: #1e1e2e;
+                color: #cdd6f4;
+                border: 2px solid #313244;
+                border-radius: 8px;
+                padding: 12px;
+                selection-background-color: #585b70;
+            }
+            QPlainTextEdit:focus {
+                border-color: #89b4fa;
+            }
+        """)
+
+        self.text_area.textChanged.connect(self._on_text_changed)
+        layout.addWidget(self.text_area, stretch=1)
+
+        # Feedback container (outer wrapper with rounded corners)
+        self.feedback_container = QWidget()
+        self.feedback_container.setStyleSheet("""
+            QWidget {
+                background-color: #313244;
+                border-radius: 6px;
+            }
+        """)
+        self.feedback_container.setVisible(False)
+
+        container_layout = QHBoxLayout(self.feedback_container)
+        container_layout.setContentsMargins(0, 0, 0, 0)
+        container_layout.setSpacing(0)
+
+        # Left accent bar (separate widget - avoids Qt border-left + border-radius bug)
+        self.accent_bar = QWidget()
+        self.accent_bar.setFixedWidth(4)
+        self.accent_bar.setStyleSheet("background-color: #6c7086;")
+        container_layout.addWidget(self.accent_bar)
+
+        # Inner content panel
+        self.feedback_panel = QWidget()
+        self.feedback_panel.setStyleSheet("background-color: transparent;")
+        container_layout.addWidget(self.feedback_panel, stretch=1)
+
+        feedback_layout = QHBoxLayout(self.feedback_panel)
+        feedback_layout.setContentsMargins(12, 12, 12, 12)
+        feedback_layout.setSpacing(12)  # Add spacing between icon and text
+
+        # Icon
+        self.feedback_icon = QLabel()
+        self.feedback_icon.setPixmap(qta.icon('fa6s.circle-info', color='#60a5fa').pixmap(20, 20))
+        self.feedback_icon.setMinimumSize(20, 20)  # Minimum size instead of fixed
+        self.feedback_icon.setAlignment(Qt.AlignCenter)
+        self.feedback_icon.setScaledContents(False)  # Prevent pixmap stretching/artifacts
+        feedback_layout.addWidget(self.feedback_icon, alignment=Qt.AlignTop)
+
+        # Text content
+        text_content = QVBoxLayout()
+        text_content.setSpacing(4)
+
+        self.feedback_title = QLabel()
+        self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px;")
+        text_content.addWidget(self.feedback_title)
+
+        self.feedback_detail = QLabel()
+        self.feedback_detail.setStyleSheet("font-size: 12px; color: #a6adc8;")
+        self.feedback_detail.setWordWrap(True)
+        text_content.addWidget(self.feedback_detail)
+
+        feedback_layout.addLayout(text_content, stretch=1)
+
+        # Override button
+        self.override_btn = QPushButton("Override...")
+        self.override_btn.setVisible(False)
+        self.override_btn.setStyleSheet("""
+            QPushButton {
+                background-color: #45475a;
+                color: #cdd6f4;
+                border: none;
+                padding: 6px 12px;
+                border-radius: 4px;
+                font-size: 11px;
+            }
+            QPushButton:hover {
+                background-color: #585b70;
+            }
+        """)
+        self.override_btn.setCursor(Qt.PointingHandCursor)
+        feedback_layout.addWidget(self.override_btn, alignment=Qt.AlignTop)
+
+        layout.addWidget(self.feedback_container)
+
+    def _on_text_changed(self):
+        """Handle text change (debounced)."""
+        # Cancel previous timer, start new one
+        self.detection_timer.stop()
+        self.detection_timer.start(500)  # 500ms debounce
+
+    def _run_detection(self):
+        """Run format detection (after debounce)."""
+        text = self.text_area.toPlainText()
+
+        if not text.strip():
+            self.feedback_container.setVisible(False)
+            self.last_result = None
+            return
+
+        result = self.detector.detect(text)
+        self.last_result = result
+        self._update_feedback_ui(result)
+        self.format_detected.emit(result)
+
+    def _set_feedback_icon(self, icon_name: str, color: str):
+        """Helper to properly set feedback icon."""
+        self.feedback_icon.clear()  # Clear old pixmap first
+        self.feedback_icon.setPixmap(qta.icon(icon_name, color=color).pixmap(20, 20))
+
+    def _set_feedback_style(self, bg_color: str, accent_color: str):
+        """Helper to properly set feedback panel style (avoids Qt border-left + border-radius bug)."""
+        self.feedback_container.setStyleSheet(f"""
+            QWidget {{
+                background-color: {bg_color};
+                border-radius: 6px;
+            }}
+        """)
+        self.accent_bar.setStyleSheet(f"background-color: {accent_color};")
+
+    def _update_feedback_ui(self, result: DetectionResult):
+        """Update feedback panel with detection result."""
+        self.feedback_container.setVisible(True)
+
+        # Update icon and styling based on result
+        if result.format == InputFormat.POSITION_IDS:
+            if result.warnings:
+                # Warning state (GnuBG not configured)
+                self._set_feedback_icon('fa6s.triangle-exclamation', '#fab387')
+                self._set_feedback_style('#2e2416', '#f9e2af')
+                self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #f9e2af;")
+                self.feedback_title.setText(f"{result.details}")
+                self.feedback_detail.setText(
+                    result.warnings[0] + "\nConfigure GnuBG in Settings to analyze positions."
+                )
+            else:
+                # Success state
+                self._set_feedback_icon('fa6s.circle-check', '#a6e3a1')
+                self._set_feedback_style('#1e2d1f', '#a6e3a1')
+                self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #a6e3a1;")
+                self.feedback_title.setText(f"{result.details}")
+
+                # Calculate estimated time
+                est_seconds = result.count * 5  # ~5 seconds per position
+                self.feedback_detail.setText(
+                    f"Will analyze with GnuBG ({self.settings.gnubg_analysis_ply}-ply)\n"
+                    f"Estimated time: ~{est_seconds} seconds"
+                )
+
+        elif result.format == InputFormat.FULL_ANALYSIS:
+            # Success state (blue)
+            self._set_feedback_icon('fa6s.circle-check', '#89b4fa')
+            self._set_feedback_style('#1e2633', '#89b4fa')
+            self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #89b4fa;")
+            self.feedback_title.setText(f"{result.details}")
+
+            # Show preview of first position if available
+            preview_text = "Ready to add to export list"
+            if result.position_previews:
+                preview_text += f"\nFirst position: {result.position_previews[0]}"
+
+            if result.warnings:
+                preview_text += f"\n{result.warnings[0]}"
+
+            self.feedback_detail.setText(preview_text)
+
+        else:
+            # Unknown/error state
+            self._set_feedback_icon('fa6s.triangle-exclamation', '#fab387')
+            self._set_feedback_style('#2e2416', '#fab387')
+            self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #fab387;")
+            self.feedback_title.setText(f"{result.details}")
+
+            warning_text = "Paste XGID/OGID/GNUID or full XG analysis text"
+            if result.warnings:
+                warning_text = "\n".join(result.warnings)
+
+            self.feedback_detail.setText(warning_text)
+
+    def get_text(self) -> str:
+        """Get current input text."""
+        return self.text_area.toPlainText()
+
+    def clear_text(self):
+        """Clear input text."""
+        self.text_area.clear()
+        self.feedback_container.setVisible(False)
+        self.last_result = None
+
+    def get_last_result(self) -> DetectionResult:
+        """Get last detection result."""
+        return self.last_result