easycoder 250406.1__py2.py3-none-any.whl → 250422.3__py2.py3-none-any.whl

easycoder/__init__.py

@@ -9,4 +9,4 @@ from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250406.1"
+__version__ = "250422.3"

easycoder/ec_core.py

@@ -1597,6 +1597,13 @@ class Core(Handler):
         target['locked'] = False
         return self.nextPC()
 
+    def k_use(self, command):
+        if self.nextIs('graphics'):
+            from .ec_pyside6 import Graphics
+            self.program.classes.append(Graphics)
+            self.program.processClasses()
+            return True
+
     # Declare a general-purpose variable
     def k_variable(self, command):
         return self.compileVariable(command, True)

easycoder/ec_pyside6.py

@@ -0,0 +1,517 @@
+import sys
+from easycoder import Handler, FatalError, RuntimeError
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QComboBox,
+    QDateEdit,
+    QDateTimeEdit,
+    QDial,
+    QDoubleSpinBox,
+    QFontComboBox,
+    QLabel,
+    QLCDNumber,
+    QLineEdit,
+    QListWidget,
+    QMainWindow,
+    QProgressBar,
+    QPushButton,
+    QRadioButton,
+    QSlider,
+    QSpinBox,
+    QTimeEdit,
+    QVBoxLayout,
+    QHBoxLayout,
+    QGridLayout,
+    QStackedLayout,
+    QGroupBox,
+    QWidget,
+    QSpacerItem,
+    QSizePolicy
+)
+
+class Graphics(Handler):
+
+    class MainWindow(QMainWindow):
+
+        def __init__(self):
+            super().__init__()
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+
+    def getName(self):
+        return 'pyside6'
+
+    def closeEvent(self):
+        print('window closed')
+
+    #############################################################################
+    # Keyword handlers
+
+    # Add a widget to a layout
+    # add [stretch] {widget} to {layout}
+    # add stretch to {layout}
+    def k_add(self, command):
+        command['stretch'] = False
+        if self.nextIs('stretch'):
+            if self.peek() == 'to':
+                command['widget'] = 'stretch'
+            elif self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                command['widget'] = record['name']
+                command['stretch'] = True
+            else: return False
+        elif self.isSymbol():
+            record = self.getSymbolRecord()
+            command['widget'] = record['name']
+        else: return False
+        if self.nextIs('to'):
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                command['layout'] = record['name']
+                self.add(command)
+                return True
+        return False
+    
+    def r_add(self, command):
+        layoutRecord = self.getVariable(command['layout'])
+        widget = command['widget']
+        if widget == 'stretch':
+            layoutRecord['widget'].addStretch()
+        else:
+            widgetRecord = self.getVariable(widget)
+            layoutRecord = self.getVariable(command['layout'])
+            widget = widgetRecord['widget']
+            layout = layoutRecord['widget']
+            stretch = command['stretch']
+            if widgetRecord['keyword'] == 'layout':
+                if layoutRecord['keyword'] == 'groupbox':
+                    if widgetRecord['keyword'] == 'layout':
+                        layout.setLayout(widget)
+                    else:
+                        RuntimeError(self.program, 'Can only add a layout to a groupbox')
+                else:
+                    if stretch: layout.addLayout(widget, stretch=1)
+                    else: layout.addLayout(widget)
+            else:
+                if stretch: layout.addWidget(widget, stretch=1)
+                else: layout.addWidget(widget)
+        return self.nextPC()
+
+    # Declare a checkbox variable
+    def k_checkbox(self, command):
+        return self.compileVariable(command, False)
+
+    def r_checkbox(self, command):
+        return self.nextPC()
+
+    # Close a window
+    def k_close(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'window':
+                command['name'] = record['name']
+                self.add(command)
+                return True
+        return False
+    
+    def r_close(self, command):
+        self.getVariable(command['name'])['window'].close()
+        return self.nextPC()
+
+    # Create a window
+    def k_createWindow(self, command):
+        command['title'] = 'Default'
+        command['x'] = self.compileConstant(100)
+        command['y'] = self.compileConstant(100)
+        command['w'] = self.compileConstant(640)
+        command['h'] = self.compileConstant(480)
+        while True:
+            token = self.peek()
+            if token in ['title', 'at', 'size']:
+                self.nextToken()
+                if token == 'title': command['title'] = self.nextValue()
+                elif token == 'at':
+                    command['x'] = self.nextValue()
+                    command['y'] = self.nextValue()
+                elif token == 'size':
+                    command['w'] = self.nextValue()
+                    command['h'] = self.nextValue()
+            else: break
+        self.add(command)
+        return True
+
+    # Create a widget
+    def k_createLayout(self, command):
+        if self.nextIs('type'):
+            command['type'] = self.nextToken()
+            self.add(command)
+            return True
+        return False
+
+    def k_createGroupBox(self, command):
+        if self.peek() == 'title':
+            self.nextToken()
+            title = self.nextValue()
+        else: title = ''
+        command['title'] = title
+        self.add(command)
+        return True
+
+    def k_createLabel(self, command):
+        text = ''
+        while True:
+            token = self.peek()
+            if token == 'text':
+                self.nextToken()
+                text = self.nextValue()
+            elif token == 'size':
+                self.nextToken()
+                command['size'] = self.nextValue()
+            else: break
+        command['text'] = text
+        self.add(command)
+        return True
+
+    def k_createPushbutton(self, command):
+        text = ''
+        while True:
+            token = self.peek()
+            if token == 'text':
+                self.nextToken()
+                text = self.nextValue()
+            elif token == 'size':
+                self.nextToken()
+                command['size'] = self.nextValue()
+            else: break
+        command['text'] = text
+        self.add(command)
+        return True
+
+    def k_createCheckBox(self, command):
+        if self.peek() == 'text':
+            self.nextToken()
+            text = self.nextValue()
+        else: text = ''
+        command['text'] = text
+        self.add(command)
+        return True
+
+    def k_createLineEdit(self, command):
+        if self.peek() == 'size':
+            self.nextToken()
+            size = self.nextValue()
+        else: size = 10
+        command['size'] = size
+        self.add(command)
+        return True
+
+    def k_createListWidget(self, command):
+        self.add(command)
+        return True
+
+    def k_create(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            command['name'] = record['name']
+            keyword = record['keyword']
+            if keyword == 'window': return self.k_createWindow(command)
+            elif keyword == 'layout': return self.k_createLayout(command)
+            elif keyword == 'groupbox': return self.k_createGroupBox(command)
+            elif keyword == 'label': return self.k_createLabel(command)
+            elif keyword == 'pushbutton': return self.k_createPushbutton(command)
+            elif keyword == 'checkbox': return self.k_createCheckBox(command)
+            elif keyword == 'lineinput': return self.k_createLineEdit(command)
+            elif keyword == 'listbox': return self.k_createListWidget(command)
+        return False
+    
+    def r_createWindow(self, command, record):
+        window = self.MainWindow()
+        window.setWindowTitle(self.getRuntimeValue(command['title']))
+        x = self.getRuntimeValue(command['x'])
+        y = self.getRuntimeValue(command['y'])
+        w = self.getRuntimeValue(command['w'])
+        h = self.getRuntimeValue(command['h'])
+        window.setGeometry(x, y, w, h)
+        record['window'] = window
+        return self.nextPC()
+    
+    def r_createLayout(self, command, record):
+        type = command['type']
+        if type == 'QHBoxLayout': layout = QHBoxLayout()
+        elif type == 'QGridLayout': layout = QGridLayout()
+        elif type == 'QStackedLayout': layout = QStackedLayout()
+        else: layout = QVBoxLayout()
+        layout.setContentsMargins(5,0,5,0)
+        record['widget'] = layout
+        return self.nextPC()
+    
+    def r_createGroupBox(self, command, record):
+        groupbox = QGroupBox(self.getRuntimeValue(command['title']))
+        groupbox.setAlignment(Qt.AlignLeft)
+        record['widget'] = groupbox
+        return self.nextPC()
+    
+    def r_createLabel(self, command, record):
+        label = QLabel(self.getRuntimeValue(command['text']))
+        if 'size' in command:
+            fm = label.fontMetrics()
+            c = label.contentsMargins()
+            w = fm.horizontalAdvance('x') * self.getRuntimeValue(command['size']) +c.left()+c.right()
+            label.setMaximumWidth(w)
+        record['widget'] = label
+        return self.nextPC()
+    
+    def r_createPushbutton(self, command, record):
+        pushbutton = QPushButton(self.getRuntimeValue(command['text']))
+        if 'size' in command:
+            fm = pushbutton.fontMetrics()
+            c = pushbutton.contentsMargins()
+            w = fm.horizontalAdvance('x') * self.getRuntimeValue(command['size']) +c.left()+c.right()
+            pushbutton.setMaximumWidth(w)
+        record['widget'] = pushbutton
+        return self.nextPC()
+    
+    def r_createCheckBox(self, command, record):
+        checkbox = QCheckBox(self.getRuntimeValue(command['text']))
+        record['widget'] = checkbox
+        return self.nextPC()
+    
+    def r_createLineEdit(self, command, record):
+        lineinput = QLineEdit()
+        fm = lineinput.fontMetrics()
+        m = lineinput.textMargins()
+        c = lineinput.contentsMargins()
+        w = fm.horizontalAdvance('x') * self.getRuntimeValue(command['size']) +m.left()+m.right()+c.left()+c.right()
+        lineinput.setMaximumWidth(w)
+        record['widget'] = lineinput
+        return self.nextPC()
+    
+    def r_createListWidget(self, command, record):
+        record['widget'] = QListWidget()
+        return self.nextPC()
+
+    def r_create(self, command):
+        record = self.getVariable(command['name'])
+        keyword = record['keyword']
+        if keyword == 'window': return self.r_createWindow(command, record)
+        elif keyword == 'layout': return self.r_createLayout(command, record)
+        elif keyword == 'groupbox': return self.r_createGroupBox(command, record)
+        elif keyword == 'label': return self.r_createLabel(command, record)
+        elif keyword == 'pushbutton': return self.r_createPushbutton(command, record)
+        elif keyword == 'checkbox': return self.r_createCheckBox(command, record)
+        elif keyword == 'lineinput': return self.r_createLineEdit(command, record)
+        elif keyword == 'listbox': return self.r_createListWidget(command, record)
+        return None
+
+    # Create a group box
+    def k_groupbox(self, command):
+        return self.compileVariable(command, False)
+
+    def r_groupbox(self, command):
+        return self.nextPC()
+
+    # Initialize the graphics environment
+    def k_init(self, command):
+        if self.nextIs('graphics'):
+            self.add(command)
+            return True
+        return False
+    
+    def r_init(self, command):
+        self.app = QApplication(sys.argv)
+        return self.nextPC()
+
+    # Declare a label variable
+    def k_label(self, command):
+        return self.compileVariable(command, False)
+
+    def r_label(self, command):
+        return self.nextPC()
+
+    # Declare a layout variable
+    def k_layout(self, command):
+        return self.compileVariable(command, False)
+
+    def r_layout(self, command):
+        return self.nextPC()
+
+    # Declare a line input variable
+    def k_lineinput(self, command):
+        return self.compileVariable(command, False)
+
+    def r_lineinput(self, command):
+        return self.nextPC()
+
+    # Declare a listbox input variable
+    def k_listbox(self, command):
+        return self.compileVariable(command, False)
+
+    def r_listbox(self, command):
+        return self.nextPC()
+
+    # Handle events
+    def k_on(self, command):
+        if self.nextIs('click'):
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'pushbutton':
+                    command['name'] = record['name']
+                    command['goto'] = self.getPC() + 2
+                    self.add(command)
+                    self.nextToken()
+                    # Step over the click handler
+                    pcNext = self.getPC()
+                    cmd = {}
+                    cmd['domain'] = 'core'
+                    cmd['lino'] = command['lino']
+                    cmd['keyword'] = 'gotoPC'
+                    cmd['goto'] = 0
+                    cmd['debug'] = False
+                    self.addCommand(cmd)
+                    # This is the click handler
+                    self.compileOne()
+                    cmd = {}
+                    cmd['domain'] = 'core'
+                    cmd['lino'] = command['lino']
+                    cmd['keyword'] = 'stop'
+                    cmd['debug'] = False
+                    self.addCommand(cmd)
+                    # Fixup the link
+                    self.getCommandAt(pcNext)['goto'] = self.getPC()
+                    return True
+        return False
+    
+    def r_on(self, command):
+        pushbutton = self.getVariable(command['name'])['widget']
+        pushbutton.clicked.connect(lambda: self.run(command['goto']))
+        return self.nextPC()
+
+    # Declare a pushbutton variable
+    def k_pushbutton(self, command):
+        return self.compileVariable(command, False)
+
+    def r_pushbutton(self, command):
+        return self.nextPC()
+
+    # Clean exit
+    def on_last_window_closed(self):
+        print("Last window closed! Performing cleanup...")
+        self.program.kill()
+
+    # This is called every 10ms to keep the main application running
+    def flush(self):
+        self.program.flushCB()
+
+    # Resume execution at the line following 'start graphics'
+    def resume(self):
+        self.program.flush(self.nextPC())
+
+    # Set something
+    def k_set(self, command):
+        token = self.nextToken()
+        if token == 'the': token = self.nextToken()
+        if token == 'height':
+            command['property'] = token
+            if self.nextToken() == 'of':
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    keyword = record['keyword']
+                    if keyword == 'groupbox':
+                        command['name'] = record['name']
+                        if self.nextIs('to'):
+                            command['value'] = self.nextValue()
+                            self.add(command)
+                            return True
+        return False
+    
+    def r_set(self, command):
+        property = command['property']
+        if property == 'height':
+            groupbox = self.getVariable(command['name'])['widget']
+            groupbox.setFixedHeight(self.getRuntimeValue(command['value']))
+        return self.nextPC()
+
+    # Show a window with a specified layout
+    # show {name} in {window}}
+    def k_show(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'layout':
+                command['layout'] = record['name']
+                if self.nextIs('in'):
+                    if self.nextIsSymbol():
+                        record = self.getSymbolRecord()
+                        if record['keyword'] == 'window':
+                            command['window'] = record['name']
+                            self.add(command)
+                            return True
+        return False
+        
+    def r_show(self, command):
+        layoutRecord = self.getVariable(command['layout'])
+        windowRecord = self.getVariable(command['window'])
+        window = windowRecord['window']
+        container = QWidget()
+        container.setLayout(layoutRecord['widget'])
+        window.setCentralWidget(container)
+        window.show()
+        return self.nextPC()
+
+    # Start the graphics
+    def k_start(self, command):
+        if self.nextIs('graphics'):
+            self.add(command)
+            return True
+        return False
+        
+    def r_start(self, command):
+        timer = QTimer()
+        timer.timeout.connect(self.flush)
+        timer.start(10)
+        QTimer.singleShot(500, self.resume)
+        self.app.lastWindowClosed.connect(self.on_last_window_closed)
+        self.app.exec()
+
+    # Declare a window variable
+    def k_window(self, command):
+        return self.compileVariable(command, False)
+
+    def r_window(self, command):
+        return self.nextPC()
+
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        value['domain'] = 'rbr'
+        if self.tokenIs('the'):
+            self.nextToken()
+        token = self.getToken()
+        if token == 'xxxxx':
+            return value
+
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    def v_xxxxx(self, v):
+        value = {}
+        return value
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers

{easycoder-250406.1.dist-info → easycoder-250422.3.dist-info}/METADATA

@@ -1,13 +1,13 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: easycoder
-Version: 250406.1
+Version: 250422.3
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: MIT License
-License-File: LICENSE
 Requires-Dist: pytz
+Requires-Dist: pyside6
 Project-URL: Home, https://github.com/easycoder/easycoder-py
 
 # Introduction
@@ -84,18 +84,7 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `benchmark.ecs` allows the performance of **_EasyCoder_** to be compared to other languages if a similar script is written for each one.
 
 ## Graphical programming
-**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. Some demo scripts will be included in the `scripts` directory; these can be recognised by the extension`.ecg`. To run them, first install `tkinter`. On Linux this is done with
-```
-    sudo apt install python3-tk
-```
-
-Next, install the Python `pySimpleGUI` graphics library; this is done with `pip install pysimplegui`. Then run your **_EasyCoder_** script using `easycoder {scriptname}.ecg`.
-
-Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. Non-graphical applications can use any extension but `.ecs` is recommended. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment, but graphics will of course not be available in the former.
-
-Some demo graphical scripts will included in the `scripts` directory as development proceeds.
-
-`gtest.ecg` contains sample code to demonstrate and test basic features.
+**_EasyCoder_** includes a graphical programming environment based on PySide6, that is in the early stages of development. Some demo scripts will be included in the `scripts` directory as development proceeds.
 
 ## Significant features
 

{easycoder-250406.1.dist-info → easycoder-250422.3.dist-info}/RECORD

@@ -1,17 +1,18 @@
 easycoder/README.md,sha256=BVXmYphcTJ6q6RN_9L6HtQukgCnOjSLVIsTM3lk-9aM,587
-easycoder/__init__.py,sha256=CzZqrjSXsFgsbCCRQNz3RoLfvo0k76aLwK8m3pci754,262
+easycoder/__init__.py,sha256=HAdBM4aowyailw2NexqgELS6KF9_8A6QEnCYy1FghmY,262
 easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
 easycoder/ec_compiler.py,sha256=rtxFEWnhW0550MtWEDvYHOw9cYkeTcR0oG3t-kmgnBk,4795
 easycoder/ec_condition.py,sha256=YXvSBQKEzKGCcgUGo3Qp8iHolXmm2BpEm0NimSDszIM,785
-easycoder/ec_core.py,sha256=1S6NxyDSvPqeuZzWB1ry3jySafvyn8mgFnrPKImmp70,90397
+easycoder/ec_core.py,sha256=-nSX_KA_VBximHI1GIuXA-FhsqcyTNp9-HFrv6Dy64M,90625
 easycoder/ec_graphics.py,sha256=ScGLNxW_sxu0WyoO-Od-9MM0bhpVvf-vGa5UmoHYRCA,16073
 easycoder/ec_gutils.py,sha256=yqu4RRQ6VdRkC5B2ADBYsXzgNu76dLnekd9aUjdEgPw,6399
 easycoder/ec_handler.py,sha256=K7nBuQTH8l0k8hX1o2b4KhTnhZHGdf2fkEuX4FJXJs8,2277
 easycoder/ec_program.py,sha256=BDwU7aGHiaw6WdbQvVFDhGVaHsvwQ1CWa4wb5MPmOe8,10013
+easycoder/ec_pyside6.py,sha256=OOj7ikQbGQqi1wZ8VaNcX0yZUrN0KkVzZGPGbKlyGDo,17583
 easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
 easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder-250406.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250406.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250406.1.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
-easycoder-250406.1.dist-info/METADATA,sha256=CobU9Wrd-r7tEkMS4Q3jQnltrmtK5iWWSXybW8NUyGw,6520
-easycoder-250406.1.dist-info/RECORD,,
+easycoder-250422.3.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250422.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250422.3.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-250422.3.dist-info/METADATA,sha256=40jnSopPCKhQMtl0N_9Hka9LT7CVXI-TV0q0DeyIQ0A,5617
+easycoder-250422.3.dist-info/RECORD,,

{easycoder-250406.1.dist-info → easycoder-250422.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: flit 3.12.0
+Generator: flit 3.10.1
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any