easycoder 251104.1__py2.py3-none-any.whl → 251215.2__py2.py3-none-any.whl

easycoder/__init__.py

@@ -1,15 +1,17 @@
 '''EasyCoder for Python'''
 
 from .ec_classes import *
+from .ec_gclasses import *
 from .ec_compiler import *
 from .ec_condition import *
 from .ec_core import *
+from .ec_graphics import *
 from .ec_handler import *
 from .ec_keyboard import *
 from .ec_border import *
 from .ec_program import *
-from .ec_pyside import *
+from .ec_psutil import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "251104.1"
+__version__ = "251215.2"

easycoder/debugger/__init__.py

@@ -0,0 +1,5 @@
+"""EasyCoder debugger module"""
+
+from .ec_debug import Debugger
+
+__all__ = ['Debugger']

easycoder/debugger/ec_dbg_value_display copy.py

@@ -0,0 +1,195 @@
+"""ValueDisplay widget for displaying variable values in the EasyCoder debugger"""
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QFrame,
+    QVBoxLayout,
+    QLabel,
+    QScrollArea,
+)
+from PySide6.QtCore import Qt
+
+
+class ValueDisplay(QWidget):
+    """Widget to display a variable value with type-appropriate formatting"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        vlayout = QVBoxLayout(self)
+        vlayout.setContentsMargins(0, 0, 0, 0)
+        vlayout.setSpacing(2)
+        
+        # Main value label (always visible)
+        self.value_label = QLabel()
+        self.value_label.setStyleSheet("font-family: mono; padding: 1px 2px;")
+        self.value_label.setWordWrap(False)
+        vlayout.addWidget(self.value_label)
+        
+        # Expanded details inside a scroll area (initially hidden)
+        self.details_scroll = QScrollArea()
+        self.details_scroll.setFrameShape(QFrame.Shape.NoFrame)
+        self.details_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.details_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.details_scroll.setWidgetResizable(True)
+        self.details_content = QWidget()
+        self.details_layout = QVBoxLayout(self.details_content)
+        self.details_layout.setContentsMargins(10, 0, 0, 0)
+        self.details_layout.setSpacing(1)
+        self.details_scroll.setWidget(self.details_content)
+        self.details_scroll.hide()
+        vlayout.addWidget(self.details_scroll)
+        
+        self.is_expanded = False
+        self.current_value = None
+        self.max_detail_rows = 10
+    
+    def setValue(self, symbol_record, program):
+        """Update display with current value from symbol record"""
+        if not symbol_record:
+            self.value_label.setText("<not found>")
+            return
+        
+        # Check if variable has value capability
+        symbol_object = program.getObject(symbol_record)
+        if not symbol_object.hasRuntimeValue():
+            self.value_label.setText(f"<{symbol_record.get('type', 'no-value')}>")
+            return
+        
+        # Get the value array
+        value_array = symbol_object.getValues()
+        
+        if not value_array or len(value_array) == 0:
+            self.value_label.setText("<empty>")
+            return
+        
+        # For arrays, show summary
+        if len(value_array) > 1:
+            index = symbol_record.get('index', 0)
+            self.value_label.setText(f"[{len(value_array)} elements] @{index}")
+            
+            # If expanded, show individual elements
+            if self.is_expanded:
+                self._show_array_elements(value_array, index)
+            else:
+                self._hide_details()
+        else:
+            # Single value - show it directly
+            val = program.textify(symbol_object)
+            self._show_single_value(val)
+    
+    def _show_single_value(self, content):
+        """Display a single value element"""
+        if content is None or content == {}:
+            self.value_label.setText("<none>")
+            return
+        
+        if isinstance(content, bool):
+            self.value_label.setText(str(content))
+        elif isinstance(content, int):
+            self.value_label.setText(str(content))
+        elif isinstance(content, str):
+            # Check if it's JSON
+            if isinstance(content, str) and content.strip().startswith(('{', '[')):
+                # Likely JSON - show truncated with expand option
+                self._set_elided_text(str(content), multiplier=2.0)
+                if self.is_expanded and len(content) > 50:
+                    self._show_text_details(content)
+            else:
+                # Regular string
+                text_s = str(content)
+                self._set_elided_text(text_s, multiplier=2.0)
+                if self.is_expanded:
+                    self._show_text_details(text_s)
+        else:
+            self.value_label.setText(str(content))
+    
+    def _show_array_elements(self, value_array, current_index):
+        """Show expanded array elements"""
+        self.details_scroll.show()
+        # Clear existing
+        while self.details_layout.count():
+            item = self.details_layout.takeAt(0)
+            if item.widget():
+                item.widget().deleteLater()
+
+        # Show all elements with internal vertical scrolling capped to N lines
+        for i in range(len(value_array)):
+            val = value_array[i]
+            marker = '→ ' if i == current_index else '  '
+            
+            if val is None or val == {}:
+                text = f"{marker}[{i}]: <none>"
+            else:
+                val_type = val.get('type', '?')
+                content = val.get('content', '')
+                if val_type == 'str':
+                    # keep each element concise
+                    s = str(content)
+                    if len(s) > 120:
+                        content = s[:120] + '...'
+                text = f'{marker}[{i}]: {content}'
+            
+            lbl = QLabel(text)
+            lbl.setStyleSheet("font-family: mono; font-size: 9pt;")
+            self.details_layout.addWidget(lbl)
+        # Cap scroll area height to max_detail_rows
+        fm = self.fontMetrics()
+        max_h = int(self.max_detail_rows * fm.height() * 1.2)
+        self.details_scroll.setMaximumHeight(max_h)
+    
+    def _show_text_details(self, text):
+        """Show full text in details area"""
+        self.details_scroll.show()
+        # Clear existing
+        while self.details_layout.count():
+            item = self.details_layout.takeAt(0)
+            if item.widget():
+                item.widget().deleteLater()
+        
+        lbl = QLabel(text)
+        lbl.setStyleSheet("font-family: mono; font-size: 9pt;")
+        lbl.setWordWrap(True)
+        self.details_layout.addWidget(lbl)
+        # Cap to max_detail_rows
+        fm = self.fontMetrics()
+        max_h = int(self.max_detail_rows * fm.height() * 1.2)
+        self.details_scroll.setMaximumHeight(max_h)
+    
+    def _hide_details(self):
+        """Hide expanded details"""
+        self.details_scroll.hide()
+    
+    def toggleExpand(self):
+        """Toggle between expanded and compact view"""
+        self.is_expanded = not self.is_expanded
+        # Caller should call setValue again to refresh display
+
+    def _approx_available_width(self) -> int:
+        try:
+            # Try to find nearest scroll area's viewport width
+            w = self
+            depth = 0
+            while w and depth < 6:
+                if isinstance(w, QScrollArea):
+                    return max(200, w.viewport().width())
+                w = w.parentWidget()
+                depth += 1
+            # Fallback to our own width or a safe default
+            return max(240, self.width())
+        except Exception:
+            return 320
+
+    def _set_elided_text(self, text: str, multiplier: float = 2.0):
+        try:
+            fm = self.value_label.fontMetrics()
+            avail = int(self._approx_available_width() * multiplier)
+            # Apply quotes for display
+            quoted = f'"{text}"'
+            elided = fm.elidedText(quoted, Qt.TextElideMode.ElideRight, max(80, avail))
+            self.value_label.setText(elided)
+        except Exception:
+            # Fallback simple trim
+            s = text
+            if len(s) > 160:
+                s = s[:160] + '...'
+            self.value_label.setText(f'"{s}"')

easycoder/debugger/ec_dbg_value_display.py

@@ -0,0 +1,23 @@
+"""ValueDisplay widget for displaying variable values in the EasyCoder debugger"""
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QFrame,
+    QVBoxLayout,
+    QLabel,
+    QScrollArea,
+)
+from PySide6.QtCore import Qt
+
+
+class ValueDisplay(QLabel):
+    """Widget to display a variable value with type-appropriate formatting"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+    
+    def setValue(self, program, symbol_name):
+        record = program.getVariable(symbol_name)
+        value = program.textify(record)
+        self.setText(str(value))
+

easycoder/debugger/ec_dbg_watch_list copy.py

@@ -0,0 +1,219 @@
+"""WatchListWidget for managing the variable watch list in the EasyCoder debugger"""
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QFrame,
+    QHBoxLayout,
+    QVBoxLayout,
+    QGridLayout,
+    QLabel,
+    """WatchListWidget for managing the variable watch list in the EasyCoder debugger
+
+    Simplified to show variables in single-line form: `Name = value`.
+    """
+
+    from PySide6.QtWidgets import (
+        QWidget,
+        QHBoxLayout,
+        QVBoxLayout,
+        QLabel,
+        QPushButton,
+        QSizePolicy,
+    )
+    from .ec_dbg_value_display import ValueDisplay
+
+
+    class WatchListWidget(QWidget):
+        """Simple watch list that renders each variable on a single line."""
+
+        def __init__(self, debugger):
+            super().__init__(debugger)
+            self.debugger = debugger
+            self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+            self._rows: dict[str, dict] = {}
+            self._variable_set: set[str] = set()
+            self._placeholder: QLabel | None = None
+
+            self.layout = QVBoxLayout(self)
+            self.layout.setContentsMargins(0, 0, 0, 0)
+            self.layout.setSpacing(2)
+
+            self._show_placeholder()
+
+        # ------------------------------------------------------------------
+        def _show_placeholder(self):
+            if self._placeholder is not None:
+                return
+            self._placeholder = QLabel("No variables watched. Click + to add.")
+            self._placeholder.setStyleSheet("color: #666; font-style: italic; padding: 4px 2px;")
+            self.layout.addWidget(self._placeholder)
+
+        def _hide_placeholder(self):
+            if self._placeholder is None:
+                return
+            self.layout.removeWidget(self._placeholder)
+            self._placeholder.deleteLater()
+            self._placeholder = None
+
+        # ------------------------------------------------------------------
+        def addVariable(self, name: str):
+            if not name or name in self._variable_set:
+                return
+            if not hasattr(self.debugger, 'watched'):
+                self.debugger.watched = []  # type: ignore[attr-defined]
+            if name not in self.debugger.watched:  # type: ignore[attr-defined]
+                self.debugger.watched.append(name)  # type: ignore[attr-defined]
+
+            # Ensure placeholder hidden
+            self._hide_placeholder()
+
+            # Build a simple row: [ QLabel("Name = value") | remove_btn ]
+            row_widget = QWidget(self)
+            row_layout = QHBoxLayout(row_widget)
+            row_layout.setContentsMargins(4, 0, 4, 0)
+            row_layout.setSpacing(6)
+
+            label = QLabel("")
+            label.setWordWrap(False)
+            row_layout.addWidget(label, 1)
+
+            remove_btn = QPushButton("–")
+            remove_btn.setFixedSize(22, 22)
+
+            def on_remove():
+                try:
+                    if hasattr(self.debugger, 'watched') and name in self.debugger.watched:  # type: ignore[attr-defined]
+                        self.debugger.watched.remove(name)  # type: ignore[attr-defined]
+                    if name in self._variable_set:
+                        self._variable_set.remove(name)
+                    self.layout.removeWidget(row_widget)
+                    row_widget.deleteLater()
+                    self._rows.pop(name, None)
+                    if not self._rows:
+                        """WatchListWidget for managing the variable watch list in the EasyCoder debugger
+
+                        Simplified to show variables in single-line form: `Name = value`.
+                        """
+
+                        from PySide6.QtWidgets import (
+                            QWidget,
+                            QHBoxLayout,
+                            QVBoxLayout,
+                            QLabel,
+                            QPushButton,
+                            QSizePolicy,
+                        )
+                        from .ec_dbg_value_display import ValueDisplay
+
+
+                        class WatchListWidget(QWidget):
+                            """Simple watch list that renders each variable on a single line."""
+
+                            def __init__(self, debugger):
+                                super().__init__(debugger)
+                                self.debugger = debugger
+                                self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+                                self._rows: dict[str, dict] = {}
+                                self._variable_set: set[str] = set()
+                                self._placeholder: QLabel | None = None
+
+                                self.layout = QVBoxLayout(self)
+                                self.layout.setContentsMargins(0, 0, 0, 0)
+                                self.layout.setSpacing(2)
+
+                                self._show_placeholder()
+
+                            # ------------------------------------------------------------------
+                            def _show_placeholder(self):
+                                if self._placeholder is not None:
+                                    return
+                                self._placeholder = QLabel("No variables watched. Click + to add.")
+                                self._placeholder.setStyleSheet("color: #666; font-style: italic; padding: 4px 2px;")
+                                self.layout.addWidget(self._placeholder)
+
+                            def _hide_placeholder(self):
+                                if self._placeholder is None:
+                                    return
+                                self.layout.removeWidget(self._placeholder)
+                                self._placeholder.deleteLater()
+                                self._placeholder = None
+
+                            # ------------------------------------------------------------------
+                            def addVariable(self, name: str):
+                                if not name or name in self._variable_set:
+                                    return
+                                if not hasattr(self.debugger, 'watched'):
+                                    self.debugger.watched = []  # type: ignore[attr-defined]
+                                if name not in self.debugger.watched:  # type: ignore[attr-defined]
+                                    self.debugger.watched.append(name)  # type: ignore[attr-defined]
+
+                                # Ensure placeholder hidden
+                                self._hide_placeholder()
+
+                                # Build a simple row: [ QLabel("Name = value") | remove_btn ]
+                                row_widget = QWidget(self)
+                                row_layout = QHBoxLayout(row_widget)
+                                row_layout.setContentsMargins(4, 0, 4, 0)
+                                row_layout.setSpacing(6)
+
+                                label = QLabel("")
+                                label.setWordWrap(False)
+                                row_layout.addWidget(label, 1)
+
+                                remove_btn = QPushButton("–")
+                                remove_btn.setFixedSize(22, 22)
+
+                                def on_remove():
+                                    try:
+                                        if hasattr(self.debugger, 'watched') and name in self.debugger.watched:  # type: ignore[attr-defined]
+                                            self.debugger.watched.remove(name)  # type: ignore[attr-defined]
+                                        if name in self._variable_set:
+                                            self._variable_set.remove(name)
+                                        self.layout.removeWidget(row_widget)
+                                        row_widget.deleteLater()
+                                        self._rows.pop(name, None)
+                                        if not self._rows:
+                                            self._show_placeholder()
+                                    except Exception:
+                                        pass
+
+                                remove_btn.clicked.connect(on_remove)
+                                row_layout.addWidget(remove_btn, 0)
+
+                                # Track row
+                                self.layout.addWidget(row_widget)
+                                self._rows[name] = {
+                                    'widget': row_widget,
+                                    'label': label,
+                                }
+                                self._variable_set.add(name)
+
+                                # Initial refresh for the new row
+                                try:
+                                    self._refresh_one(name, self.debugger.program)
+                                except Exception:
+                                    pass
+
+                            # ------------------------------------------------------------------
+                            def _refresh_one(self, name: str, program):
+                                row = self._rows.get(name)
+                                if not row:
+                                    return
+                                try:
+                                    # ValueDisplay reduced to textify given symbol name
+                                    val_display = ValueDisplay()
+                                    val_display.setValue(program, name)
+                                    value_text = val_display.text()
+                                except Exception as e:
+                                    value_text = f"<error: {e}>"
+                                row['label'].setText(f"{name} = {value_text}")
+
+                            # ------------------------------------------------------------------
+                            def refreshVariables(self, program):
+                                if not self._rows:
+                                    self._show_placeholder()
+                                    return
+                                for name in list(self._rows.keys()):
+                                    self._refresh_one(name, program)

easycoder/debugger/ec_dbg_watchlist.py

@@ -0,0 +1,159 @@
+"""WatchListWidget showing variables on a single line with scrollable values."""
+
+import bisect
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QHBoxLayout,
+    QVBoxLayout,
+    QLabel,
+    QPushButton,
+    QSizePolicy,
+    QScrollArea,
+)
+from PySide6.QtCore import Qt
+from .ec_dbg_value_display import ValueDisplay
+
+
+class WatchListWidget(QWidget):
+    def __init__(self, debugger):
+        super().__init__(debugger)
+        self.debugger = debugger
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+        self._rows: dict[str, dict] = {}
+        self._variable_set: set[str] = set()
+        self._order: list[str] = []
+        self._placeholder: QLabel | None = None
+
+        # Outer layout: scrollable labels (left) and fixed button column (right)
+        outer = QHBoxLayout(self)
+        outer.setContentsMargins(0, 0, 0, 0)
+        outer.setSpacing(2)
+
+        # Left: scroll area for labels
+        self.scroll = QScrollArea(self)
+        self.scroll.setWidgetResizable(True)
+        self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+
+        self.content = QWidget()
+        self.content_layout = QVBoxLayout(self.content)
+        self.content_layout.setContentsMargins(4, 2, 4, 2)
+        self.content_layout.setSpacing(4)
+        self.content_layout.addStretch(1)  # keep items grouped at the top
+
+        self.scroll.setWidget(self.content)
+        outer.addWidget(self.scroll, 1)
+
+        # Right: button column, top-aligned
+        self.buttons_column = QVBoxLayout()
+        self.buttons_column.setContentsMargins(0, 2, 4, 2)
+        self.buttons_column.setSpacing(4)
+        self.buttons_column.addStretch(1)
+        outer.addLayout(self.buttons_column)
+
+        self._show_placeholder()
+
+    def _show_placeholder(self):
+        if self._placeholder is not None:
+            return
+        self._placeholder = QLabel("No variables watched. Click + to add.")
+        self._placeholder.setStyleSheet("color: #666; font-style: italic; padding: 4px 2px;")
+        self.content_layout.insertWidget(self.content_layout.count() - 1, self._placeholder)
+
+    def _hide_placeholder(self):
+        if self._placeholder is None:
+            return
+        self.content_layout.removeWidget(self._placeholder)
+        self._placeholder.deleteLater()
+        self._placeholder = None
+
+    def addVariable(self, name: str):
+        if not name or name in self._variable_set:
+            return
+        if not hasattr(self.debugger, 'watched'):
+            self.debugger.watched = []  # type: ignore[attr-defined]
+        if name not in self.debugger.watched:  # type: ignore[attr-defined]
+            bisect.insort(self.debugger.watched, name)  # type: ignore[attr-defined]
+
+        self._hide_placeholder()
+
+        # Row with label
+        row_widget = QWidget(self)
+        row_layout = QHBoxLayout(row_widget)
+        row_layout.setContentsMargins(4, 0, 4, 0)
+        row_layout.setSpacing(6)
+
+        label = QLabel("")
+        label.setWordWrap(False)
+        row_layout.addWidget(label, 1)
+
+        # Remove button in separate column
+        remove_btn = QPushButton("-")
+        remove_btn.setFixedWidth(22)
+
+        def on_remove():
+            try:
+                if hasattr(self.debugger, 'watched') and name in self.debugger.watched:  # type: ignore[attr-defined]
+                    self.debugger.watched.remove(name)  # type: ignore[attr-defined]
+                if name in self._variable_set:
+                    self._variable_set.remove(name)
+                if name in self._order:
+                    self._order.remove(name)
+                self.content_layout.removeWidget(row_widget)
+                row_widget.deleteLater()
+                self.buttons_column.removeWidget(remove_btn)
+                remove_btn.deleteLater()
+                self._rows.pop(name, None)
+                if not self._rows:
+                    self._show_placeholder()
+            except Exception:
+                pass
+
+        remove_btn.clicked.connect(on_remove)
+
+        insert_pos = bisect.bisect_left(self._order, name)
+        self._order.insert(insert_pos, name)
+        # Insert label row above stretch, keeping alphabetical order
+        self.content_layout.insertWidget(insert_pos, row_widget)
+        # Insert button above stretch on the right, same position
+        self.buttons_column.insertWidget(insert_pos, remove_btn)
+
+        # Align button height to row height
+        row_widget.adjustSize()
+        btn_h = row_widget.sizeHint().height()
+        if btn_h > 0:
+            remove_btn.setFixedHeight(btn_h)
+
+        self._rows[name] = {
+            'widget': row_widget,
+            'label': label,
+            'button': remove_btn,
+        }
+        self._variable_set.add(name)
+
+        try:
+            self._refresh_one(name, self.debugger.program)
+        except Exception:
+            pass
+
+    def _refresh_one(self, name: str, program):
+        row = self._rows.get(name)
+        if not row:
+            return
+        try:
+            val_display = ValueDisplay()
+            val_display.setValue(program, name)
+            value_text = val_display.text()
+        except Exception as e:
+            value_text = f"<error: {e}>"
+        row['label'].setText(f"{name} = {value_text}")
+
+    def refreshVariables(self, program):
+        if not self._rows:
+            self._show_placeholder()
+            return
+        for name in list(self._rows.keys()):
+            self._refresh_one(name, program)