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

easycoder/__init__.py

@@ -12,4 +12,4 @@ from .ec_pyside import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "251004.1"
+__version__ = "251104.1"

easycoder/ec_classes.py

@@ -16,7 +16,6 @@ class AssertionError:
 	def __init__(self, program, msg=None):
 		code = program.code[program.pc]
 		lino = code['lino']
-		script = program.script.lines[lino].strip()
 		message = f'Assertion Error in {program.name} at line {lino + 1}'
 		if msg != None:
 			message += f': {msg}'
@@ -58,8 +57,5 @@ class Token:
 		self.lino = lino
 		self.token = token
 	
-class Condition():
-	negate = False
-
 class Object():
     pass

easycoder/ec_compiler.py

@@ -1,4 +1,4 @@
-from .ec_classes import Token, FatalError
+from .ec_classes import FatalError
 from .ec_value import Value
 from .ec_condition import Condition
 
@@ -18,9 +18,11 @@ class Compiler:
 		self.debugCompile = False
 		self.valueTypes = {}
 
-	def getPC(self):
+	# Get the current code size. Used during compilation
+	def getCodeSize(self):
 		return len(self.program.code)
 
+	# Get the current index (the program counter)
 	def getIndex(self):
 		return self.index
 
@@ -39,6 +41,7 @@ class Compiler:
 		self.index += 1
 		return self.getToken()
 
+	# Peek ahead to see the next token without advancing the index
 	def peek(self):
 		try:
 			return self.tokens[self.index + 1].token
@@ -68,19 +71,23 @@ class Compiler:
 		self.index += 1
 		return self.condition.compileCondition()
 
+	# Test if the current token has a specified value
 	def tokenIs(self, value):
 		return self.getToken() == value
 
+	# Test if the next token has the specified value
 	def nextIs(self, value):
 		return self.nextToken() == value
 
+	# Get the command at a given pc in the code list
 	def getCommandAt(self, pc):
 		return self.program.code[pc]
 
 	# Add a command to the code list
-	def add(self, command):
+	def addCommand(self, command):
 		self.code.append(command)
 
+	# Test if the current token is a symbol
 	def isSymbol(self):
 		token = self.getToken()
 		try:
@@ -89,10 +96,12 @@ class Compiler:
 			return False
 		return True
 
+	# Test if the next token is a symbol
 	def nextIsSymbol(self):
 		self.next()
 		return self.isSymbol()
 	
+	# Skip the next token if it matches the value given
 	def skip(self, token):
 		next = self.peek()
 		if type(token) == list:
@@ -102,21 +111,26 @@ class Compiler:
 					return
 		elif next == token: self.nextToken()
 
+	# Rewind to a given position in the code list
 	def rewindTo(self, index):
 		self.index = index
 
+	# Get source line number containing the current token
 	def getLino(self):
 		if self.index >= len(self.tokens):
 			return 0
 		return self.tokens[self.index].lino
 
+	# Issue a warning
 	def warning(self, message):
 		self.warnings.append(f'Warning at line {self.getLino() + 1} of {self.program.name}: {message}')
 
+	# Print all warnings
 	def showWarnings(self):
 		for warning in self.warnings:
 			print(warning)
 
+	# Get the symbol record for the current token (assumes it is a symbol name)
 	def getSymbolRecord(self):
 		token = self.getToken()
 		if not token in self.symbols:
@@ -128,18 +142,23 @@ class Compiler:
 		symbolRecord['used'] = True
 		return symbolRecord
 
+	# Add a value type
 	def addValueType(self):
 		self.valueTypes[self.getToken()] = True
 
+	# Test if a given value is in the value types list
 	def hasValue(self, type):
 		return type in self.valueTypes
 
+	# Compile a program label (a symbol ending with ':')
 	def compileLabel(self, command):
 		return self.compileSymbol(command, self.getToken())
 
+	# Compile a variable
 	def compileVariable(self, command, extra=None):
 		return self.compileSymbol(command, self.nextToken(), extra)
 
+	# Compile a symbol
 	def compileSymbol(self, command, name, extra=None):
 		try:
 			v = self.symbols[name]
@@ -148,7 +167,7 @@ class Compiler:
 		if v:
 			FatalError(self, f'Duplicate symbol name "{name}"')
 			return False
-		self.symbols[name] = self.getPC()
+		self.symbols[name] = self.getCodeSize()
 		command['program'] = self.program
 		command['type'] = 'symbol'
 		command['name'] = name
@@ -161,7 +180,7 @@ class Compiler:
 		command['locked'] = False
 		command['extra'] = extra
 		if 'keyword' in command: command['hasValue'] = self.hasValue(command['keyword'])
-		self.add(command)
+		self.addCommand(command)
 		return True
 
 	# Compile the current token
@@ -171,6 +190,10 @@ class Compiler:
 #		print(f'Compile {token}')
 		if not token:
 			return False
+		if len(self.code) == 0:
+			if self.program.parent == None and hasattr(self.program, 'usingGraphics'):
+				cmd = {'domain': 'graphics', 'keyword': 'init', 'debug': False}
+				self.code.append(cmd)
 		mark = self.getIndex()
 		for domain in self.program.getDomains():
 			handler = domain.keywordHandler(token)
@@ -195,7 +218,7 @@ class Compiler:
 		keyword = self.getToken()
 		if not keyword:
 			return False
-		# print(f'Compile keyword "{keyword}"')
+#		print(f'Compile keyword "{keyword}"')
 		if keyword.endswith(':'):
 			command = {}
 			command['domain'] = None
@@ -209,7 +232,7 @@ class Compiler:
 		self.index = index
 		while True:
 			token = self.tokens[self.index]
-			keyword = token.token
+#			keyword = token.token
 			if self.debugCompile: print(self.script.lines[token.lino])
 #			if keyword != 'else':
 			if self.compileOne() == True:
@@ -221,5 +244,10 @@ class Compiler:
 			else:
 				return False
 
+	# Compile fom the current location, stopping on any of a list of tokens
 	def compileFromHere(self, stopOn):
 		return self.compileFrom(self.getIndex(), stopOn)
+
+	# Compile from the start of the script
+	def compileFromStart(self):
+		return self.compileFrom(0, [])

easycoder/ec_condition.py

@@ -19,7 +19,7 @@ class Condition:
 				condition.domain= domain.getName()
 				return condition
 			self.rewindTo(mark)
-			return None
+		return None
 
 	def testCondition(self, condition):
 		handler = self.program.domainIndex[condition.domain]

easycoder/ec_core.py

@@ -3,7 +3,7 @@ import numbers, base64, binascii, random, requests, paramiko
 from copy import deepcopy
 from psutil import Process
 from datetime import datetime
-from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, NoValueError, NoValueRuntimeError, Condition, Object
+from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, NoValueError, NoValueRuntimeError, Object
 from .ec_handler import Handler
 from .ec_timestamp import getTimestamp
 
@@ -31,13 +31,13 @@ class Core(Handler):
             cmd['keyword'] = 'gotoPC'
             cmd['goto'] = 0
             cmd['debug'] = False
-            skip = self.getPC()
+            skip = self.getCodeSize()
             self.add(cmd)
             # Process the 'or'
-            self.getCommandAt(orHere)['or'] = self.getPC()
+            self.getCommandAt(orHere)['or'] = self.getCodeSize()
             self.compileOne()
             # Fixup the skip
-            self.getCommandAt(skip)['goto'] = self.getPC()
+            self.getCommandAt(skip)['goto'] = self.getCodeSize()
 
     #############################################################################
     # Keyword handlers
@@ -323,7 +323,8 @@ class Core(Handler):
             symbolRecord = self.getVariable(command['var'])
             value = self.getSymbolValue(symbolRecord)
             content = value['content']
-            content.remove(key)
+            if key >= 0 and key < len(content): del(content[key])
+            else: RuntimeError(self.program, f'Index {key} out of range')
             value['content'] = content
             self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
@@ -467,7 +468,7 @@ class Core(Handler):
                 if url != None:
                     command['url'] = url
                     command['or'] = None
-                    get = self.getPC()
+                    get = self.getCodeSize()
                     if self.peek() == 'timeout':
                         self.nextToken()
                         command['timeout'] = self.nextValue()
@@ -555,7 +556,7 @@ class Core(Handler):
         command['condition'] = self.nextCondition()
         self.add(command)
         self.nextToken()
-        pcElse = self.getPC()
+        pcElse = self.getCodeSize()
         cmd = {}
         cmd['lino'] = command['lino']
         cmd['domain'] = 'core'
@@ -568,7 +569,7 @@ class Core(Handler):
         if self.peek() == 'else':
             self.nextToken()
             # Add a 'goto' to skip the 'else'
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['lino'] = command['lino']
             cmd['domain'] = 'core'
@@ -577,15 +578,15 @@ class Core(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the link to the 'else' branch
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
+            self.getCommandAt(pcElse)['goto'] = self.getCodeSize()
             # Process the 'else' branch
             self.nextToken()
             self.compileOne()
             # Fixup the pcNext 'goto'
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
         else:
             # We're already at the next command
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
+            self.getCommandAt(pcElse)['goto'] = self.getCodeSize()
         return True
 
     def r_if(self, command):
@@ -604,7 +605,7 @@ class Core(Handler):
             name = self.nextToken()
             item = [keyword, name]
             imports.append(item)
-            self.symbols[name] = self.getPC()
+            self.symbols[name] = self.getCodeSize()
             variable = {}
             variable['domain'] = None
             variable['name'] = name
@@ -746,7 +747,7 @@ class Core(Handler):
                     else:
                         command['file'] = self.getValue()
                     command['or'] = None
-                    load = self.getPC()
+                    load = self.getCodeSize()
                     self.processOr(command, load)
                     return True
         else:
@@ -915,7 +916,7 @@ class Core(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the link
-            command['goto'] = self.getPC()
+            command['goto'] = self.getCodeSize()
             return True
         return False
 
@@ -1006,7 +1007,7 @@ class Core(Handler):
         else:
             command['result'] = None
         command['or'] = None
-        post = self.getPC()
+        post = self.getCodeSize()
         self.processOr(command, post)
         return True
 
@@ -1105,7 +1106,7 @@ class Core(Handler):
                         FatalError(self.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
                     else:
                         command['or'] = None
-                        self.processOr(command, self.getPC())
+                        self.processOr(command, self.getCodeSize())
                         return True
                 else:
                     FatalError(self.compiler, f'Symbol {self.getToken()} is not a variable')
@@ -1273,7 +1274,7 @@ class Core(Handler):
         else:
             command['file'] = self.getValue()
         command['or'] = None
-        save = self.getPC()
+        save = self.getCodeSize()
         self.processOr(command, save)
         return True
 
@@ -1768,12 +1769,17 @@ class Core(Handler):
                 self.program.importPlugin(f'{source}:{clazz}')
                 return True
             return False
-        elif self.nextIs('graphics'):
-            print('Loading graphics module')
-            from .ec_pyside import Graphics
-            self.program.graphics = Graphics
-            self.program.useClass(Graphics)
-            return True
+        else:
+            token = self.nextToken()
+            if token in ['graphics', 'debugger']:
+                if not hasattr(self.program, 'usingGraphics'):
+                    print('Loading graphics module')
+                    from .ec_pyside import Graphics
+                    self.program.graphics = Graphics
+                    self.program.useClass(Graphics)
+                    self.program.usingGraphics = True
+                if token == 'debugger': self.program.debugging = True
+                return True
         return False
 
     # Declare a general-purpose variable
@@ -1817,10 +1823,10 @@ class Core(Handler):
             return None
         # token = self.getToken()
         command['condition'] = code
-        test = self.getPC()
+        test = self.getCodeSize()
         self.add(command)
         # Set up a goto for when the test fails
-        fail = self.getPC()
+        fail = self.getCodeSize()
         cmd = {}
         cmd['lino'] = command['lino']
         cmd['domain'] = 'core'
@@ -1841,7 +1847,7 @@ class Core(Handler):
         cmd['debug'] = False
         self.add(cmd)
         # Fixup the 'goto' on completion
-        self.getCommandAt(fail)['goto'] = self.getPC()
+        self.getCommandAt(fail)['goto'] = self.getCodeSize()
         return True
 
     def r_while(self, command):
@@ -2631,7 +2637,8 @@ class Core(Handler):
     #############################################################################
     # Compile a condition
     def compileCondition(self):
-        condition = Condition()
+        condition = Object()
+        condition.negate = False
 
         token = self.getToken()
 
@@ -2655,7 +2662,14 @@ class Core(Handler):
             path = self.nextValue()
             condition.path = path
             condition.type = 'exists'
-            token = self.nextToken()
+            self.skip('on')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'ssh':
+                    condition.type = 'sshExists'
+                    condition.target = record['name']
+                    token = self.nextToken()
+            else: token = self.getToken()
             if token == 'exists':
                 return condition
             elif token == 'does':
@@ -2839,6 +2853,17 @@ class Core(Handler):
         test = errormsg != None
         return not test if condition.negate else test
 
+    def c_sshExists(self, condition):
+        path = self.getRuntimeValue(condition.path)
+        ssh = self.getVariable(condition.target)
+        sftp = ssh['sftp']
+        try:
+            with sftp.open(path, 'r') as remote_file: remote_file.read().decode()
+            comparison = True
+        except:
+            comparison = False
+        return not comparison if condition.negate else comparison
+
     def c_starts(self, condition):
         value1 = self.getRuntimeValue(condition.value1)
         value2 = self.getRuntimeValue(condition.value2)

easycoder/ec_handler.py

@@ -22,8 +22,8 @@ class Handler:
 		self.compileVariable = compiler.compileVariable
 		self.rewindTo = compiler.rewindTo
 		self.warning = compiler.warning
-		self.getPC = compiler.getPC
-		self.add = compiler.add
+		self.getCodeSize = compiler.getCodeSize
+		self.add = compiler.addCommand
 		self.getCommandAt = compiler.getCommandAt
 		self.compileOne = compiler.compileOne
 		self.compileFromHere = compiler.compileFromHere

easycoder/ec_keyboard.py

@@ -158,6 +158,8 @@ class KeyboardView(QVBoxLayout):
         for row in rows:
             self.addLayout(row)
 
+###############################################################################
+# VirtualKeyboard Class
 class VirtualKeyboard(QStackedWidget):
     def __init__(self, keyboardType, buttonHeight, receiver, onFinished):
         super().__init__()
@@ -173,6 +175,8 @@ class VirtualKeyboard(QStackedWidget):
         self.addKeyboardLayout2()
         self.addKeyboardLayout3()
 
+    ###########################################################################
+    # Add the first keyboard layout (lowercase letters)
     def addKeyboardLayout0(self):
         rowList = []
 
@@ -214,7 +218,7 @@ class VirtualKeyboard(QStackedWidget):
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickNumbers, None, 'img/numbers.png'),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, ","),
-            KeyboardButton(self.buttonHeight * 5, self.buttonHeight, self.onClickSpace, None, 'skeyboard/pace.png'),
+            KeyboardButton(self.buttonHeight * 5, self.buttonHeight, self.onClickSpace, None, 'keyboard/space.png'),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, "."),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickEnter, None, 'img/enter.png'),
@@ -228,6 +232,8 @@ class VirtualKeyboard(QStackedWidget):
         container.setLayout(keyboardView)
         self.addWidget(container)
 
+    ###########################################################################
+    # Add the second keyboard layout (uppercase letters)
     def addKeyboardLayout1(self):
         rowList = []
 
@@ -283,6 +289,8 @@ class VirtualKeyboard(QStackedWidget):
         container.setLayout(keyboardView)
         self.addWidget(container)
 
+    ###########################################################################
+    # Add the third keyboard layout (numbers and symbols)
     def addKeyboardLayout2(self):
         rowList = []
 
@@ -320,11 +328,11 @@ class VirtualKeyboard(QStackedWidget):
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickLetters, None, 'img/letters.png'),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, ","),
-            KeyboardButton(self.buttonHeight * 6, self.buttonHeight, self.onClickSpace, None, 'img/space.png'),
+            KeyboardButton(self.buttonHeight * 5.2, self.buttonHeight, self.onClickSpace, None, 'keyboard/space.png'),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, "."),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickEnter, None, 'img/enter.png'),
-            QSpacerItem(20, 40, QSizePolicy.Expanding, QSizePolicy.Minimum)
+            QSpacerItem(10, 40, QSizePolicy.Expanding, QSizePolicy.Minimum)
         ])
         rowList.append(row4)
 
@@ -334,6 +342,8 @@ class VirtualKeyboard(QStackedWidget):
         container.setLayout(keyboardView)
         self.addWidget(container)
 
+    ###########################################################################
+    # Add the fourth keyboard layout (additional symbols)
     def addKeyboardLayout3(self):
         rowList = []
 

easycoder/ec_program.py

@@ -34,9 +34,9 @@ class Program:
 		self.domainIndex = {}
 		self.name = '<anon>'
 		self.code = []
+		self.pc = 0
 		self.symbols = {}
 		self.onError = 0
-		self.pc = 0
 		self.debugStep = False
 		self.stack = []
 		self.script = Script(source)
@@ -48,7 +48,6 @@ class Program:
 		self.externalControl = False
 		self.ticker = 0
 		self.running = True
-#		self.start()
 
 	# This is called at 10msec intervals by the GUI code
 	def flushCB(self):
@@ -62,7 +61,7 @@ class Program:
 			module['child'] = self
 		startCompile = time.time()
 		self.tokenise(self.script)
-		if self.compiler.compileFrom(0, []):
+		if self.compiler.compileFromStart():
 			finishCompile = time.time()
 			s = len(self.script.lines)
 			t = len(self.script.tokens)

easycoder/ec_pyside.py

@@ -1,7 +1,7 @@
 import sys
 from functools import partial
 from .ec_handler import Handler
-from .ec_classes import RuntimeError
+from .ec_classes import RuntimeError, Object
 from .ec_border import Border
 from PySide6.QtCore import Qt, QTimer, Signal, QRect
 from PySide6.QtGui import QPixmap, QPainter
@@ -26,6 +26,7 @@ from PySide6.QtWidgets import (
     QSlider,
     QSpinBox,
     QTimeEdit,
+    QLayout,
     QVBoxLayout,
     QHBoxLayout,
     QGridLayout,
@@ -67,13 +68,25 @@ class Graphics(Handler):
             'combobox',
             'widget'
             ]
+    
+    def setWidget(self, record, widget):
+        if record['index'] >= record['elements']:
+            RuntimeError(self.program, f'Index out of range for widget {record["name"]}')
+        if not 'widget' in record:
+            record['widget'] = [None] * record['elements']
+        while len(record['widget']) < record['elements']:
+            record['widget'].append(None)
+        record['widget'][record['index']] = widget
+    
+    def getWidget(self, record):
+        if 'widget' in record and record['widget'] != None:
+            if record['keyword'] in ['layout', 'group']: return record['widget'] 
+            return record['widget'][record['index']]
+        else:
+            return None
 
     def dialogTypes(self):
         return ['confirm', 'lineedit', 'multiline', 'generic']
-    
-    def getWidget(self, record):
-        if record['keyword'] in ['pushbutton']: return self.getSymbolContent(record)
-        else: return record['widget']
 
     class ClickableLineEdit(QLineEdit):
         clicked = Signal()
@@ -114,7 +127,7 @@ class Graphics(Handler):
     # (2) add {widget} to {layout}
     # (3) add stretch {widget} to {layout}
     # (4) add stretch to {layout}
-    # (5) add spacer {size} to {layout}
+    # (5) add spacer [size] {size} to {layout}
     # (6) add {widget} at {col} {row} in {grid layout}
     def k_add(self, command):
         def addToLayout():
@@ -146,6 +159,7 @@ class Graphics(Handler):
         
         elif token == 'spacer':
             self.nextToken()
+            self.skip('size')
             command['widget'] = 'spacer'
             command['size'] = self.nextValue()
             self.skip('to')
@@ -186,19 +200,19 @@ class Graphics(Handler):
     def r_add(self, command):
         if 'value' in command:
             value = self.getRuntimeValue(command['value'])
-            widget = self.getVariable(command['widget'])
-            if widget['keyword'] == 'listbox':
-                widget['widget'].addItem(value)
-            elif widget['keyword'] == 'combobox':
-                if isinstance(value, list): widget['widget'].addItems(value)
-                else: widget['widget'].addItem(value)
+            record = self.getVariable(command['widget'])
+            if record['keyword'] == 'listbox':
+                self.getWidget(record).addItem(value)
+            elif record['keyword'] == 'combobox':
+                if isinstance(value, list): record['widget'].addItems(value)
+                else: self.getWidget(record).addItem(value)
         elif 'row' in command and 'col' in command:
             layout = self.getVariable(command['layout'])['widget']
-            widgetVar = self.getVariable(command['widget'])
-            widget = widgetVar['widget']
+            record = self.getVariable(command['widget'])
+            widget = self.getWidget(record)
             row = self.getRuntimeValue(command['row'])
             col = self.getRuntimeValue(command['col'])
-            if widgetVar['keyword'] == 'layout':
+            if record['keyword'] == 'layout':
                 layout.addLayout(widget, row, col)
             else:
                 layout.addWidget(widget, row, col)
@@ -272,8 +286,41 @@ class Graphics(Handler):
         return False
     
     def r_clear(self, command):
-        widget = self.getVariable(command['name'])['widget']
-        widget.clear()
+
+        def clearLayout(layout: QLayout) -> None:
+            if layout is None:
+                return
+            while layout.count() > 0:
+                item = layout.takeAt(0)
+                if item is None:
+                    continue
+                widget = item.widget()
+                if widget is not None:
+                    # Delete the widget
+                    widget.deleteLater()
+                elif item.layout() is not None:
+                    # Recursively clear sub-layout
+                    clearLayout(item.layout())
+                    item.layout().deleteLater()
+                # The QLayoutItem will be automatically cleaned up by Qt
+
+        def clearWidget(widget: QWidget) -> None:
+            if widget is None:
+                return
+            # Clear the layout first
+            layout = widget.layout()
+            if layout is not None:
+                clearLayout(layout)
+                layout.deleteLater()
+            # Clear any remaining child widgets
+            child_widgets = widget.findChildren(QWidget, "", Qt.FindDirectChildrenOnly)
+            for child in child_widgets:
+                child.deleteLater()
+
+        widget = self.getWidget(self.getVariable(command['name']))
+        clearWidget(widget)
+        return self.nextPC()
+
         return self.nextPC()
 
     # close {window}
@@ -370,17 +417,18 @@ class Graphics(Handler):
         return True
 
     def k_createPushbutton(self, command):
-        text = ''
         while True:
             token = self.peek()
             if token == 'text':
                 self.nextToken()
-                text = self.nextValue()
+                command['text'] = self.nextValue()
+            elif token == 'icon':
+                self.nextToken()
+                command['icon'] = self.nextValue()
             elif token == 'size':
                 self.nextToken()
                 command['size'] = self.nextValue()
             else: break
-        command['text'] = text
         self.add(command)
         return True
 
@@ -562,19 +610,33 @@ class Graphics(Handler):
             elif alignment == 'justify': label.setAlignment(Qt.AlignJustify)
         if 'expand' in command:
             label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
-        record['widget'] = label
+        self.setWidget(record, label)
         return self.nextPC()
     
     def r_createPushbutton(self, command, record):
-        text = self.getRuntimeValue(command['text'])
-        pushbutton = QPushButton(text)
-        pushbutton.setAccessibleName(text)
         if 'size' in command:
-            fm = pushbutton.fontMetrics()
-            c = pushbutton.contentsMargins()
-            w = fm.horizontalAdvance('m') * self.getRuntimeValue(command['size']) + c.left()+c.right()
-            pushbutton.setMaximumWidth(w)
+            size = self.getRuntimeValue(command['size'])
+        else: size = None
+        if 'icon' in command:
+            iconPath = self.getRuntimeValue(command['icon'])
+            pixmap = QPixmap(iconPath)
+            if pixmap.isNull():
+                RuntimeError(self.program, f'Icon not found: {iconPath}')
+            icon = pixmap.scaledToHeight(size if size != None else 24, Qt.SmoothTransformation)
+            pushbutton = QPushButton()
+            pushbutton.setIcon(icon)
+            pushbutton.setIconSize(icon.size())
+        elif 'text' in command:
+            text = self.getRuntimeValue(command['text'])
+            pushbutton = QPushButton(text)
+            pushbutton.setAccessibleName(text)
+            if size != None:
+                fm = pushbutton.fontMetrics()
+                c = pushbutton.contentsMargins()
+                w = fm.horizontalAdvance('m') * self.getRuntimeValue(command['size']) + c.left()+c.right()
+                pushbutton.setMaximumWidth(w)
         self.putSymbolValue(record, pushbutton)
+        self.setWidget(record, pushbutton)
         return self.nextPC()
     
     def r_createCheckBox(self, command, record):
@@ -596,7 +658,7 @@ class Graphics(Handler):
             }
         """)
         checkbox.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
-        record['widget'] = checkbox
+        self.setWidget(record, checkbox)
         return self.nextPC()
     
     def r_createLineEdit(self, command, record):
@@ -607,7 +669,7 @@ class Graphics(Handler):
         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
+        self.setWidget(record, lineinput)
         return self.nextPC()
     
     def r_createMultiLineEdit(self, command, record):
@@ -617,19 +679,19 @@ class Graphics(Handler):
         charHeight = fontMetrics.height()
         textinput.setFixedWidth(charWidth * self.getRuntimeValue(command['cols']))
         textinput.setFixedHeight(charHeight * self.getRuntimeValue(command['rows']))
-        record['widget'] = textinput
+        self.setWidget(record, textinput)
         return self.nextPC()
     
     def r_createListWidget(self, command, record):
-        record['widget'] = QListWidget()
+        self.setWidget(record, QListWidget())
         return self.nextPC()
     
     def r_createComboBox(self, command, record):
-        record['widget'] = QComboBox()
+        self.setWidget(record, QComboBox())
         return self.nextPC()
     
     def r_createWidget(self, command, record):
-        record['widget'] = QWidget()
+        self.setWidget(record, QWidget())
         return self.nextPC()
     
     def r_createDialog(self, command, record):
@@ -757,12 +819,23 @@ class Graphics(Handler):
     def r_group(self, command):
         return self.nextPC()
 
-    # Initialize the graphics environment
-    def k_init(self, command):
-        if self.nextIs('graphics'):
-            self.add(command)
-            return True
+    # hide {widget}
+    def k_hide(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if self.isWidget(record['keyword']):
+                command['widget'] = record['name']
+                self.add(command)
+                return True
         return False
+        
+    def r_hide(self, command):
+        record = self.getVariable(command['widget'])
+        if 'widget' in record: self.getWidget(record).hide()
+        return self.nextPC()
+
+    # Initialize the graphics environment
+    # Unused: def k_init(self, command):
     
     def r_init(self, command):
         self.app = QApplication(sys.argv)
@@ -770,7 +843,22 @@ class Graphics(Handler):
         self.program.screenWidth = screen[0]
         self.program.screenHeight = screen[1]
         print(f'Screen: {self.program.screenWidth}x{self.program.screenHeight}')
-        return self.nextPC()
+        # return self.nextPC()
+        def on_last_window_closed():
+            self.program.kill()
+        def init():
+            self.program.flush(self.nextPC())
+        def flush():
+            if not self.blocked:
+                if self.runOnTick != 0:
+                    self.program.run(self.runOnTick)
+                self.program.flushCB()
+        timer = QTimer()
+        timer.timeout.connect(flush)
+        timer.start(10)
+        QTimer.singleShot(500, init)
+        self.app.lastWindowClosed.connect(on_last_window_closed)
+        self.app.exec()
 
     # Declare a label variable
     def k_label(self, command):
@@ -819,11 +907,11 @@ class Graphics(Handler):
     # on tick
     def k_on(self, command):
         def setupOn():
-            command['goto'] = self.getPC() + 2
+            command['goto'] = self.getCodeSize() + 2
             self.add(command)
             self.nextToken()
             # Step over the click handler
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['domain'] = 'core'
             cmd['lino'] = command['lino']
@@ -840,7 +928,7 @@ class Graphics(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the goto
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
 
         token = self.nextToken()
         command['type'] = token
@@ -860,11 +948,11 @@ class Graphics(Handler):
                     return True
         elif token == 'tick':
             command['tick'] = True
-            command['runOnTick'] = self.getPC() + 2
+            command['runOnTick'] = self.getCodeSize() + 2
             self.add(command)
             self.nextToken()
             # Step over the on tick action
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['domain'] = 'core'
             cmd['lino'] = command['lino']
@@ -881,13 +969,13 @@ class Graphics(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the goto
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
             return True
         return False
     
     def r_on(self, command):
         def run(widget, record):
-            for i, w in enumerate(record['value']):
+            for i, w in enumerate(record['widget']):
                 if w == widget:
                     record['index'] = i
                     self.run(command['goto'])
@@ -941,10 +1029,10 @@ class Graphics(Handler):
         record = self.getVariable(command['name'])
         if variant == 'current':
             if record['keyword'] == 'combobox':
-                widget = record['widget']
+                widget = self.getWidget(record)
                 widget.removeItem(widget.currentIndex())
             if record['keyword'] == 'listbox':
-                widget = record['widget']
+                widget = self.getWidget(record)
                 selectedItem = widget.currentItem()
                 if selectedItem:
                     row = widget.row(selectedItem)
@@ -969,7 +1057,7 @@ class Graphics(Handler):
         return False
     
     def r_select(self, command):
-        widget = self.getVariable(command['widget'])['widget']
+        widget = self.getWidget(self.getVariable(command['widget']))
         if 'index' in command:
             index = self.getRuntimeValue(command['index'])
         else:
@@ -1012,9 +1100,10 @@ class Graphics(Handler):
                     self.skip('to')
                     if self.nextIsSymbol():
                         record = self.getSymbolRecord()
-                        command['layout'] = record['name']
-                        self.add(command)
-                        return True
+                        if record['keyword'] == 'layout':
+                            command['layout'] = record['name']
+                            self.add(command)
+                            return True
         elif token == 'spacing':
             self.skip('of')
             if self.nextIsSymbol():
@@ -1122,25 +1211,26 @@ class Graphics(Handler):
     def r_set(self, command):
         what = command['what']
         if what == 'height':
-            widget = self.getVariable(command['name'])['widget']
+            widget = self.getWidget(self.getVariable(command['name']))
             widget.setFixedHeight(self.getRuntimeValue(command['value']))
         elif what == 'width':
-            widget = self.getVariable(command['name'])['widget']
+            widget = self.getWidget(self.getVariable(command['name']))
             widget.setFixedWidth(self.getRuntimeValue(command['value']))
         elif what == 'layout':
-            content = self.getVariable(command['layout'])['widget']
+            record = self.getVariable(command['layout'])
+            layout = record['widget']
             record = self.getVariable(command['name'])
             keyword = record['keyword']
             if keyword == 'window':
                 window = record['window']
                 container = QWidget()
-                container.setLayout(content)
+                container.setLayout(layout)
                 window.setCentralWidget(container)
             elif keyword == 'widget':
-                widget = record['widget']
-                widget.setLayout(content)
+                widget = self.getWidget(record)
+                widget.setLayout(layout)
         elif what == 'spacing':
-            layout = self.getVariable(command['name'])['widget']
+            layout = self.getWidget(self.getVariable(command['name']))
             layout.setSpacing(self.getRuntimeValue(command['value']))
         elif what == 'text':
             record = self.getVariable(command['name'])
@@ -1158,7 +1248,7 @@ class Graphics(Handler):
             record = self.getVariable(command['name'])
             if record['keyword'] == 'checkbox':
                 state = self.getRuntimeValue(command['value'])
-                record['widget'].setChecked(state)
+                self.getWidget(record).setChecked(state)
         elif what == 'alignment':
             widget = self.getVariable(command['name'])['widget']
             flags = command['value']
@@ -1197,6 +1287,7 @@ class Graphics(Handler):
 
     # show {window}
     # show {dialog}
+    # show {widget}
     # show {messagebox} giving {result}}
     def k_show(self, command):
         if self.nextIsSymbol():
@@ -1210,6 +1301,10 @@ class Graphics(Handler):
                 command['dialog'] = record['name']
                 self.add(command)
                 return True
+            elif self.isWidget(keyword):
+                command['name'] = record['name']
+                self.add(command)
+                return True
             elif keyword == 'messagebox':
                 command['messagebox'] = record['name']
                 self.skip('giving')
@@ -1270,6 +1365,9 @@ class Graphics(Handler):
                 if dialog.exec() == QDialog.Accepted:
                     record['result'] = dialog.textEdit.toPlainText()
                 else: record['result'] = dialog.value
+        elif 'name' in command:
+            record = self.getVariable(command['name'])
+            if 'widget' in record: self.getWidget(record).show()
         return self.nextPC()
 
     # Start the graphics
@@ -1280,21 +1378,22 @@ class Graphics(Handler):
         return False
         
     def r_start(self, command):
-        def on_last_window_closed():
-            self.program.kill()
-        def init():
-            self.program.flush(self.nextPC())
-        def flush():
-            if not self.blocked:
-                if self.runOnTick != 0:
-                    self.program.run(self.runOnTick)
-                self.program.flushCB()
-        timer = QTimer()
-        timer.timeout.connect(flush)
-        timer.start(10)
-        QTimer.singleShot(500, init)
-        self.app.lastWindowClosed.connect(on_last_window_closed)
-        self.app.exec()
+        return self.nextPC()
+        # def on_last_window_closed():
+        #     self.program.kill()
+        # def init():
+        #     self.program.flush(self.nextPC())
+        # def flush():
+        #     if not self.blocked:
+        #         if self.runOnTick != 0:
+        #             self.program.run(self.runOnTick)
+        #         self.program.flushCB()
+        # timer = QTimer()
+        # timer.timeout.connect(flush)
+        # timer.start(10)
+        # QTimer.singleShot(500, init)
+        # self.app.lastWindowClosed.connect(on_last_window_closed)
+        # self.app.exec()
 
     # Declare a widget variable
     def k_widget(self, command):
@@ -1364,38 +1463,38 @@ class Graphics(Handler):
         symbolRecord = self.getVariable(symbolRecord['name'])
         keyword = symbolRecord['keyword']
         if keyword == 'pushbutton':
-            pushbutton = self.getSymbolContent(symbolRecord) # symbolRecord['widget']
+            pushbutton = self.getWidget(symbolRecord)
             v = {}
             v['type'] = 'text'
             v['content'] = pushbutton.accessibleName()
             return v
         elif keyword == 'lineinput':
-            lineinput = symbolRecord['widget']
+            lineinput = self.getWidget(symbolRecord)
             v = {}
             v['type'] = 'text'
             v['content'] = lineinput.displayText()
             return v
         elif keyword == 'multiline':
-            multiline = symbolRecord['widget']
+            multiline = self.getWidget(symbolRecord)
             v = {}
             v['type'] = 'text'
             v['content'] = multiline.toPlainText()
             return v
         elif keyword == 'combobox':
-            combobox = symbolRecord['widget']
+            combobox = self.getWidget(symbolRecord)
             v = {}
             v['type'] = 'text'
             v['content'] = combobox.currentText()
             return v
         elif keyword == 'listbox':
-            listbox = symbolRecord['widget']
+            listbox = self.getWidget(symbolRecord)
             content = listbox.currentItem().text()
             v = {}
             v['type'] = 'text'
             v['content'] = content
             return v
         elif keyword == 'checkbox':
-            checkbox = symbolRecord['widget']
+            checkbox =self.getWidget(symbolRecord)
             content = checkbox.isChecked()
             v = {}
             v['type'] = 'boolean'
@@ -1412,7 +1511,7 @@ class Graphics(Handler):
     def v_count(self, v):
         record = self.getVariable(v['name'])
         keyword = record['keyword']
-        widget = record['widget']
+        widget = self.getWidget(record)
         if keyword in ['combobox', 'listbox']: content = widget.count()
         value = {}
         value['type'] = 'int'
@@ -1422,7 +1521,7 @@ class Graphics(Handler):
     def v_current(self, v):
         record = self.getVariable(v['name'])
         keyword = record['keyword']
-        widget = record['widget']
+        widget = self.getWidget(record)
         if keyword == 'listbox': content = widget.currentItem().text()
         value = {}
         value['type'] = 'text'
@@ -1432,8 +1531,9 @@ class Graphics(Handler):
     #############################################################################
     # Compile a condition
     def compileCondition(self):
-        condition = {}
-        return condition
+        condition = Object()
+        condition.negate = False
+        return None
 
     #############################################################################
     # Condition handlers
@@ -1442,4 +1542,4 @@ class Graphics(Handler):
     # Force the application to exit
     def force_exit(self):
         QApplication.quit()  # Gracefully close the application
-        sys.exit(0)          # Force a complete system exit
+        sys.exit(0)          # Force a complete system exit

{easycoder-251004.1.dist-info → easycoder-251104.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 251004.1
+Version: 251104.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>

easycoder-251104.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+easycoder/__init__.py,sha256=7ZoWrgGr2R_dOw69Yis1-y0u8zR8AAQ24gN0GpfM5rc,339
+easycoder/close.png,sha256=3B9ueRNtEu9E4QNmZhdyC4VL6uqKvGmdfeFxIV9aO_Y,9847
+easycoder/ec_border.py,sha256=KpOy0Jq8jI_6DYGo4jaFvoBP_jTIoAYWrmuHhl-FXA4,2355
+easycoder/ec_classes.py,sha256=YGUiKnVN6T5scoeBmmGDQAtE8xJgaTHi0Exh9A7H2Y4,1750
+easycoder/ec_compiler.py,sha256=2bdB7Bb4Cn_Uj7g0wjDn_gO0gQivqeaFellbgbAT2Hg,6587
+easycoder/ec_condition.py,sha256=uamZrlW3Ej3R4bPDuduGB2f00M80Z1D0qV8muDx4Qfw,784
+easycoder/ec_core.py,sha256=K89KR1z_clnubQgq_-L3SiTTRI4qs2ue1MhuUkB9xoU,100888
+easycoder/ec_handler.py,sha256=doGCMXBCQxvSaD3omKMlXoR_LvQODxV7dZyoWafecyg,2336
+easycoder/ec_keyboard.py,sha256=H8DhPT8-IvAIGgRxCs4qSaF_AQLaS6lxxtDteejbktM,19010
+easycoder/ec_program.py,sha256=aPuZOYWFqGd1jsLDl5M5YmLu5LfFAewF9EZh6zHIbyM,10308
+easycoder/ec_pyside.py,sha256=DwHMsk5kDBXg8feSbkyUinGWPO1a4uH-rcT3F9J4Aiw,58287
+easycoder/ec_timestamp.py,sha256=myQnnF-mT31_1dpQKv2VEAu4BCcbypvMdzq7_DUi1xc,277
+easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
+easycoder/tick.png,sha256=OedASXJJTYvnza4J6Kv5m5lz6DrBfy667zX_WGgtbmM,9127
+easycoder-251104.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-251104.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-251104.1.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+easycoder-251104.1.dist-info/METADATA,sha256=jWlzWZY1kVcRNkxMiIn6SGBsgK3UESTSnMhp8KlG064,6897
+easycoder-251104.1.dist-info/RECORD,,

easycoder-251004.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-easycoder/__init__.py,sha256=q9lIBFHBsL7m8IFo13YFUlg_4clZurFfRFYX7kZnBCo,339
-easycoder/close.png,sha256=3B9ueRNtEu9E4QNmZhdyC4VL6uqKvGmdfeFxIV9aO_Y,9847
-easycoder/ec_border.py,sha256=KpOy0Jq8jI_6DYGo4jaFvoBP_jTIoAYWrmuHhl-FXA4,2355
-easycoder/ec_classes.py,sha256=bejrby7mLHTeAQXhhz-1l8iv6LSbNSy30lW21KJKjXE,1832
-easycoder/ec_compiler.py,sha256=LYwGNs8dcHKXI_nnu1sVFe1N36vjvylcUO_tX_bLjrk,5359
-easycoder/ec_condition.py,sha256=YXvSBQKEzKGCcgUGo3Qp8iHolXmm2BpEm0NimSDszIM,785
-easycoder/ec_core.py,sha256=VTAnhdLp3ftZ1tLPhovKX0PQ1CplmC9x17jH_DfrJsQ,99650
-easycoder/ec_handler.py,sha256=ED08ULiOlZkcs4XHxAguvdPZw_dFXuwGDFLbFuo0kLs,2317
-easycoder/ec_keyboard.py,sha256=ru-HdWolBMZJPyck2s72In9tXFeLJQSPtR1TpjmIo90,18350
-easycoder/ec_program.py,sha256=srVDRlELMElvnkjxmREczUVPkvPXPvanZglN4hKreLI,10324
-easycoder/ec_pyside.py,sha256=bnGwnlYyN-4KI4ECpocrgVx2uGO_9aDrDZNjT4AK7ak,54148
-easycoder/ec_timestamp.py,sha256=myQnnF-mT31_1dpQKv2VEAu4BCcbypvMdzq7_DUi1xc,277
-easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder/tick.png,sha256=OedASXJJTYvnza4J6Kv5m5lz6DrBfy667zX_WGgtbmM,9127
-easycoder-251004.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-251004.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-251004.1.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
-easycoder-251004.1.dist-info/METADATA,sha256=O3CZb_23D8wHS9r_IMN0TLjZVRg1JMgq_SgOuxU6nb8,6897
-easycoder-251004.1.dist-info/RECORD,,