easycoder 241211.3__py2.py3-none-any.whl → 241215.1__py2.py3-none-any.whl

easycoder/__init__.py

@@ -8,5 +8,6 @@ from .ec_handler import *
 from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
+from .ec_graphics import *
 
-__version__ = "241211.3"
+__version__ = "241215.1"

easycoder/ec_compiler.py

@@ -101,7 +101,7 @@ class Compiler:
 
 	def showWarnings(self):
 		for warning in self.warnings:
-			print(f'Line {self.getLino() + 1}: {warning}')
+			print(f'Warning: Line {self.getLino() + 1}: {warning}')
 
 	def getSymbolRecord(self):
 		token = self.getToken()

easycoder/ec_core.py

@@ -38,7 +38,7 @@ class Core(Handler):
                         command['target'] = self.getToken()
                         self.add(command)
                         return True
-                self.warning(f'core.add: Expected value holder')
+                self.warning(f'Core.add: Expected value holder')
             else:
                 # Here we have 2 values so 'giving' must come next
                 command['value2'] = self.getValue()
@@ -46,7 +46,7 @@ class Core(Handler):
                     command['target'] = self.nextToken()
                     self.add(command)
                     return True
-                self.warning(f'core.add: Expected "giving"')
+                self.warning(f'Core.add: Expected "giving"')
         return False
 
     def r_add(self, command):
@@ -90,7 +90,7 @@ class Core(Handler):
                     command['target'] = symbolRecord['name']
                     self.add(command)
                     return True
-                self.warning(f'Variable "{symbolRecord["name"]}" does not hold a value')
+                self.warning(f'Core.append: Variable "{symbolRecord["name"]}" does not hold a value')
         return False
 
     def r_append(self, command):
@@ -248,7 +248,7 @@ class Core(Handler):
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.decrement: Variable "{symbolRecord["name"]}" does not hold a value')
         return False
 
     def r_decrement(self, command):
@@ -272,9 +272,9 @@ class Core(Handler):
                 self.add(command)
                 return True
             else:
-                self.warning(f'"of" expected; got {self.getToken()}')
+                self.warning(f'Core.delete: "of" expected; got {self.getToken()}')
         else:
-            self.warning(f'"file" or "property" expected; got {token}')
+            self.warning(f'Core.delete: "file" or "property" expected; got {token}')
         return False
 
     def r_delete(self, command):
@@ -570,7 +570,7 @@ class Core(Handler):
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.increment: Variable "{symbolRecord["name"]}" does not hold a value')
         return False
 
     def r_increment(self, command):
@@ -729,7 +729,7 @@ class Core(Handler):
             else:
                 FatalError(self.compiler, f'Variable "{self.getToken()}" is not a file')
         else:
-            self.warning(f'core.open: Variable "{self.getToken()}" not declared')
+            self.warning(f'Core.open: Variable "{self.getToken()}" not declared')
         return False
 
     def r_open(self, command):
@@ -1215,7 +1215,7 @@ class Core(Handler):
                         command['target'] = self.getToken()
                         self.add(command)
                         return True
-                self.warning(f'core.take: Expected value holder')
+                self.warning(f'Core.take: Expected value holder')
             else:
                 # Here we have 2 values so 'giving' must come next
                 command['value2'] = self.getValue()
@@ -1227,7 +1227,7 @@ class Core(Handler):
                     else:
                         FatalError(self.program.compiler, f'\'{self.getToken()}\' is not a symbol')
                 else:
-                    self.warning(f'core.take: Expected "giving"')
+                    self.warning(f'Core.take: Expected "giving"')
         return False
 
     def r_take(self, command):
@@ -1402,6 +1402,8 @@ class Core(Handler):
             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')
         if mode == '+':
             value['content'] += 1
         else:
@@ -1467,7 +1469,7 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
         if token == 'property':
@@ -1478,7 +1480,7 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
         if token == 'arg':
@@ -1640,7 +1642,7 @@ class Core(Handler):
                     return value
             return None
 
-        self.warning(f'Core: Unknown token {token}')
+        self.warning(f'Core.compileValue: Unknown token "{token}"')
         return None
 
     #############################################################################
@@ -2115,7 +2117,7 @@ class Core(Handler):
             condition.type = 'boolean'
             return condition
 
-        self.warning(f'I can\'t get a conditional:')
+        self.warning(f'Core.compileCondition: I can\'t get a conditional:')
         return None
 
     def isNegate(self):

easycoder/ec_graphics.py

@@ -0,0 +1,376 @@
+from .ec_classes import FatalError, RuntimeError
+from .ec_handler import Handler
+from .ec_renderer import *
+
+class Graphics(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+
+    def getName(self):
+        return 'graphics'
+
+    #############################################################################
+    # Keyword handlers
+
+    def k_attach(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            command['name'] = record['name']
+            if self.nextIs('to'):
+                value = self.nextValue()
+                command['id'] = value
+            self.add(command)
+        return True
+
+    def r_attach(self, command):
+        target = self.getVariable(command['name'])
+        id = self.getRuntimeValue(command['id'])
+        element = getElement(id)
+        if element == None:
+            FatalError(self.program.compiler, f'There is no screen element with id \'{id}\'')
+            return -1
+        if element['type'] != target['keyword']:
+            FatalError(self.program.compiler, f'Mismatched element type ({element['type']} and {target['keyword']})')
+        self.putSymbolValue(target, {'type': 'text', 'content': id})
+        return self.nextPC()
+
+    def k_close(self, command):
+        if self.nextIs('screen'):
+            self.add(command)
+            return True
+        return False
+
+    def r_close(self, command):
+        closeScreen()
+        return self.nextPC()
+
+    def k_create(self, command):
+        if self.nextIs('screen'):
+            while True:
+                token = self.peek()
+                if token == 'at':
+                    self.nextToken()
+                    command['left'] = self.nextValue()
+                    command['top'] = self.nextValue()
+                elif token == 'size':
+                    self.nextToken()
+                    command['width'] = self.nextValue()
+                    command['height'] = self.nextValue()
+                elif token == 'fill':
+                    self.nextToken()
+                    command['fill'] = self.nextValue()
+                else:
+                    break
+            self.add(command)
+            return True
+        return False
+
+    def r_create(self, command):
+        createScreen(command)
+        return self.nextPC()
+
+    def k_ellipse(self, command):
+        return self.compileVariable(command)
+
+    def r_ellipse(self, command):
+        return self.nextPC()
+
+    def k_image(self, command):
+        return self.compileVariable(command)
+
+    def r_image(self, command):
+        return self.nextPC()
+
+    def k_move(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] in ['rectangle', 'ellipse', 'text', 'image']:
+                command['name'] = record['name']
+                if self.nextToken() in ['by', 'to']:
+                    command['type'] = self.getToken()
+                    command['x'] = self.nextValue()
+                    command['y'] = self.nextValue()
+                    self.add(command)
+                    return True
+        return False
+
+    def r_move(self, command):
+        target = self.getVariable(command['name'])
+        id = self.getSymbolValue(target)['content']
+        type = command['type']
+        x = self.getRuntimeValue(command['x'])
+        y = self.getRuntimeValue(command['y'])
+        if type == 'by':
+            moveElement(id, x, y)
+        elif type == 'to':
+            moveElementTo(id, x, y)
+        return self.nextPC()
+
+    def k_on(self, command):
+        token = self.nextToken()
+        command['type'] = token
+        if token == 'click':
+            command['event'] = token
+            if self.peek() == 'in':
+                self.nextToken()
+            if self.nextIs('screen'):
+                command['target'] = None
+            elif self.isSymbol():
+                target = self.getSymbolRecord()
+                command['target'] = target['name']
+            else:
+                FatalError(self.program.compiler, f'{self.getToken()} is not a screen element')
+                return False
+            command['goto'] = self.getPC() + 2
+            self.add(command)
+            self.nextToken()
+            pcNext = self.getPC()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
+        elif token == 'tick':
+            command['event'] = token
+            command['goto'] = self.getPC() + 2
+            self.add(command)
+            self.nextToken()
+            pcNext = self.getPC()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
+        return False
+
+    def r_on(self, command):
+        pc = command['goto']
+        if command['type'] == 'click':
+            event = command['event']
+            if event == 'click':
+                target = command['target']
+                if target == None:
+                    value = 'screen'
+                else:
+                    widget = self.getVariable(target)
+                value = widget['value'][widget['index']]
+                setOnClick(value['content'], lambda: self.run(pc))
+        elif command['type'] == 'tick':
+            setOnTick(lambda: self.run(pc))
+        return self.nextPC()
+
+    def k_rectangle(self, command):
+        return self.compileVariable(command)
+
+    def r_rectangle(self, command):
+        return self.nextPC()
+
+    def k_render(self, command):
+        command['value'] = self.nextValue()
+        command['parent'] = 'screen'
+        if self.peek() == 'in':
+            self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                type = record['type']
+                name = record['name']
+                if type in ['rectangle', 'ellipse']:
+                    command['parent'] = record['name']
+                    self.add(command)
+                    return True
+                else:
+                    self.warning(f'Graphics.render: {name} cannot be a parent of another element')
+                    return False
+        self.add(command)
+        return True
+        FatalError(self.program.compiler, 'Nothing specified to render')
+        return False
+
+    def r_render(self, command):
+        parent = command['parent']
+        value = self.getRuntimeValue(command['value'])
+        render(value, parent)
+        return self.nextPC()
+
+    def k_set(self, command):
+        if self.peek() == 'the':
+            self.nextToken()
+        token = self.peek()
+        if token == 'text':
+            self.nextToken()
+            command['variant'] = 'setText'
+            if self.peek() == 'of':
+                self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                command['name'] = record['name']
+                if record['keyword'] != 'text':
+                    RuntimeError(command['program'], f'Symbol type is not \'text\'')
+                if self.peek() == 'to':
+                    self.nextToken()
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                    return True
+            return False
+        elif token == 'background':
+            self.nextToken()
+            command['variant'] = 'setBackground'
+            if self.peek() == 'color':
+                self.nextToken()
+            if self.peek() == 'of':
+                self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                command['name'] = record['name']
+                if not record['keyword'] in ['rectangle', 'ellipse']:
+                    RuntimeError(command['program'], f'Symbol type is not \'rectangle\' or \'ellipse\'')
+                if self.peek() == 'to':
+                    self.nextToken()
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                return True
+            return False
+        return False
+
+    def r_set(self, command):
+        variant = command['variant']
+        if variant == 'setText':
+            variable = self.getVariable(command['name'])
+            element = self.getSymbolValue(variable)
+            value = self.getRuntimeValue(command['value'])
+            setText(element['content'], value)
+        elif variant == 'setBackground':
+            variable = self.getVariable(command['name'])
+            element = self.getSymbolValue(variable)
+            value = self.getRuntimeValue(command['value'])
+            setBackground(element['content'], value)
+        return self.nextPC()
+
+    def k_show(self, command):
+        if self.nextIs('screen'):
+            command['name'] = None
+            self.add(command)
+            return True
+        return False
+
+    def r_show(self, command):
+        showScreen()
+        return self.nextPC()
+
+    def k_spec(self, command):
+        return self.compileVariable(command, True)
+
+    def r_spec(self, command):
+        return self.nextPC()
+
+    def k_text(self, command):
+        return self.compileVariable(command)
+
+    def r_text(self, command):
+        return self.nextPC()
+    
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        value['domain'] = 'graphics'
+        token = self.getToken()
+        if self.isSymbol():
+            value['name'] = token
+            symbolRecord = self.getSymbolRecord()
+            keyword = symbolRecord['keyword']
+            if keyword == 'module':
+                value['type'] = 'module'
+                return value
+
+            if symbolRecord['valueHolder'] == True or keyword == 'dictionary':
+                value['type'] = 'symbol'
+                return value
+            return None
+
+        if self.tokenIs('the'):
+            self.nextToken()
+        token = self.getToken()
+
+        value['type'] = token
+
+        if token == 'color':
+            name = self.nextToken()
+            value = {}
+            value['type'] = 'string'
+            value['content'] = name
+            return value
+        
+        elif token == 'attribute':
+            value['attribute'] = self.nextValue()
+            if (self.nextIs('of')):
+                if (self.nextIsSymbol()):
+                    value['name'] = self.getToken()
+                    return value
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    def v_symbol(self, symbolRecord):
+        result = {}
+        if symbolRecord['valueHolder']:
+            symbolValue = self.getSymbolValue(symbolRecord)
+            if symbolValue == None:
+                return None
+            result['type'] = symbolValue['type']
+            content = symbolValue['content']
+            if content == None:
+                return ''
+            result['content'] = content
+            return result
+        else:
+            return ''
+    
+    def v_attribute(self, v):
+        target = self.getVariable(v['name'])
+        attribute = self.getRuntimeValue(v['attribute'])
+        name = target['value'][target['index']]['content']
+        value = {}
+        value['type'] = 'int'
+        value['content'] = getAttribute(name, attribute)
+        return value
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers

easycoder/ec_program.py

@@ -12,18 +12,22 @@ class Program:
 	def __init__(self, argv):
 		print(f'EasyCoder version {version("easycoder")}')
 		scriptName = None
-		if len(argv)>0:
-			scriptName = argv[0]
-		else:
+		if len(argv) == 0:
 			print('No script supplied')
-			exit();
+			exit()
+		self.classes=[Core]
+		for n in range(len(argv)):
+			arg = argv[n]
+			if arg == '-g':
+				from .ec_graphics import Graphics
+				self.classes.append(Graphics)
+			else:
+				scriptName = arg
 
-#		print('Domains:',domains)
 		f = open(scriptName, 'r')
 		source = f.read()
 		f.close()
 		self.argv = argv
-		self.classes=[Core]
 		self.domains = []
 		self.domainIndex = {}
 		self.name = '<anon>'
@@ -40,6 +44,7 @@ class Program:
 		self.processClasses()
 		self.queue = deque()
 
+	def start(self):
 		startCompile = time.time()
 		self.tokenise(self.script)
 		if self.compiler.compileFrom(0, []):
@@ -62,8 +67,11 @@ class Program:
 	# Import a plugin
 	def importPlugin(self, source):
 		args=source.split(':')
+		if len(args)<2:
+			RuntimeError(None, f'Invalid plugin spec "{source}"')
 		idx=args[0].rfind('/')
 		if idx<0:
+			sys.path.append('.')
 			module=args[0]
 		else:
 			sys.path.append(args[0][0:idx])
@@ -318,6 +326,6 @@ class Program:
 # This is the program launcher
 def Main():
 	if (len(sys.argv) > 1):
-		Program(sys.argv[1:])
+		Program(sys.argv[1:]).start()
 	else:
 		print('Syntax: easycoder <scriptname> [plugins]')

easycoder/ec_renderer.py

@@ -0,0 +1,330 @@
+# renderer.py
+
+import sys, json
+import tkinter as tk
+from PIL import *
+
+elements = {}
+zlist = []
+images = {}
+onTick = None
+
+# Set the canvas
+def setCanvas(c):
+    global canvas
+    canvas = c
+
+# Get the canvas
+def getCanvas():
+    global canvas
+    return canvas
+
+def createScreen(values):
+    global screen, canvas, screenLeft, screenTop, running
+    running = True
+    screen = tk.Tk()
+    screen.title('EasyCoder')
+    # screen.attributes('-fullscreen', True)
+
+    # screen.overrideredirect(True)
+    width = values['width']['content'] if 'width' in values else 600
+    height = values['height']['content'] if 'height' in values else 800
+    screenLeft = int((screen.winfo_screenwidth() - width) / 2)
+    screenTop = int((screen.winfo_screenheight() - height) / 2)
+    if 'left' in values:
+        screenLeft = values['left']['content']
+    if 'top' in values:
+        screenTop = values['top']['content'] 
+
+    geometry = str(width) + 'x' + str(height) + '+' + str(screenLeft) + '+' + str(screenTop) 
+    screen.geometry(geometry)
+
+    # Handle a click in the screen
+    def onClick(event):
+        global screenLeft, screenTop, zlist
+        x = event.x
+        y = event.y
+        # print('Clicked at : '+ str(x) +","+ str(y))
+        for i in range(1, len(zlist) + 1):
+            element = zlist[-i]
+            id = list(element)[0]
+            values = element[id]
+            x1 = values['left']
+            x2 = x1 + values['width']
+            y1 = values['top']
+            y2 = y1 + values['height']
+            if x >= x1 and x < x2 and y >= y1 and y < y2:
+                if id in elements:
+                    element = elements[id]
+                    if 'cb' in element:
+                        element['cb']()
+                        break
+                else:
+                    RuntimeError(None, f'Element \'{id}\' does not exist')
+
+    screen.bind('<Button-1>', onClick)
+
+    fill = values['fill']['content'] if 'fill' in values else 'white'
+    canvas = tk.Canvas(master=screen, width=width, height=height, bg=fill)
+    canvas.place(x=0, y=0)
+    setCanvas(canvas)
+
+# Close the screen
+def closeScreen():
+    global screen
+    screen.destroy()
+
+# Set up a click handler in an element
+def setOnClick(id, cb):
+    global elements
+    if id in elements:
+        elements[id]['cb'] = cb
+    else:
+        RuntimeError(None, f'Element \'{id}\' does not exist')
+    return
+
+# Set up the tick handler
+def setOnTick(cb):
+    global onTick
+    onTick = cb
+
+# Show the screen and issue tick callbacks
+def showScreen():
+    global screen, onTick
+    def afterCB(screen):
+        if onTick != None:
+            onTick()
+        screen.after(100, lambda: afterCB(screen))
+    screen.after(1000, lambda: afterCB(screen))
+    screen.mainloop()
+    sys.exit()
+
+# Render a graphic specification
+def render(spec, parent):
+    global elements
+
+    def getValue(args, item):
+        if item in args:
+            if type(item) == int:
+                return item
+            return args[item]
+        return item
+
+    def renderIntoRectangle(widgetType, values, offset, args):
+        global zlist
+        left = getValue(args, values['left']) if 'left' in values else 10
+        top = getValue(args, values['top']) if 'top' in values else 10
+        left = offset['dx'] + left
+        top = offset['dy'] + top
+        width = getValue(args, values['width']) if 'width' in values else 100
+        height = getValue(args, values['height']) if 'height' in values else 100
+        right = left + width
+        bottom = top + height
+        fill = values['fill'] if 'fill' in values else None
+        outline = values['outline'] if 'outline' in values else None
+        if outline != None:
+            outlineWidth = getValue(args, values['outlineWidth']) if 'outlineWidth' in values else 1
+        else:
+            outlineWidth = 0
+        if widgetType == 'rectangle':
+            widgetId = getCanvas().create_rectangle(left, top, right, bottom, fill=fill, outline=outline, width=outlineWidth)
+        elif widgetType == 'ellipse':
+            widgetId = getCanvas().create_oval(left, top, right, bottom, fill=fill, outline=outline, width=outlineWidth)
+        else:
+            return f'Unknown widget type \'{widgetType}\''
+        if 'name' in values:
+            widgetName = getValue(args, values['name'])
+        else:
+            widgetName = None
+        widgetSpec = {
+            "type": widgetType,
+            "name": widgetName,
+            "id": widgetId,
+            "left": left,
+            "top": top,
+            "width": width,
+            "height": height,
+            "children": []
+        }
+        elements[widgetName] = widgetSpec
+        zlist.append({widgetName: widgetSpec})
+        if '#' in values:
+            children = values['#']
+            if type(children) == list:
+                for item in children:
+                    if item in values:
+                        child = values[item]
+                        childSpec = renderWidget(child, {'dx': left, 'dy': top}, args)
+                        widgetSpec['children'].append(childSpec['name'])
+            else:
+                child = values[children]
+                childSpec = renderWidget(child, {'dx': left, 'dy': top}, args)
+                widgetSpec['children'].append(childSpec['name'])
+        return widgetSpec
+   
+    def renderText(values, offset, args):
+        left = getValue(args, values['left']) if 'left' in values else 10
+        top = getValue(args, values['top']) if 'top' in values else 10
+        left = offset['dx'] + left
+        top = offset['dy'] + top
+        width = getValue(args, values['width']) if 'width' in values else 100
+        height = getValue(args, values['height']) if 'height' in values else 100
+        right = left + width
+        bottom = top + height
+        shape = getValue(args, values['shape']) if 'shape' in values else 'rectangle'
+        fill = getValue(args, values['fill']) if 'fill' in values else None
+        outline = getValue(args, values['outline']) if 'outline' in values else None
+        outlineWidth = getValue(args, values['outlineWidth']) if 'outlineWidth' in values else 0 if outline == None else 1
+        color = getValue(args, values['color']) if 'color' in values else None
+        text = getValue(args, values['text']) if 'text' in values else ''
+        fontFace = getValue(args, values['fontFace']) if 'fontFace' in values else 'Helvetica'
+        fontWeight = getValue(args, values['fontWeight']) if 'fontWeight' in values else 'normal'
+        fontSize = round(height*2/5) if shape == 'ellipse' else round(height*3/5)
+        fontTop = top + height/2
+        if 'fontSize' in values:
+            fontSize = getValue(args, values['fontSize'])
+            fontTop = top + round(fontSize * 5 / 4)
+        adjust = round(fontSize/5) if shape == 'ellipse' else 0
+        align = getValue(args, values['align']) if 'align' in values else 'center'
+        if align == 'left':
+            xoff = round(fontSize/5)
+            anchor = 'w'
+        elif align == 'right':
+            xoff = width - round(fontSize/5)
+            anchor = 'e'
+        else:
+            xoff = width/2
+            anchor = 'center'
+        if xoff < 3:
+            xoff = 3
+        if shape == 'ellipse':
+            containerId = getCanvas().create_oval(left, top, right, bottom, fill=fill, outline=outline, width=outlineWidth)
+        else:
+            containerId = getCanvas().create_rectangle(left, top, right, bottom, fill=fill, outline=outline, width=outlineWidth)
+        textId = canvas.create_text(left + xoff, fontTop + adjust, fill=color, font=f'"{fontFace}" {fontSize} {fontWeight}', text=text, anchor=anchor)
+        if 'name' in values:
+            widgetName = getValue(args, values['name'])
+        else:
+            widgetName = None
+        widgetSpec = {
+            "type": "text",
+            "name": widgetName,
+            "id": textId,
+            "containerId": containerId,
+            "left": left,
+            "top": top,
+            "width": width,
+            "height": height
+        }
+        elements[widgetName] = widgetSpec
+        zlist.append({widgetName: widgetSpec})
+        return widgetSpec
+
+    def renderImage(values, offset, args):
+        global images
+        left = getValue(args, values['left']) if 'left' in values else 10
+        top = getValue(args, values['top']) if 'top' in values else 10
+        left = offset['dx'] + left
+        top = offset['dy'] + top
+        width = getValue(args, values['width']) if 'width' in values else 100
+        height = getValue(args, values['height']) if 'height' in values else 100
+        right = left + width
+        bottom = top + height
+        src = getValue(args, values['src']) if 'src' in values else None
+        containerId = getCanvas().create_rectangle(left, top, right, bottom, width=0)
+        if 'name' in values:
+            widgetName = values['name']
+        else:
+            widgetName = None
+        widgetSpec = {
+            "type": "image",
+            "nme": widgetName,
+            "id": containerId,
+            "left": left,
+            "top": top,
+            "width": width,
+            "height": height
+        }
+        elements[widgetName] = widgetSpec
+        zlist.append({widgetName: widgetSpec})
+        if src == None:
+            raise(Exception(f'No image source given for \'{id}\''))
+        img = (Image.open(src))
+        resized_image= img.resize((width, height), Image.ANTIALIAS)
+        new_image= ImageTk.PhotoImage(resized_image)
+        imageid = getCanvas().create_image(left, top, anchor='nw', image=new_image)
+        images[containerId] = {'id': imageid, "image": new_image}
+        return widgetSpec
+
+    # Create a canvas or render a widget
+    def renderWidget(widget, offset, args):
+        widgetType = widget['type']
+        if widgetType in ['rectangle', 'ellipse']:
+            return renderIntoRectangle(widgetType, widget, offset, args)
+        elif widgetType == 'text':
+            return renderText(widget, offset, args)
+        elif widgetType == 'image':
+            return renderImage(widget, offset, args)
+
+    # Render a complete specification
+    def renderSpec(spec, offset, args):
+        widgets = spec['#']
+        # If a list, iterate it
+        if type(widgets) is list:
+            for widget in widgets:
+                renderWidget(spec[widget], offset, args)
+        # Otherwise, process the single widget
+        else:
+            renderWidget(spec[widgets], offset, args)
+
+    # Main entry point
+    offset = {'dx': 0, 'dy': 0}
+    if parent != screen:
+        RuntimeError(None, 'Can\'t yet render into parent widget')
+
+    # If it'a string, process it
+    if type(spec) is str:
+        renderSpec(json.loads(spec), offset, {})
+
+    # If it's a 'dict', extract the spec and the args
+    if type(spec) is dict:
+        args = spec['args']
+        spec = json.loads(spec['spec'])
+        renderSpec(spec, offset, args)
+
+# Get the widget whose name is given
+def getElement(name):
+    global elements
+    if name in elements:
+        return elements[name]
+    else:
+        RuntimeError(None, f'Element \'{name}\' does not exist')
+
+# Set the content of a text widget
+def setText(name, value):
+    getCanvas().itemconfig(getElement(name)['id'], text=value)
+
+# Set the background of a rectangle or ellipse widget
+def setBackground(name, value):
+    id = getElement(name)['id']
+    getCanvas().itemconfig(getElement(name)['id'], fill=value)
+    
+# Move an element by an amount
+def moveElement(name, dx, dy):
+    element = getElement(name)
+    getCanvas().move(element['id'], dx, dy)
+    element['left'] += dx
+    element['top'] += dy
+    for childName in element['children']:
+        element = getElement(childName)
+        getCanvas().move(element['id'], dx, dy)
+
+# Move an element to a new location
+def moveElementTo(name, left, top):
+    element = getElement(name)
+    moveElement(name, left - element['left'], top - element['top'])
+
+# Get an attribute of an element
+def getAttribute(name, attribute):
+    element = getElement(name)
+    return element[attribute]

{easycoder-241211.3.dist-info → easycoder-241215.1.dist-info}/METADATA

@@ -1,19 +1,20 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 241211.3
-Summary: EasyCoder for Python
+Version: 241215.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>
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: MIT License
 Requires-Dist: pytz
-Project-URL: Home, https://github.com/easycoder
+Project-URL: Home, https://github.com/easycoder/easycoder-py
 
 # Introduction
 This is the Python version of **_EasyCoder_**, a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line.
 
 The JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, is at
 
-Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)
+Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)  
 Website: [https://easycoder.github.io](https://easycoder.github.io)
 
 ## Quick Start
@@ -58,6 +59,11 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `tests.ecs` is a test program containing many of the EasyCoder features  
 `fizzbuzz.ecs` is a simple programming challenge often given at job interviews
 
+## Graphical programmming
+**_EasyCoder_** is currently being extended to include a graphical programming environment. A single demo script `graphics-demo.ecs` is included in the `scripts` directory. To run it, first install the Python graphics library if it's not already present on your system. On Linux this is done with `sudo apt install python3-tk`. On Windows it's `pip install tk`. Then give the command `easycoder -g scripts/graphics-demo.ecs`.
+
+As development progresses this demo script will be extended to include new features as they are added. **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **EasyCoder_** environment, in other Python programs.
+
 ## EasyCoder programming reference
 
 The language comprises a general-purpose core package, which can be enhanced by plugins to provide special features on demand.

easycoder-241215.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+easycoder/__init__.py,sha256=aW_U1vTxPggcn2FkBFYhEwPI9qsf4KZPbV2hNZk24B4,289
+easycoder/ec_classes.py,sha256=mRvIk2d-yc20u54oX8fauKeYy-z_g30Otbl-dn5O6T4,1486
+easycoder/ec_compiler.py,sha256=s7M3Jl6z0X_tp-QW4p3v7ac2fhL_bf0uw1GHebqt1Ug,4638
+easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
+easycoder/ec_core.py,sha256=NfXNTyxmsU4_f3JTTFMUzgsfCRL9se8rdVfwqBC_1wM,76452
+easycoder/ec_graphics.py,sha256=qHkZkpT5WM0Y-vHXXLoiqGGS_1qWiajKBYqS1MRSicA,12786
+easycoder/ec_handler.py,sha256=WDDIz0awD3vSQZ149rgbUWsClt6zXqED8ByXQJ5p1Ds,2200
+easycoder/ec_program.py,sha256=MHPHEYHoU5zUVsnkL30kyUxtFph-8naVlDGN2hHsKpw,8103
+easycoder/ec_renderer.py,sha256=SiKmUg5SWjlquscZt7UwD6EFlYLZWORmzMl5FrNz7u0,12082
+easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
+easycoder/ec_value.py,sha256=aOvSF6bM1iKpcLLm0zyGerxHixBkyjE3iYl1Bx6jmzU,2381
+easycoder-241215.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-241215.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-241215.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-241215.1.dist-info/METADATA,sha256=J5XUm0EhpR-bLU1FizskpkVt1F4ZyHUHHmeuug71iAQ,4096
+easycoder-241215.1.dist-info/RECORD,,

easycoder-241211.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-easycoder/__init__.py,sha256=vys8r-4skG-XdH6b0L8eS4WpTpCkVdV_-RaKL1snTMA,262
-easycoder/ec_classes.py,sha256=mRvIk2d-yc20u54oX8fauKeYy-z_g30Otbl-dn5O6T4,1486
-easycoder/ec_compiler.py,sha256=1z5U92uzUdCOO5-k0VXLnU581iAhwzQga04kfdTlpMY,4629
-easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
-easycoder/ec_core.py,sha256=j4YPwERad7iKSaUpbcFG6d5dlyLETK3M-np132G6d9s,76188
-easycoder/ec_handler.py,sha256=WDDIz0awD3vSQZ149rgbUWsClt6zXqED8ByXQJ5p1Ds,2200
-easycoder/ec_program.py,sha256=U5QRxcyYycTugyu1ew8prk6NUEqnvcGuFJSY9stN8vY,7870
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=aOvSF6bM1iKpcLLm0zyGerxHixBkyjE3iYl1Bx6jmzU,2381
-easycoder-241211.3.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-241211.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-241211.3.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-241211.3.dist-info/METADATA,sha256=kk6Hmmny8KtnC3gQhlpZEHYHV5zAU-8dGZc_KPKsRbM,3242
-easycoder-241211.3.dist-info/RECORD,,