easycoder 250423.2__py2.py3-none-any.whl → 250503.1__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__ = "250423.2"
+__version__ = "250503.1"

easycoder/ec_compiler.py

@@ -87,6 +87,15 @@ class Compiler:
 	def nextIsSymbol(self):
 		self.next()
 		return self.isSymbol()
+	
+	def skip(self, token):
+		next = self.peek()
+		if type(token) == list:
+			for item in token:
+				if next == item:
+					self.nextToken()
+					return
+		elif next == token: self.nextToken()
 
 	def rewindTo(self, index):
 		self.index = index
@@ -114,10 +123,10 @@ class Compiler:
 	def compileLabel(self, command):
 		return self.compileSymbol(command, self.getToken(), False)
 
-	def compileVariable(self, command, hasValue = False):
-		return self.compileSymbol(command, self.nextToken(), hasValue)
+	def compileVariable(self, command, hasValue = False, extra=None):
+		return self.compileSymbol(command, self.nextToken(), hasValue, extra)
 
-	def compileSymbol(self, command, name, hasValue):
+	def compileSymbol(self, command, name, hasValue, extra=None):
 		try:
 			v = self.symbols[name]
 		except:
@@ -137,6 +146,7 @@ class Compiler:
 		command['debug'] = False
 		command['import'] = None
 		command['locked'] = False
+		command['extra'] = extra
 		self.addCommand(command)
 		return True
 
@@ -164,7 +174,7 @@ class Compiler:
 					self.rewindTo(mark)
 			else:
 				self.rewindTo(mark)
-		FatalError(self, f'No handler found for "{token}"')
+		FatalError(self, f'Unable to compile this "{token}" command. Perhaps a syntax error?')
 
 	# Compile a single command
 	def compileOne(self):

easycoder/ec_core.py

@@ -14,6 +14,9 @@ class Core(Handler):
 
     def getName(self):
         return 'core'
+    
+    def noSymbolWarning(self):
+        self.warning(f'Symbol "{self.getToken()}" not found')
 
     #############################################################################
     # Keyword handlers
@@ -161,7 +164,6 @@ class Core(Handler):
         val['type'] = 'boolean'
         val['content'] = False
         self.putSymbolValue(target, val)
-        # self.add(command)
         return self.nextPC()
 
     # Close a file
@@ -367,6 +369,8 @@ class Core(Handler):
         return True
 
     def r_exit(self, command):
+        if self.program.graphics != None:
+            self.program.graphics.force_exit()
         return -1
 
     # Declare a file variable
@@ -717,7 +721,7 @@ class Core(Handler):
         try:
             with open(filename) as f: content = f.read()
         except:
-            RuntimeError(self.program, f'File \'{filename}\' not found')
+            content = ''
         try:
             if filename.endswith('.json'): content = json.loads(content)
         except:
@@ -1295,7 +1299,10 @@ class Core(Handler):
                 if self.nextIsSymbol():
                     command['target'] = self.getSymbolRecord()['name']
                     if self.nextIs('to'):
-                        command['value'] = self.nextValue()
+                        value = self.nextValue()
+                        if value == None:
+                            FatalError(self.compiler, 'Unable to get a value')
+                        command['value'] = value
                         self.add(command)
                         return True
 
@@ -1379,6 +1386,33 @@ class Core(Handler):
             self.putSymbolValue(targetVariable, val)
             return self.nextPC()
 
+    # Shuffle a list
+    def k_shuffle(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['hasValue']:
+                command['target'] = self.getToken()
+                self.add(command)
+                return True
+            self.warning(f'Core.negate: Variable "{symbolRecord["name"]}" does not hold a value')
+        return False
+
+    def r_shuffle(self, command):
+        symbolRecord = self.getVariable(command['target'])
+        if not symbolRecord['hasValue']:
+            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+            return None
+        value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
+        content = value['content']
+        if isinstance(content, list):
+            random.shuffle(content)
+            value['content'] = content
+            self.putSymbolValue(symbolRecord, value)
+            return self.nextPC()
+        RuntimeError(self.program, f'{symbolRecord["name"]} is not a list')
+
     # Split a string into a variable with several elements
     # split {variable} on {value}
     def k_split(self, command):
@@ -1400,6 +1434,7 @@ class Core(Handler):
                         command['on'] = self.nextValue()
                 self.add(command)
                 return True
+        else: self.noSymbolWarning()
         return False
 
     def r_split(self, command):
@@ -1419,33 +1454,6 @@ class Core(Handler):
 
         return self.nextPC()
 
-    # Shuffle a list
-    def k_shuffle(self, command):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                command['target'] = self.getToken()
-                self.add(command)
-                return True
-            self.warning(f'Core.negate: Variable "{symbolRecord["name"]}" does not hold a value')
-        return False
-
-    def r_shuffle(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['hasValue']:
-            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
-            return None
-        value = self.getSymbolValue(symbolRecord)
-        if value == None:
-            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
-        content = value['content']
-        if isinstance(content, list):
-            random.shuffle(content)
-            value['content'] = content
-            self.putSymbolValue(symbolRecord, value)
-            return self.nextPC()
-        RuntimeError(self.program, f'{symbolRecord["name"]} is not a list')
-
     # Declare a stack variable
     def k_stack(self, command):
         return self.compileVariable(command)
@@ -1599,7 +1607,9 @@ class Core(Handler):
 
     def k_use(self, command):
         if self.nextIs('graphics'):
-            from .ec_pyside6 import Graphics
+            print('Loading graphics module')
+            from .ec_pyside import Graphics
+            self.program.graphics = Graphics
             self.program.classes.append(Graphics)
             self.program.processClasses()
             return True
@@ -1762,7 +1772,7 @@ class Core(Handler):
         if token in ['now', 'today', 'newline', 'tab', 'empty']:
             return value
 
-        if token in ['stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
+        if token in ['stringify', 'prettify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
             value['content'] = self.nextValue()
             return value
 
@@ -2272,6 +2282,13 @@ class Core(Handler):
         value['content'] = haystack.rfind(needle) if last else haystack.find(needle)
         return value
 
+    def v_prettify(self, v):
+        item = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'text'
+        value['content'] = json.dumps(item, indent=4)
+        return value
+
     def v_property(self, v):
         propertyValue = self.getRuntimeValue(v['name'])
         if 'target' in v:

easycoder/ec_handler.py

@@ -7,6 +7,7 @@ class Handler:
 		self.program = compiler.program
 		self.getToken = compiler.getToken
 		self.nextToken = compiler.nextToken
+		self.skip = compiler.skip
 		self.peek = compiler.peek
 		self.getValue = compiler.getValue
 		self.nextValue = compiler.nextValue

easycoder/ec_program.py

@@ -78,7 +78,7 @@ class Program:
 			while True:
 				if self.running == True:
 					flush()
-					time.sleep(0.1)
+					time.sleep(0.01)
 				else:
 					break
 

easycoder/{ec_pyside6.py → ec_pyside.py}

@@ -1,6 +1,7 @@
 import sys
 from easycoder import Handler, FatalError, RuntimeError
 from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QPixmap
 from PySide6.QtWidgets import (
     QApplication,
     QCheckBox,
@@ -30,7 +31,8 @@ from PySide6.QtWidgets import (
     QSpacerItem,
     QSizePolicy,
     QDialog,
-    QMessageBox
+    QMessageBox,
+    QDialogButtonBox
 )
 
 class Graphics(Handler):
@@ -84,28 +86,30 @@ class Graphics(Handler):
 
         # Here it's either (1) or (2)
         elif self.isSymbol():
-            if self.peek() == 'to':
-                # (2)
-                record = self.getSymbolRecord()
-                command['widget'] = record['name']
-                self.nextToken()
-                return addToLayout()
-        else:
-            # (1)
-            command['value'] = self.getValue()
-            if self.nextIs('to'):
-                if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['extra'] == 'gui':
+                if self.peek() == 'to':
+                    # (2)
                     record = self.getSymbolRecord()
                     command['widget'] = record['name']
-                    self.add(command)
-                    return True
+                    self.nextToken()
+                    return addToLayout()
+                return False
+        # (1)
+        command['value'] = self.getValue()
+        self.skip('to')
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            command['widget'] = record['name']
+            self.add(command)
+            return True
         return False
     
     def r_add(self, command):
         if 'value' in command:
             value = self.getRuntimeValue(command['value'])
             widget = self.getVariable(command['widget'])
-            if widget['keyword'] == 'combobox':
+            if widget['keyword'] in ['listbox', 'combobox']:
                 widget['widget'].addItem(value)
         else:
             layoutRecord = self.getVariable(command['layout'])
@@ -132,14 +136,51 @@ class Graphics(Handler):
                     else: layout.addWidget(widget)
         return self.nextPC()
 
+    # Center one window on another
+    # center {window2} on {window1}
+    def k_center(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'window':
+                command['window2'] = record['name']
+                self.skip('on')
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] == 'window':
+                        command['window1'] = record['name']
+                        self.add(command)
+                        return True
+        return False
+    
+    def r_center(self, command):
+        window1 = self.getVariable(command['window1'])['window']
+        window2 = self.getVariable(command['window2'])['window']
+        geo1 = window1.geometry()
+        geo2 = window2.geometry()
+        geo2.moveCenter(geo1.center())
+        window2.setGeometry(geo2)
+        return self.nextPC()
+
     # Declare a checkbox variable
     def k_checkbox(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_checkbox(self, command):
         return self.nextPC()
 
-    # Close a window
+    # clear {widget}
+    def k_clear(self, command):
+        if self.nextIsSymbol():
+            command['name'] = self.getSymbolRecord()['name']
+            self.add(command)
+            return True
+        return False
+    
+    def r_clear(self, command):
+        self.getVariable(command['name'])['widget'].clear()
+        return self.nextPC()
+
+    # close {window}
     def k_close(self, command):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
@@ -155,7 +196,7 @@ class Graphics(Handler):
 
     # Declare a combobox variable
     def k_combobox(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_combobox(self, command):
         return self.nextPC()
@@ -165,34 +206,39 @@ class Graphics(Handler):
         command['title'] = 'Default'
         x = None
         y = None
-        w = 640
-        h = 480
+        w = self.compileConstant(640)
+        h = self.compileConstant(480)
         while True:
             token = self.peek()
-            if token in ['title', 'at', 'size']:
+            if token in ['title', 'at', 'size', 'layout']:
                 self.nextToken()
                 if token == 'title': command['title'] = self.nextValue()
                 elif token == 'at':
                     x = self.nextValue()
                     y = self.nextValue()
                 elif token == 'size':
-                    command['w'] = self.nextValue()
-                    command['h'] = self.nextValue()
+                    w = self.nextValue()
+                    h = self.nextValue()
+                elif token == 'layout':
+                    if self.nextIsSymbol():
+                        record = self.getSymbolRecord()
+                        if record['keyword'] == 'layout':
+                            command['layout'] = record['name']
+                else: return False
             else: break
-        command['w'] = self.compileConstant(w)
-        command['h'] = self.compileConstant(h)
         command['x'] = x
         command['y'] = y
+        command['w'] = w
+        command['h'] = h
         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
+        self.skip('type')
+        command['type'] = self.nextToken()
+        self.add(command)
+        return True
 
     def k_createGroupBox(self, command):
         if self.peek() == 'title':
@@ -204,7 +250,7 @@ class Graphics(Handler):
         return True
 
     def k_createLabel(self, command):
-        text = ''
+        text = self.compileConstant('')
         while True:
             token = self.peek()
             if token == 'text':
@@ -213,6 +259,11 @@ class Graphics(Handler):
             elif token == 'size':
                 self.nextToken()
                 command['size'] = self.nextValue()
+            elif token == 'align':
+                self.nextToken()
+                token = self.nextToken()
+                if token in ['left', 'right', 'center', 'centre', 'justify']:
+                    command['align'] = token
             else: break
         command['text'] = text
         self.add(command)
@@ -260,38 +311,50 @@ class Graphics(Handler):
         return True
 
     def k_createDialog(self, command):
-        if self.peek() == 'title':
+        if self.peek() == 'on':
             self.nextToken()
-            title = self.nextValue()
-        else: title = ''
+            if self.nextIsSymbol():
+                command['window'] = self.getSymbolRecord()['name']
+        else: command['window'] = None
+        title = ''
+        while True:
+            if self.peek() == 'title':
+                self.nextToken()
+                title = self.nextValue()
+            elif self.peek() == 'layout':
+                self.nextToken()
+                if self.nextIsSymbol():
+                    command['layout'] = self.getSymbolRecord()['name']
+            else: break
         command['title'] = title
         self.add(command)
         return True
 
     def k_createMessageBox(self, command):
-        if self.nextIs('on'):
+        if self.peek() == 'on':
+            self.nextToken()
             if self.nextIsSymbol():
                 command['window'] = self.getSymbolRecord()['name']
-                style = 'question'
-                title = ''
-                message = ''
-                while True:
-                    if self.peek() == 'style':
-                        self.nextToken()
-                        style = self.nextToken()
-                    elif self.peek() == 'title':
-                        self.nextToken()
-                        title = self.nextValue()
-                    elif self.peek() == 'message':
-                        self.nextToken()
-                        message = self.nextValue()
-                    else: break
-                command['style'] = style
-                command['title'] = title
-                command['message'] = message
-                self.add(command)
-                return True
-        return False
+        else: command['window'] = None
+        style = 'question'
+        title = ''
+        message = ''
+        while True:
+            if self.peek() == 'style':
+                self.nextToken()
+                style = self.nextToken()
+            elif self.peek() == 'title':
+                self.nextToken()
+                title = self.nextValue()
+            elif self.peek() == 'message':
+                self.nextToken()
+                message = self.nextValue()
+            else: break
+        command['style'] = style
+        command['title'] = title
+        command['message'] = message
+        self.add(command)
+        return True
 
     def k_create(self, command):
         if self.nextIsSymbol():
@@ -323,6 +386,9 @@ class Graphics(Handler):
         if y == None: y = (self.screenHeight - h) / 2
         else: y = self.getRuntimeValue(x)
         window.setGeometry(x, y, w, h)
+        container = QWidget()
+        container.setLayout(self.getVariable(command['layout'])['widget'])
+        window.setCentralWidget(container)
         record['window'] = window
         return self.nextPC()
     
@@ -347,17 +413,25 @@ class Graphics(Handler):
         if 'size' in command:
             fm = label.fontMetrics()
             c = label.contentsMargins()
-            w = fm.horizontalAdvance('x') * self.getRuntimeValue(command['size']) +c.left()+c.right()
+            w = fm.horizontalAdvance('m') * self.getRuntimeValue(command['size']) +c.left()+c.right()
             label.setMaximumWidth(w)
+        if 'align' in command:
+            alignment = command['align']
+            if alignment == 'left': label.setAlignment(Qt.AlignLeft)
+            elif alignment == 'right': label.setAlignment(Qt.AlignRight)
+            elif alignment in ['center', 'centre']: label.setAlignment(Qt.AlignHCenter)
+            elif alignment == 'justify': label.setAlignment(Qt.AlignJustify)
         record['widget'] = label
         return self.nextPC()
     
     def r_createPushbutton(self, command, record):
-        pushbutton = QPushButton(self.getRuntimeValue(command['text']))
+        text = self.getRuntimeValue(command['text'])
+        pushbutton = QPushButton(text)
+        pushbutton.setAccessibleName(text)
         if 'size' in command:
             fm = pushbutton.fontMetrics()
             c = pushbutton.contentsMargins()
-            w = fm.horizontalAdvance('x') * self.getRuntimeValue(command['size']) +c.left()+c.right()
+            w = fm.horizontalAdvance('m') * self.getRuntimeValue(command['size']) +c.left()+c.right()
             pushbutton.setMaximumWidth(w)
         record['widget'] = pushbutton
         return self.nextPC()
@@ -386,8 +460,14 @@ class Graphics(Handler):
         return self.nextPC()
     
     def r_createDialog(self, command, record):
+        layout = self.getVariable(command['layout'])['widget']
         dialog = QDialog()
         dialog.setWindowTitle(self.getRuntimeValue(command['title']))
+        dialog.buttonBox = QDialogButtonBox((QDialogButtonBox.Ok | QDialogButtonBox.Cancel))
+        dialog.buttonBox.accepted.connect(dialog.accept)
+        dialog.buttonBox.rejected.connect(dialog.reject)
+        layout.addWidget(dialog.buttonBox)
+        dialog.setLayout(layout)
         record['dialog'] = dialog
         return self.nextPC()
     
@@ -450,7 +530,7 @@ class Graphics(Handler):
 
     # Create a group box
     def k_groupbox(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_groupbox(self, command):
         return self.nextPC()
@@ -472,28 +552,28 @@ class Graphics(Handler):
 
     # Declare a label variable
     def k_label(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_label(self, command):
         return self.nextPC()
 
     # Declare a layout variable
     def k_layout(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_layout(self, command):
         return self.nextPC()
 
     # Declare a line input variable
     def k_lineinput(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_lineinput(self, command):
         return self.nextPC()
 
     # Declare a listbox input variable
     def k_listbox(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_listbox(self, command):
         return self.nextPC()
@@ -505,139 +585,247 @@ class Graphics(Handler):
     def r_messagebox(self, command):
         return self.nextPC()
 
-    # Handle events
+    # on click {pushbutton}
+    # on select {combobox}/{listbox}
     def k_on(self, command):
-        if self.nextIs('click'):
+        def setupOn():
+            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()
+
+        token = self.nextToken()
+        if token == '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()
+                    setupOn()
+                    return True
+        elif token == 'select':
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] in ['combobox', 'listbox']:
+                    setupOn()
                     return True
         return False
     
     def r_on(self, command):
-        pushbutton = self.getVariable(command['name'])['widget']
-        pushbutton.clicked.connect(lambda: self.run(command['goto']))
+        record = self.getVariable(command['name'])
+        widget = record['widget']
+        keyword = record['keyword']
+        if keyword == 'pushbutton':
+            widget.clicked.connect(lambda: self.run(command['goto']))
+        elif keyword == 'combobox':
+            widget.currentIndexChanged.connect(lambda: self.run(command['goto']))
+        elif keyword == 'listbox':
+            widget.itemClicked.connect(lambda: self.run(command['goto']))
         return self.nextPC()
 
     # Declare a pushbutton variable
     def k_pushbutton(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, False, 'gui')
 
     def r_pushbutton(self, command):
         return self.nextPC()
 
-    # remove current item from {combobox}
+    # remove [the] [current/selected] [item] [from/in] {combobox}/{listbox}
     def k_remove(self, command):
         command['variant'] = None
-        if self.nextIs('current'):
-            if self.nextIs('item'):
-                if self.nextIs('from'):
-                    if self.nextIsSymbol():
-                        record = self.getSymbolRecord()
-                        if record['keyword'] == 'combobox':
-                            command['variant'] = 'current'
-                            command['name'] = record['name']
-                            self.addCommand(command)
-                            return True
+        self.skip('the')
+        self.skip(['current', 'selected'])
+        self.skip('item')
+        self.skip(['from', 'in'])
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'combobox':
+                command['variant'] = 'current'
+                command['name'] = record['name']
+                self.addCommand(command)
+                return True
+            elif record['keyword'] == 'listbox':
+                command['variant'] = 'current'
+                command['name'] = record['name']
+                self.addCommand(command)
+                return True
         return False
         
     def r_remove(self, command):
         variant = command['variant']
         record = self.getVariable(command['name'])
-        if record['keyword'] == 'combobox' and variant == 'current':
-            widget = record['widget']
-            widget.removeItem(widget.currentIndex())
+        if variant == 'current':
+            if record['keyword'] == 'combobox':
+                widget = record['widget']
+                widget.removeItem(widget.currentIndex())
+            if record['keyword'] == 'listbox':
+                widget = record['widget']
+                selectedItem = widget.currentItem()
+                if selectedItem:
+                    row = widget.row(selectedItem)
+                    widget.takeItem(row)
         return self.nextPC()
 
-    # This is called every 10ms to keep the main application running
-    def flush(self):
-        self.program.flushCB()
+    # select index {n} [of] {combobox]}
+    # select {name} [in] {combobox}
+    def k_select(self, command):
+        if self.nextIs('index'):
+            command['index'] = self.nextValue()
+            self.skip('of')
+        else:
+            command['name'] = self.nextValue()
+            self.skip('in')
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'combobox':
+                command['widget'] = record['name']
+                self.add(command)
+                return True
+        return False
+    
+    def r_select(self, command):
+        widget = self.getVariable(command['widget'])['widget']
+        if 'index' in command:
+            index = self.getRuntimeValue(command['index'])
+        else:
+            name = self.getRuntimeValue(command['name'])
+            index = widget.findText(name, Qt.MatchFixedString)
+        if index >= 0:
+            widget.setCurrentIndex(index)
+        return self.nextPC()
 
-    # Set something
+    # set [the] width/height [of] {widget} [to] {value}
+    # set [the] text [of] {label}/{button}/{lineinput} [to] {text}
+    # set [the] color [of] {label}/{button}/{lineinput} [to] {color}
+    # set {listbox} to {list}
     def k_set(self, command):
+        self.skip('the')
         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
+        command['what'] = token
+        if token in ['width', 'height']:
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['extra'] == 'gui':
+                    command['name'] = record['name']
+                    self.skip('to')
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                    return True
+        elif token == 'text':
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] in ['label', 'pushbutton', 'lineinput']:
+                    command['name'] = record['name']
+                    self.skip('to')
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                    return True
+        elif token == 'color':
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'label':
+                    command['name'] = record['name']
+                    self.skip('to')
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                    return True
+        elif token == 'background':
+            self.skip('color')
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] in ['label', 'pushbutton', 'lineinput']:
+                    command['name'] = record['name']
+                    self.skip('to')
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                    return True
+        elif self.isSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'listbox':
+                command['what'] = 'listbox'
+                command['name'] = record['name']
+                self.skip('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']))
+        what = command['what']
+        if what == 'height':
+            widget = self.getVariable(command['name'])['widget']
+            widget.setFixedHeight(self.getRuntimeValue(command['value']))
+        elif what == 'width':
+            widget = self.getVariable(command['name'])['widget']
+            widget.setFixedWidth(self.getRuntimeValue(command['value']))
+        elif what == 'text':
+            record = self.getVariable(command['name'])
+            widget = self.getVariable(command['name'])['widget']
+            text = self.getRuntimeValue(command['value'])
+            widget.setText(text)
+            if record['keyword'] == 'pushbutton':
+                widget.setAccessibleName(text)
+        elif what == 'color':
+            widget = self.getVariable(command['name'])['widget']
+            color = self.getRuntimeValue(command['value'])
+            widget.setStyleSheet(f"color: {color};")
+        elif what == 'background-color':
+            widget = self.getVariable(command['name'])['widget']
+            bg_color = self.getRuntimeValue(command['value'])
+            widget.setStyleSheet(f"background-color: {bg_color};")
+        elif what == 'listbox':
+            widget = self.getVariable(command['name'])['widget']
+            value = self.getRuntimeValue(command['value'])
+            widget.addItems(value)
         return self.nextPC()
 
-    # Show something
-    # show {name} in {window}}
-    # show {dialog}/{messagebox}
+    # show {window}
+    # show {dialog}
+    # show {messagebox} giving {result}}
     def k_show(self, command):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
             keyword = record['keyword']
-            if 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
+            if keyword == 'window':
+                command['window'] = record['name']
+                self.add(command)
+                return True
             elif keyword == 'dialog':
                 command['dialog'] = record['name']
                 self.add(command)
                 return True
             elif keyword == 'messagebox':
                 command['messagebox'] = record['name']
-                if self.nextIs('giving'):
-                    if self.nextIsSymbol():
-                        command['result'] = self.getSymbolRecord()['name']
-                        self.add(command)
-                        return True
+                self.skip('giving')
+                if self.nextIsSymbol():
+                    command['result'] = self.getSymbolRecord()['name']
+                    self.add(command)
+                    return True
         return False
         
     def r_show(self, command):
-        if 'dialog' in command:
-            dialog = self.getVariable(command['dialog'])['dialog']
-            b1 = QPushButton("ok",dialog)
-            b1.move(50,50)
-            dialog.setWindowModality(Qt.ApplicationModal)
-            dialog.exec_()
-        elif 'messagebox' in command:
+        if 'messagebox' in command:
             data = self.getVariable(command['messagebox'])['data']
             symbolRecord = self.getVariable(command['result'])
             window = self.getVariable(data['window'])['window']
@@ -657,14 +845,12 @@ class Graphics(Handler):
             v['type'] = 'text'
             v['content'] = result
             self.putSymbolValue(symbolRecord, v)
-        else:
-            layoutRecord = self.getVariable(command['layout'])
-            windowRecord = self.getVariable(command['window'])
-            window = windowRecord['window']
-            container = QWidget()
-            container.setLayout(layoutRecord['widget'])
-            window.setCentralWidget(container)
+        elif 'window' in command:
+            window = self.getVariable(command['window'])['window']
             window.show()
+        elif 'dialog' in command:
+            dialog = self.getVariable(command['dialog'])['dialog']
+            dialog.exec()
         return self.nextPC()
 
     # Start the graphics
@@ -676,12 +862,14 @@ class Graphics(Handler):
         
     def r_start(self, command):
         def on_last_window_closed():
-            print("Performing cleanup...")
+            print("Kill the appication...")
             self.program.kill()
         def resume():
             self.program.flush(self.nextPC())
+        def flush():
+            self.program.flushCB()
         timer = QTimer()
-        timer.timeout.connect(self.flush)
+        timer.timeout.connect(flush)
         timer.start(10)
         QTimer.singleShot(500, resume)
         self.app.lastWindowClosed.connect(on_last_window_closed)
@@ -693,7 +881,7 @@ class Graphics(Handler):
 
     def r_window(self, command):
         return self.nextPC()
-
+    
     #############################################################################
     # Compile a value in this domain
     def compileValue(self):
@@ -710,15 +898,27 @@ class Graphics(Handler):
         token = self.getToken()
 
         if token == 'count':
-            if self.nextIs('of'):
-                if self.nextIsSymbol():
-                    value['type'] = 'symbol'
-                    record = self.getSymbolRecord()
-                    keyword = record['keyword']
-                    if keyword == 'combobox':
-                        value['type'] = 'count'
-                        value['name'] = record['name']
-                        return value
+            self.skip('of')
+            if self.nextIsSymbol():
+                value['type'] = 'symbol'
+                record = self.getSymbolRecord()
+                keyword = record['keyword']
+                if keyword in ['combobox', 'listbox']:
+                    value['type'] = 'count'
+                    value['name'] = record['name']
+                    return value
+        
+        if token == 'current':
+            self.skip('item')
+            self.skip('in')
+            if self.nextIsSymbol():
+                value['type'] = 'symbol'
+                record = self.getSymbolRecord()
+                keyword = record['keyword']
+                if keyword == 'listbox':
+                    value['type'] = 'current'
+                    value['name'] = record['name']
+                    return value
 
         return None
 
@@ -734,24 +934,53 @@ class Graphics(Handler):
     def v_symbol(self, symbolRecord):
         symbolRecord = self.getVariable(symbolRecord['name'])
         keyword = symbolRecord['keyword']
-        if keyword == 'combobox':
+        if keyword == 'pushbutton':
+            pushbutton = symbolRecord['widget']
+            v = {}
+            v['type'] = 'text'
+            v['content'] = pushbutton.accessibleName()
+            return v
+        elif keyword == 'lineinput':
+            lineinput = symbolRecord['widget']
+            v = {}
+            v['type'] = 'text'
+            v['content'] = lineinput.displayText()
+            return v
+        elif keyword == 'combobox':
             combobox = symbolRecord['widget']
             v = {}
             v['type'] = 'text'
             v['content'] = combobox.currentText()
             return v
+        elif keyword == 'listbox':
+            listbox = symbolRecord['widget']
+            content = listbox.currentItem().text()
+            v = {}
+            v['type'] = 'text'
+            v['content'] = content
+            return v
         return None
 
     def v_count(self, v):
         record = self.getVariable(v['name'])
         keyword = record['keyword']
         widget = record['widget']
-        if keyword == 'combobox': content = widget.count()
+        if keyword in ['combobox', 'listbox']: content = widget.count()
         value = {}
         value['type'] = 'int'
         value['content'] = content
         return value
 
+    def v_current(self, v):
+        record = self.getVariable(v['name'])
+        keyword = record['keyword']
+        widget = record['widget']
+        if keyword == 'listbox': content = widget.currentItem().text()
+        value = {}
+        value['type'] = 'text'
+        value['content'] = content
+        return value
+
     #############################################################################
     # Compile a condition
     def compileCondition(self):
@@ -760,3 +989,22 @@ class Graphics(Handler):
 
     #############################################################################
     # Condition handlers
+
+    #############################################################################
+    # Force the application to exit
+    def force_exit(self):
+        QApplication.quit()  # Gracefully close the application
+        sys.exit(0)          # Force a complete system exit
+
+
+def addIconToLayout(layout, icon_path):
+    """
+    Adds an icon to the specified layout.
+
+    :param layout: The layout to which the icon will be added.
+    :param icon_path: The file path of the icon image.
+    """
+    icon_label = QLabel()
+    pixmap = QPixmap(icon_path)
+    icon_label.setPixmap(pixmap)
+    layout.addWidget(icon_label)

{easycoder-250423.2.dist-info → easycoder-250503.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250423.2
+Version: 250503.1
 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>
@@ -11,7 +11,11 @@ Requires-Dist: pyside6
 Project-URL: Home, https://github.com/easycoder/easycoder-py
 
 # Introduction
-**_EasyCoder_** is a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. The language is written in Python and it acts as a fairly thin wrapper around standard Python functions, giving fast compilation and good runtime performance for general applications.
+**_EasyCoder_** is a high-level English-like domain-specific scripting language (DSL) suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. The language is written in Python and it acts as a fairly thin wrapper around standard Python functions, giving fast compilation and good runtime performance for general applications.
+
+**_EasyCoder_** is well suited to building command-line or graphical applications for expressing random logic such as operating procedures and rules, or controlling physical systems, primarily wifi devices. It is particularly easy to construct and issue REST commands to local or remote web servers.
+
+For more advanced applications, **_EasyCoder_** is designed to be extensible, by enabling extra language syntax to be added via plugin-in modules. Once these are installed they act as seamless extensions to the basic syntax provided. **_EasyCoder_** derives its power from the use of rich and comprehensive language rather than a complex system of frameworks such as those commonly used in modern programming. This makes it very easy to learn as our brains are wired to operate that way. Having said that, the needs of most control systems are usually served by a fairly modest number of keywords and syntactic variants.
 <hr>
 
 There is also a JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser. For this, please visit
@@ -23,15 +27,12 @@ Website: [https://easycoder.github.io](https://easycoder.github.io)
 ## Quick Start
 Install **_EasyCoder_** in your Python environment:
 ```
-pip install requests pytz easycoder
+pip install requests easycoder
 ```
 
 Test the install by typing the command `easycoder`.
 <hr>
-On Linux, this will probably fail as the installer places the executable file in the `$HOME/.local/bin` directory. So give the command
-```
-    export PATH=$HOME/.local/bin:$PATH
-```
+On Linux, this will probably fail as the installer places the executable file in the `$HOME/.local/bin` directory. So give the command `export PATH=$HOME/.local/bin:$PATH`.
 
 To make this change permanent, edit your `.profile` file, adding the following:
 ```
@@ -42,7 +43,7 @@ fi
 ```
 <hr>
 
-Now write a test script, 'hello.ecs', containing the following:
+Now write a test script, `hello.ecs`, containing the following:
 ```
 print `Hello, world!`
 exit
@@ -84,7 +85,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 based on PySide6, that is in the early stages of development. Some demo scripts will be included in the `scripts` directory as development proceeds.
+**_EasyCoder_** includes a graphical programming environment based on PySide6, that is in under development. Some demo scripts will be included in the `scripts` directory as development proceeds. Anyone wishing to track progress can do so via this repository. At the time of writing we are transitioning from an early version based on PySimpleGUI to one based on PySide, the latter being an open product that matches the needs of a DSL better than does the former.
 
 ## Significant features
 

easycoder-250503.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+easycoder/README.md,sha256=BVXmYphcTJ6q6RN_9L6HtQukgCnOjSLVIsTM3lk-9aM,587
+easycoder/__init__.py,sha256=nOSldJ2q0EIA4NLCRkG8vCCgqAc64CpgzIgBYq9yO78,262
+easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
+easycoder/ec_compiler.py,sha256=vNOAKIK2pX_cW4mcxwCe0OR16iqeZqvZQ6JCgQ5MqtU,5062
+easycoder/ec_condition.py,sha256=YXvSBQKEzKGCcgUGo3Qp8iHolXmm2BpEm0NimSDszIM,785
+easycoder/ec_core.py,sha256=hmMHQ5UxJ8JS6gMmcttzmZGGHc6bXR624A5g8VCH3JY,91224
+easycoder/ec_graphics.py,sha256=WXxKMB4GJSmxvk-FVbOTyufiUx4TYIzyDoB1PCAO3JY,16067
+easycoder/ec_gutils.py,sha256=yqu4RRQ6VdRkC5B2ADBYsXzgNu76dLnekd9aUjdEgPw,6399
+easycoder/ec_handler.py,sha256=zPDZ_hqdgNnkCd8B5HmSLkqsGgf4aDmqcUBOPHgo47U,2305
+easycoder/ec_program.py,sha256=CxGYl1slYXNOYFxiSMc-BuXL_QztYuBfCXltPCtw1U4,10011
+easycoder/ec_pyside.py,sha256=6GIZpnmIj9LissJopfqcSvc1i1qbl4h56PQsJXOu9XU,36005
+easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
+easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
+easycoder-250503.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250503.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250503.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-250503.1.dist-info/METADATA,sha256=S-ZJU8J3jqERA2fkdZ1SHwRhJ_Xdp-QR1ByCOwStNHU,6803
+easycoder-250503.1.dist-info/RECORD,,

easycoder-250423.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-easycoder/README.md,sha256=BVXmYphcTJ6q6RN_9L6HtQukgCnOjSLVIsTM3lk-9aM,587
-easycoder/__init__.py,sha256=rXpc2iuRmzM8KsgUZWefLoHMii_uABr61154GK0iZ_0,262
-easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
-easycoder/ec_compiler.py,sha256=WN4DMTU66kzOAwOGJe3KDoXj2nPvq19ACegQ-RSMglo,4780
-easycoder/ec_condition.py,sha256=YXvSBQKEzKGCcgUGo3Qp8iHolXmm2BpEm0NimSDszIM,785
-easycoder/ec_core.py,sha256=X66TBECPnp-82lEcCpaiJuXSy4Ex519iBK2BM-wGHaQ,90611
-easycoder/ec_graphics.py,sha256=WXxKMB4GJSmxvk-FVbOTyufiUx4TYIzyDoB1PCAO3JY,16067
-easycoder/ec_gutils.py,sha256=yqu4RRQ6VdRkC5B2ADBYsXzgNu76dLnekd9aUjdEgPw,6399
-easycoder/ec_handler.py,sha256=K7nBuQTH8l0k8hX1o2b4KhTnhZHGdf2fkEuX4FJXJs8,2277
-easycoder/ec_program.py,sha256=ZCcvI36iq9HG4o8rFwFxzVElzZ7PEeNOPMr8eqwz8ns,10010
-easycoder/ec_pyside6.py,sha256=0Z-uWrCq7Uz_C6WjN-9E0TDI-IHny14-j5sTc1a3LLg,26627
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder-250423.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250423.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250423.2.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-250423.2.dist-info/METADATA,sha256=XZhRQ-0z-KpgImt8Nvyk46I6V_lZ1M2aet5VoR8hHYs,5617
-easycoder-250423.2.dist-info/RECORD,,